Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/acpi/video.c

  1 /*
  2  *  video.c - ACPI Video Driver
  3  *
  4  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
  5  *  Copyright (C) 2004 Bruno Ducrot <ducrot@poupinou.org>
  6  *  Copyright (C) 2006 Thomas Tuttle <linux-kernel@ttuttle.net>
  7  *
  8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  9  *
 10  *  This program is free software; you can redistribute it and/or modify
 11  *  it under the terms of the GNU General Public License as published by
 12  *  the Free Software Foundation; either version 2 of the License, or (at
 13  *  your option) any later version.
 14  *
 15  *  This program is distributed in the hope that it will be useful, but
 16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
 17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 18  *  General Public License for more details.
 19  *
 20  *  You should have received a copy of the GNU General Public License along
 21  *  with this program; if not, write to the Free Software Foundation, Inc.,
 22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 23  *
 24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 25  */
 26 
 27 #include <linux/kernel.h>
 28 #include <linux/module.h>
 29 #include <linux/init.h>
 30 #include <linux/types.h>
 31 #include <linux/list.h>
 32 #include <linux/mutex.h>
 33 #include <linux/input.h>
 34 #include <linux/backlight.h>
 35 #include <linux/thermal.h>
 36 #include <linux/sort.h>
 37 #include <linux/pci.h>
 38 #include <linux/pci_ids.h>
 39 #include <linux/slab.h>
 40 #include <linux/dmi.h>
 41 #include <linux/suspend.h>
 42 #include <linux/acpi.h>
 43 #include <acpi/video.h>
 44 #include <asm/uaccess.h>
 45 
 46 #include "internal.h"
 47 
 48 #define ACPI_VIDEO_BUS_NAME             "Video Bus"
 49 #define ACPI_VIDEO_DEVICE_NAME          "Video Device"
 50 #define ACPI_VIDEO_NOTIFY_SWITCH        0x80
 51 #define ACPI_VIDEO_NOTIFY_PROBE         0x81
 52 #define ACPI_VIDEO_NOTIFY_CYCLE         0x82
 53 #define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT   0x83
 54 #define ACPI_VIDEO_NOTIFY_PREV_OUTPUT   0x84
 55 
 56 #define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS      0x85
 57 #define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS        0x86
 58 #define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS        0x87
 59 #define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS       0x88
 60 #define ACPI_VIDEO_NOTIFY_DISPLAY_OFF           0x89
 61 
 62 #define MAX_NAME_LEN    20
 63 
 64 #define _COMPONENT              ACPI_VIDEO_COMPONENT
 65 ACPI_MODULE_NAME("video");
 66 
 67 MODULE_AUTHOR("Bruno Ducrot");
 68 MODULE_DESCRIPTION("ACPI Video Driver");
 69 MODULE_LICENSE("GPL");
 70 
 71 static bool brightness_switch_enabled = 1;
 72 module_param(brightness_switch_enabled, bool, 0644);
 73 
 74 /*
 75  * By default, we don't allow duplicate ACPI video bus devices
 76  * under the same VGA controller
 77  */
 78 static bool allow_duplicates;
 79 module_param(allow_duplicates, bool, 0644);
 80 
 81 /*
 82  * For Windows 8 systems: used to decide if video module
 83  * should skip registering backlight interface of its own.
 84  */
 85 static int use_native_backlight_param = -1;
 86 module_param_named(use_native_backlight, use_native_backlight_param, int, 0444);
 87 static bool use_native_backlight_dmi = true;
 88 
 89 static int register_count;
 90 static struct mutex video_list_lock;
 91 static struct list_head video_bus_head;
 92 static int acpi_video_bus_add(struct acpi_device *device);
 93 static int acpi_video_bus_remove(struct acpi_device *device);
 94 static void acpi_video_bus_notify(struct acpi_device *device, u32 event);
 95 
 96 static const struct acpi_device_id video_device_ids[] = {
 97         {ACPI_VIDEO_HID, 0},
 98         {"", 0},
 99 };
100 MODULE_DEVICE_TABLE(acpi, video_device_ids);
101 
102 static struct acpi_driver acpi_video_bus = {
103         .name = "video",
104         .class = ACPI_VIDEO_CLASS,
105         .ids = video_device_ids,
106         .ops = {
107                 .add = acpi_video_bus_add,
108                 .remove = acpi_video_bus_remove,
109                 .notify = acpi_video_bus_notify,
110                 },
111 };
112 
113 struct acpi_video_bus_flags {
114         u8 multihead:1;         /* can switch video heads */
115         u8 rom:1;               /* can retrieve a video rom */
116         u8 post:1;              /* can configure the head to */
117         u8 reserved:5;
118 };
119 
120 struct acpi_video_bus_cap {
121         u8 _DOS:1;              /* Enable/Disable output switching */
122         u8 _DOD:1;              /* Enumerate all devices attached to display adapter */
123         u8 _ROM:1;              /* Get ROM Data */
124         u8 _GPD:1;              /* Get POST Device */
125         u8 _SPD:1;              /* Set POST Device */
126         u8 _VPO:1;              /* Video POST Options */
127         u8 reserved:2;
128 };
129 
130 struct acpi_video_device_attrib {
131         u32 display_index:4;    /* A zero-based instance of the Display */
132         u32 display_port_attachment:4;  /* This field differentiates the display type */
133         u32 display_type:4;     /* Describe the specific type in use */
134         u32 vendor_specific:4;  /* Chipset Vendor Specific */
135         u32 bios_can_detect:1;  /* BIOS can detect the device */
136         u32 depend_on_vga:1;    /* Non-VGA output device whose power is related to
137                                    the VGA device. */
138         u32 pipe_id:3;          /* For VGA multiple-head devices. */
139         u32 reserved:10;        /* Must be 0 */
140         u32 device_id_scheme:1; /* Device ID Scheme */
141 };
142 
143 struct acpi_video_enumerated_device {
144         union {
145                 u32 int_val;
146                 struct acpi_video_device_attrib attrib;
147         } value;
148         struct acpi_video_device *bind_info;
149 };
150 
151 struct acpi_video_bus {
152         struct acpi_device *device;
153         bool backlight_registered;
154         bool backlight_notifier_registered;
155         u8 dos_setting;
156         struct acpi_video_enumerated_device *attached_array;
157         u8 attached_count;
158         struct acpi_video_bus_cap cap;
159         struct acpi_video_bus_flags flags;
160         struct list_head video_device_list;
161         struct mutex device_list_lock;  /* protects video_device_list */
162         struct list_head entry;
163         struct input_dev *input;
164         char phys[32];  /* for input device */
165         struct notifier_block pm_nb;
166         struct notifier_block backlight_nb;
167 };
168 
169 struct acpi_video_device_flags {
170         u8 crt:1;
171         u8 lcd:1;
172         u8 tvout:1;
173         u8 dvi:1;
174         u8 bios:1;
175         u8 unknown:1;
176         u8 notify:1;
177         u8 reserved:1;
178 };
179 
180 struct acpi_video_device_cap {
181         u8 _ADR:1;              /* Return the unique ID */
182         u8 _BCL:1;              /* Query list of brightness control levels supported */
183         u8 _BCM:1;              /* Set the brightness level */
184         u8 _BQC:1;              /* Get current brightness level */
185         u8 _BCQ:1;              /* Some buggy BIOS uses _BCQ instead of _BQC */
186         u8 _DDC:1;              /* Return the EDID for this device */
187 };
188 
189 struct acpi_video_brightness_flags {
190         u8 _BCL_no_ac_battery_levels:1; /* no AC/Battery levels in _BCL */
191         u8 _BCL_reversed:1;             /* _BCL package is in a reversed order */
192         u8 _BQC_use_index:1;            /* _BQC returns an index value */
193 };
194 
195 struct acpi_video_device_brightness {
196         int curr;
197         int count;
198         int *levels;
199         struct acpi_video_brightness_flags flags;
200 };
201 
202 struct acpi_video_device {
203         unsigned long device_id;
204         struct acpi_video_device_flags flags;
205         struct acpi_video_device_cap cap;
206         struct list_head entry;
207         struct delayed_work switch_brightness_work;
208         int switch_brightness_event;
209         struct acpi_video_bus *video;
210         struct acpi_device *dev;
211         struct acpi_video_device_brightness *brightness;
212         struct backlight_device *backlight;
213         struct thermal_cooling_device *cooling_dev;
214 };
215 
216 static const char device_decode[][30] = {
217         "motherboard VGA device",
218         "PCI VGA device",
219         "AGP VGA device",
220         "UNKNOWN",
221 };
222 
223 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data);
224 static void acpi_video_device_rebind(struct acpi_video_bus *video);
225 static void acpi_video_device_bind(struct acpi_video_bus *video,
226                                    struct acpi_video_device *device);
227 static int acpi_video_device_enumerate(struct acpi_video_bus *video);
228 static int acpi_video_device_lcd_set_level(struct acpi_video_device *device,
229                         int level);
230 static int acpi_video_device_lcd_get_level_current(
231                         struct acpi_video_device *device,
232                         unsigned long long *level, bool raw);
233 static int acpi_video_get_next_level(struct acpi_video_device *device,
234                                      u32 level_current, u32 event);
235 static void acpi_video_switch_brightness(struct work_struct *work);
236 
237 static bool acpi_video_use_native_backlight(void)
238 {
239         if (use_native_backlight_param != -1)
240                 return use_native_backlight_param;
241         else
242                 return use_native_backlight_dmi;
243 }
244 
245 bool acpi_video_verify_backlight_support(void)
246 {
247         if (acpi_osi_is_win8() && acpi_video_use_native_backlight() &&
248             backlight_device_registered(BACKLIGHT_RAW))
249                 return false;
250         return acpi_video_backlight_support();
251 }
252 EXPORT_SYMBOL_GPL(acpi_video_verify_backlight_support);
253 
254 /* backlight device sysfs support */
255 static int acpi_video_get_brightness(struct backlight_device *bd)
256 {
257         unsigned long long cur_level;
258         int i;
259         struct acpi_video_device *vd = bl_get_data(bd);
260 
261         if (acpi_video_device_lcd_get_level_current(vd, &cur_level, false))
262                 return -EINVAL;
263         for (i = 2; i < vd->brightness->count; i++) {
264                 if (vd->brightness->levels[i] == cur_level)
265                         /*
266                          * The first two entries are special - see page 575
267                          * of the ACPI spec 3.0
268                          */
269                         return i - 2;
270         }
271         return 0;
272 }
273 
274 static int acpi_video_set_brightness(struct backlight_device *bd)
275 {
276         int request_level = bd->props.brightness + 2;
277         struct acpi_video_device *vd = bl_get_data(bd);
278 
279         cancel_delayed_work(&vd->switch_brightness_work);
280         return acpi_video_device_lcd_set_level(vd,
281                                 vd->brightness->levels[request_level]);
282 }
283 
284 static const struct backlight_ops acpi_backlight_ops = {
285         .get_brightness = acpi_video_get_brightness,
286         .update_status  = acpi_video_set_brightness,
287 };
288 
289 /* thermal cooling device callbacks */
290 static int video_get_max_state(struct thermal_cooling_device *cooling_dev, unsigned
291                                long *state)
292 {
293         struct acpi_device *device = cooling_dev->devdata;
294         struct acpi_video_device *video = acpi_driver_data(device);
295 
296         *state = video->brightness->count - 3;
297         return 0;
298 }
299 
300 static int video_get_cur_state(struct thermal_cooling_device *cooling_dev, unsigned
301                                long *state)
302 {
303         struct acpi_device *device = cooling_dev->devdata;
304         struct acpi_video_device *video = acpi_driver_data(device);
305         unsigned long long level;
306         int offset;
307 
308         if (acpi_video_device_lcd_get_level_current(video, &level, false))
309                 return -EINVAL;
310         for (offset = 2; offset < video->brightness->count; offset++)
311                 if (level == video->brightness->levels[offset]) {
312                         *state = video->brightness->count - offset - 1;
313                         return 0;
314                 }
315 
316         return -EINVAL;
317 }
318 
319 static int
320 video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long state)
321 {
322         struct acpi_device *device = cooling_dev->devdata;
323         struct acpi_video_device *video = acpi_driver_data(device);
324         int level;
325 
326         if (state >= video->brightness->count - 2)
327                 return -EINVAL;
328 
329         state = video->brightness->count - state;
330         level = video->brightness->levels[state - 1];
331         return acpi_video_device_lcd_set_level(video, level);
332 }
333 
334 static const struct thermal_cooling_device_ops video_cooling_ops = {
335         .get_max_state = video_get_max_state,
336         .get_cur_state = video_get_cur_state,
337         .set_cur_state = video_set_cur_state,
338 };
339 
340 /*
341  * --------------------------------------------------------------------------
342  *                             Video Management
343  * --------------------------------------------------------------------------
344  */
345 
346 static int
347 acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
348                                    union acpi_object **levels)
349 {
350         int status;
351         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
352         union acpi_object *obj;
353 
354 
355         *levels = NULL;
356 
357         status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
358         if (!ACPI_SUCCESS(status))
359                 return status;
360         obj = (union acpi_object *)buffer.pointer;
361         if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
362                 printk(KERN_ERR PREFIX "Invalid _BCL data\n");
363                 status = -EFAULT;
364                 goto err;
365         }
366 
367         *levels = obj;
368 
369         return 0;
370 
371 err:
372         kfree(buffer.pointer);
373 
374         return status;
375 }
376 
377 static int
378 acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
379 {
380         int status;
381         int state;
382 
383         status = acpi_execute_simple_method(device->dev->handle,
384                                             "_BCM", level);
385         if (ACPI_FAILURE(status)) {
386                 ACPI_ERROR((AE_INFO, "Evaluating _BCM failed"));
387                 return -EIO;
388         }
389 
390         device->brightness->curr = level;
391         for (state = 2; state < device->brightness->count; state++)
392                 if (level == device->brightness->levels[state]) {
393                         if (device->backlight)
394                                 device->backlight->props.brightness = state - 2;
395                         return 0;
396                 }
397 
398         ACPI_ERROR((AE_INFO, "Current brightness invalid"));
399         return -EINVAL;
400 }
401 
402 /*
403  * For some buggy _BQC methods, we need to add a constant value to
404  * the _BQC return value to get the actual current brightness level
405  */
406 
407 static int bqc_offset_aml_bug_workaround;
408 static int __init video_set_bqc_offset(const struct dmi_system_id *d)
409 {
410         bqc_offset_aml_bug_workaround = 9;
411         return 0;
412 }
413 
414 static int __init video_set_use_native_backlight(const struct dmi_system_id *d)
415 {
416         use_native_backlight_dmi = true;
417         return 0;
418 }
419 
420 static int __init video_disable_native_backlight(const struct dmi_system_id *d)
421 {
422         use_native_backlight_dmi = false;
423         return 0;
424 }
425 
426 static struct dmi_system_id video_dmi_table[] __initdata = {
427         /*
428          * Broken _BQC workaround http://bugzilla.kernel.org/show_bug.cgi?id=13121
429          */
430         {
431          .callback = video_set_bqc_offset,
432          .ident = "Acer Aspire 5720",
433          .matches = {
434                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
435                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
436                 },
437         },
438         {
439          .callback = video_set_bqc_offset,
440          .ident = "Acer Aspire 5710Z",
441          .matches = {
442                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
443                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5710Z"),
444                 },
445         },
446         {
447          .callback = video_set_bqc_offset,
448          .ident = "eMachines E510",
449          .matches = {
450                 DMI_MATCH(DMI_BOARD_VENDOR, "EMACHINES"),
451                 DMI_MATCH(DMI_PRODUCT_NAME, "eMachines E510"),
452                 },
453         },
454         {
455          .callback = video_set_bqc_offset,
456          .ident = "Acer Aspire 5315",
457          .matches = {
458                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
459                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
460                 },
461         },
462         {
463          .callback = video_set_bqc_offset,
464          .ident = "Acer Aspire 7720",
465          .matches = {
466                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
467                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
468                 },
469         },
470         {
471          .callback = video_set_use_native_backlight,
472          .ident = "ThinkPad X230",
473          .matches = {
474                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
475                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X230"),
476                 },
477         },
478         {
479          .callback = video_set_use_native_backlight,
480          .ident = "ThinkPad T430 and T430s",
481          .matches = {
482                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
483                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T430"),
484                 },
485         },
486         {
487          .callback = video_set_use_native_backlight,
488          .ident = "ThinkPad T430",
489          .matches = {
490                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
491                 DMI_MATCH(DMI_PRODUCT_VERSION, "2349D15"),
492                 },
493         },
494         {
495          .callback = video_set_use_native_backlight,
496          .ident = "ThinkPad T431s",
497          .matches = {
498                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
499                 DMI_MATCH(DMI_PRODUCT_VERSION, "20AACTO1WW"),
500                 },
501         },
502         {
503          .callback = video_set_use_native_backlight,
504          .ident = "ThinkPad Edge E530",
505          .matches = {
506                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
507                 DMI_MATCH(DMI_PRODUCT_VERSION, "3259A2G"),
508                 },
509         },
510         {
511          .callback = video_set_use_native_backlight,
512          .ident = "ThinkPad Edge E530",
513          .matches = {
514                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
515                 DMI_MATCH(DMI_PRODUCT_VERSION, "3259CTO"),
516                 },
517         },
518         {
519          .callback = video_set_use_native_backlight,
520          .ident = "ThinkPad Edge E530",
521          .matches = {
522                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
523                 DMI_MATCH(DMI_PRODUCT_VERSION, "3259HJG"),
524                 },
525         },
526         {
527          .callback = video_set_use_native_backlight,
528          .ident = "ThinkPad W530",
529          .matches = {
530                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
531                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad W530"),
532                 },
533         },
534         {
535          .callback = video_set_use_native_backlight,
536         .ident = "ThinkPad X1 Carbon",
537         .matches = {
538                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
539                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X1 Carbon"),
540                 },
541         },
542         {
543          .callback = video_set_use_native_backlight,
544          .ident = "Lenovo Yoga 13",
545          .matches = {
546                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
547                 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo IdeaPad Yoga 13"),
548                 },
549         },
550         {
551          .callback = video_set_use_native_backlight,
552          .ident = "Lenovo Yoga 2 11",
553          .matches = {
554                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
555                 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2 11"),
556                 },
557         },
558         {
559         .callback = video_set_use_native_backlight,
560         .ident = "Thinkpad Helix",
561         .matches = {
562                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
563                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad Helix"),
564                 },
565         },
566         {
567          .callback = video_set_use_native_backlight,
568          .ident = "Dell Inspiron 7520",
569          .matches = {
570                 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
571                 DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7520"),
572                 },
573         },
574         {
575          .callback = video_set_use_native_backlight,
576          .ident = "Acer Aspire 5733Z",
577          .matches = {
578                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
579                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5733Z"),
580                 },
581         },
582         {
583          .callback = video_set_use_native_backlight,
584          .ident = "Acer Aspire 5742G",
585          .matches = {
586                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
587                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5742G"),
588                 },
589         },
590         {
591          .callback = video_set_use_native_backlight,
592          .ident = "Acer Aspire V5-171",
593          .matches = {
594                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
595                 DMI_MATCH(DMI_PRODUCT_NAME, "V5-171"),
596                 },
597         },
598         {
599          .callback = video_set_use_native_backlight,
600          .ident = "Acer Aspire V5-431",
601          .matches = {
602                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
603                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-431"),
604                 },
605         },
606         {
607          .callback = video_set_use_native_backlight,
608          .ident = "Acer Aspire V5-471G",
609          .matches = {
610                 DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
611                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-471G"),
612                 },
613         },
614         {
615          .callback = video_set_use_native_backlight,
616          .ident = "Acer TravelMate B113",
617          .matches = {
618                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
619                 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate B113"),
620                 },
621         },
622         {
623          .callback = video_set_use_native_backlight,
624          .ident = "Acer Aspire V5-572G",
625          .matches = {
626                 DMI_MATCH(DMI_SYS_VENDOR, "Acer Aspire"),
627                 DMI_MATCH(DMI_PRODUCT_VERSION, "V5-572G/Dazzle_CX"),
628                 },
629         },
630         {
631          .callback = video_set_use_native_backlight,
632          .ident = "Acer Aspire V5-573G",
633          .matches = {
634                 DMI_MATCH(DMI_SYS_VENDOR, "Acer Aspire"),
635                 DMI_MATCH(DMI_PRODUCT_VERSION, "V5-573G/Dazzle_HW"),
636                 },
637         },
638         {
639          .callback = video_set_use_native_backlight,
640          .ident = "ASUS Zenbook Prime UX31A",
641          .matches = {
642                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
643                 DMI_MATCH(DMI_PRODUCT_NAME, "UX31A"),
644                 },
645         },
646         {
647         .callback = video_set_use_native_backlight,
648         .ident = "HP ProBook 4340s",
649         .matches = {
650                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
651                 DMI_MATCH(DMI_PRODUCT_VERSION, "HP ProBook 4340s"),
652                 },
653         },
654         {
655         .callback = video_set_use_native_backlight,
656         .ident = "HP ProBook 4540s",
657         .matches = {
658                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
659                 DMI_MATCH(DMI_PRODUCT_VERSION, "HP ProBook 4540s"),
660                 },
661         },
662         {
663         .callback = video_set_use_native_backlight,
664         .ident = "HP ProBook 2013 models",
665         .matches = {
666                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
667                 DMI_MATCH(DMI_PRODUCT_NAME, "HP ProBook "),
668                 DMI_MATCH(DMI_PRODUCT_NAME, " G1"),
669                 },
670         },
671         {
672         .callback = video_set_use_native_backlight,
673         .ident = "HP EliteBook 2013 models",
674         .matches = {
675                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
676                 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook "),
677                 DMI_MATCH(DMI_PRODUCT_NAME, " G1"),
678                 },
679         },
680         {
681         .callback = video_set_use_native_backlight,
682         .ident = "HP EliteBook 2014 models",
683         .matches = {
684                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
685                 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook "),
686                 DMI_MATCH(DMI_PRODUCT_NAME, " G2"),
687                 },
688         },
689         {
690         .callback = video_set_use_native_backlight,
691         .ident = "HP ZBook 14",
692         .matches = {
693                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
694                 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 14"),
695                 },
696         },
697         {
698         .callback = video_set_use_native_backlight,
699         .ident = "HP ZBook 15",
700         .matches = {
701                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
702                 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 15"),
703                 },
704         },
705         {
706         .callback = video_set_use_native_backlight,
707         .ident = "HP ZBook 17",
708         .matches = {
709                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
710                 DMI_MATCH(DMI_PRODUCT_NAME, "HP ZBook 17"),
711                 },
712         },
713         {
714         .callback = video_set_use_native_backlight,
715         .ident = "HP EliteBook 8470p",
716         .matches = {
717                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
718                 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8470p"),
719                 },
720         },
721         {
722         .callback = video_set_use_native_backlight,
723         .ident = "HP EliteBook 8780w",
724         .matches = {
725                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
726                 DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8780w"),
727                 },
728         },
729 
730         /*
731          * These models have a working acpi_video backlight control, and using
732          * native backlight causes a regression where backlight does not work
733          * when userspace is not handling brightness key events. Disable
734          * native_backlight on these to fix this:
735          * https://bugzilla.kernel.org/show_bug.cgi?id=81691
736          */
737         {
738          .callback = video_disable_native_backlight,
739          .ident = "ThinkPad T420",
740          .matches = {
741                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
742                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T420"),
743                 },
744         },
745         {
746          .callback = video_disable_native_backlight,
747          .ident = "ThinkPad T520",
748          .matches = {
749                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
750                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T520"),
751                 },
752         },
753         {
754          .callback = video_disable_native_backlight,
755          .ident = "ThinkPad X201s",
756          .matches = {
757                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
758                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201s"),
759                 },
760         },
761 
762         /* The native backlight controls do not work on some older machines */
763         {
764          /* https://bugs.freedesktop.org/show_bug.cgi?id=81515 */
765          .callback = video_disable_native_backlight,
766          .ident = "HP ENVY 15 Notebook",
767          .matches = {
768                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
769                 DMI_MATCH(DMI_PRODUCT_NAME, "HP ENVY 15 Notebook PC"),
770                 },
771         },
772         {}
773 };
774 
775 static unsigned long long
776 acpi_video_bqc_value_to_level(struct acpi_video_device *device,
777                               unsigned long long bqc_value)
778 {
779         unsigned long long level;
780 
781         if (device->brightness->flags._BQC_use_index) {
782                 /*
783                  * _BQC returns an index that doesn't account for
784                  * the first 2 items with special meaning, so we need
785                  * to compensate for that by offsetting ourselves
786                  */
787                 if (device->brightness->flags._BCL_reversed)
788                         bqc_value = device->brightness->count - 3 - bqc_value;
789 
790                 level = device->brightness->levels[bqc_value + 2];
791         } else {
792                 level = bqc_value;
793         }
794 
795         level += bqc_offset_aml_bug_workaround;
796 
797         return level;
798 }
799 
800 static int
801 acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
802                                         unsigned long long *level, bool raw)
803 {
804         acpi_status status = AE_OK;
805         int i;
806 
807         if (device->cap._BQC || device->cap._BCQ) {
808                 char *buf = device->cap._BQC ? "_BQC" : "_BCQ";
809 
810                 status = acpi_evaluate_integer(device->dev->handle, buf,
811                                                 NULL, level);
812                 if (ACPI_SUCCESS(status)) {
813                         if (raw) {
814                                 /*
815                                  * Caller has indicated he wants the raw
816                                  * value returned by _BQC, so don't furtherly
817                                  * mess with the value.
818                                  */
819                                 return 0;
820                         }
821 
822                         *level = acpi_video_bqc_value_to_level(device, *level);
823 
824                         for (i = 2; i < device->brightness->count; i++)
825                                 if (device->brightness->levels[i] == *level) {
826                                         device->brightness->curr = *level;
827                                         return 0;
828                                 }
829                         /*
830                          * BQC returned an invalid level.
831                          * Stop using it.
832                          */
833                         ACPI_WARNING((AE_INFO,
834                                       "%s returned an invalid level",
835                                       buf));
836                         device->cap._BQC = device->cap._BCQ = 0;
837                 } else {
838                         /*
839                          * Fixme:
840                          * should we return an error or ignore this failure?
841                          * dev->brightness->curr is a cached value which stores
842                          * the correct current backlight level in most cases.
843                          * ACPI video backlight still works w/ buggy _BQC.
844                          * http://bugzilla.kernel.org/show_bug.cgi?id=12233
845                          */
846                         ACPI_WARNING((AE_INFO, "Evaluating %s failed", buf));
847                         device->cap._BQC = device->cap._BCQ = 0;
848                 }
849         }
850 
851         *level = device->brightness->curr;
852         return 0;
853 }
854 
855 static int
856 acpi_video_device_EDID(struct acpi_video_device *device,
857                        union acpi_object **edid, ssize_t length)
858 {
859         int status;
860         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
861         union acpi_object *obj;
862         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
863         struct acpi_object_list args = { 1, &arg0 };
864 
865 
866         *edid = NULL;
867 
868         if (!device)
869                 return -ENODEV;
870         if (length == 128)
871                 arg0.integer.value = 1;
872         else if (length == 256)
873                 arg0.integer.value = 2;
874         else
875                 return -EINVAL;
876 
877         status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
878         if (ACPI_FAILURE(status))
879                 return -ENODEV;
880 
881         obj = buffer.pointer;
882 
883         if (obj && obj->type == ACPI_TYPE_BUFFER)
884                 *edid = obj;
885         else {
886                 printk(KERN_ERR PREFIX "Invalid _DDC data\n");
887                 status = -EFAULT;
888                 kfree(obj);
889         }
890 
891         return status;
892 }
893 
894 /* bus */
895 
896 /*
897  *  Arg:
898  *      video           : video bus device pointer
899  *      bios_flag       :
900  *              0.      The system BIOS should NOT automatically switch(toggle)
901  *                      the active display output.
902  *              1.      The system BIOS should automatically switch (toggle) the
903  *                      active display output. No switch event.
904  *              2.      The _DGS value should be locked.
905  *              3.      The system BIOS should not automatically switch (toggle) the
906  *                      active display output, but instead generate the display switch
907  *                      event notify code.
908  *      lcd_flag        :
909  *              0.      The system BIOS should automatically control the brightness level
910  *                      of the LCD when the power changes from AC to DC
911  *              1.      The system BIOS should NOT automatically control the brightness
912  *                      level of the LCD when the power changes from AC to DC.
913  *  Return Value:
914  *              -EINVAL wrong arg.
915  */
916 
917 static int
918 acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
919 {
920         acpi_status status;
921 
922         if (!video->cap._DOS)
923                 return 0;
924 
925         if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1)
926                 return -EINVAL;
927         video->dos_setting = (lcd_flag << 2) | bios_flag;
928         status = acpi_execute_simple_method(video->device->handle, "_DOS",
929                                             (lcd_flag << 2) | bios_flag);
930         if (ACPI_FAILURE(status))
931                 return -EIO;
932 
933         return 0;
934 }
935 
936 /*
937  * Simple comparison function used to sort backlight levels.
938  */
939 
940 static int
941 acpi_video_cmp_level(const void *a, const void *b)
942 {
943         return *(int *)a - *(int *)b;
944 }
945 
946 /*
947  * Decides if _BQC/_BCQ for this system is usable
948  *
949  * We do this by changing the level first and then read out the current
950  * brightness level, if the value does not match, find out if it is using
951  * index. If not, clear the _BQC/_BCQ capability.
952  */
953 static int acpi_video_bqc_quirk(struct acpi_video_device *device,
954                                 int max_level, int current_level)
955 {
956         struct acpi_video_device_brightness *br = device->brightness;
957         int result;
958         unsigned long long level;
959         int test_level;
960 
961         /* don't mess with existing known broken systems */
962         if (bqc_offset_aml_bug_workaround)
963                 return 0;
964 
965         /*
966          * Some systems always report current brightness level as maximum
967          * through _BQC, we need to test another value for them.
968          */
969         test_level = current_level == max_level ? br->levels[3] : max_level;
970 
971         result = acpi_video_device_lcd_set_level(device, test_level);
972         if (result)
973                 return result;
974 
975         result = acpi_video_device_lcd_get_level_current(device, &level, true);
976         if (result)
977                 return result;
978 
979         if (level != test_level) {
980                 /* buggy _BQC found, need to find out if it uses index */
981                 if (level < br->count) {
982                         if (br->flags._BCL_reversed)
983                                 level = br->count - 3 - level;
984                         if (br->levels[level + 2] == test_level)
985                                 br->flags._BQC_use_index = 1;
986                 }
987 
988                 if (!br->flags._BQC_use_index)
989                         device->cap._BQC = device->cap._BCQ = 0;
990         }
991 
992         return 0;
993 }
994 
995 
996 /*
997  *  Arg:
998  *      device  : video output device (LCD, CRT, ..)
999  *
1000  *  Return Value:
1001  *      Maximum brightness level
1002  *
1003  *  Allocate and initialize device->brightness.
1004  */
1005 
1006 static int
1007 acpi_video_init_brightness(struct acpi_video_device *device)
1008 {
1009         union acpi_object *obj = NULL;
1010         int i, max_level = 0, count = 0, level_ac_battery = 0;
1011         unsigned long long level, level_old;
1012         union acpi_object *o;
1013         struct acpi_video_device_brightness *br = NULL;
1014         int result = -EINVAL;
1015         u32 value;
1016 
1017         if (!ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
1018                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available "
1019                                                 "LCD brightness level\n"));
1020                 goto out;
1021         }
1022 
1023         if (obj->package.count < 2)
1024                 goto out;
1025 
1026         br = kzalloc(sizeof(*br), GFP_KERNEL);
1027         if (!br) {
1028                 printk(KERN_ERR "can't allocate memory\n");
1029                 result = -ENOMEM;
1030                 goto out;
1031         }
1032 
1033         br->levels = kmalloc((obj->package.count + 2) * sizeof *(br->levels),
1034                                 GFP_KERNEL);
1035         if (!br->levels) {
1036                 result = -ENOMEM;
1037                 goto out_free;
1038         }
1039 
1040         for (i = 0; i < obj->package.count; i++) {
1041                 o = (union acpi_object *)&obj->package.elements[i];
1042                 if (o->type != ACPI_TYPE_INTEGER) {
1043                         printk(KERN_ERR PREFIX "Invalid data\n");
1044                         continue;
1045                 }
1046                 value = (u32) o->integer.value;
1047                 /* Skip duplicate entries */
1048                 if (count > 2 && br->levels[count - 1] == value)
1049                         continue;
1050 
1051                 br->levels[count] = value;
1052 
1053                 if (br->levels[count] > max_level)
1054                         max_level = br->levels[count];
1055                 count++;
1056         }
1057 
1058         /*
1059          * some buggy BIOS don't export the levels
1060          * when machine is on AC/Battery in _BCL package.
1061          * In this case, the first two elements in _BCL packages
1062          * are also supported brightness levels that OS should take care of.
1063          */
1064         for (i = 2; i < count; i++) {
1065                 if (br->levels[i] == br->levels[0])
1066                         level_ac_battery++;
1067                 if (br->levels[i] == br->levels[1])
1068                         level_ac_battery++;
1069         }
1070 
1071         if (level_ac_battery < 2) {
1072                 level_ac_battery = 2 - level_ac_battery;
1073                 br->flags._BCL_no_ac_battery_levels = 1;
1074                 for (i = (count - 1 + level_ac_battery); i >= 2; i--)
1075                         br->levels[i] = br->levels[i - level_ac_battery];
1076                 count += level_ac_battery;
1077         } else if (level_ac_battery > 2)
1078                 ACPI_ERROR((AE_INFO, "Too many duplicates in _BCL package"));
1079 
1080         /* Check if the _BCL package is in a reversed order */
1081         if (max_level == br->levels[2]) {
1082                 br->flags._BCL_reversed = 1;
1083                 sort(&br->levels[2], count - 2, sizeof(br->levels[2]),
1084                         acpi_video_cmp_level, NULL);
1085         } else if (max_level != br->levels[count - 1])
1086                 ACPI_ERROR((AE_INFO,
1087                             "Found unordered _BCL package"));
1088 
1089         br->count = count;
1090         device->brightness = br;
1091 
1092         /* _BQC uses INDEX while _BCL uses VALUE in some laptops */
1093         br->curr = level = max_level;
1094 
1095         if (!device->cap._BQC)
1096                 goto set_level;
1097 
1098         result = acpi_video_device_lcd_get_level_current(device,
1099                                                          &level_old, true);
1100         if (result)
1101                 goto out_free_levels;
1102 
1103         result = acpi_video_bqc_quirk(device, max_level, level_old);
1104         if (result)
1105                 goto out_free_levels;
1106         /*
1107          * cap._BQC may get cleared due to _BQC is found to be broken
1108          * in acpi_video_bqc_quirk, so check again here.
1109          */
1110         if (!device->cap._BQC)
1111                 goto set_level;
1112 
1113         level = acpi_video_bqc_value_to_level(device, level_old);
1114         /*
1115          * On some buggy laptops, _BQC returns an uninitialized
1116          * value when invoked for the first time, i.e.
1117          * level_old is invalid (no matter whether it's a level
1118          * or an index). Set the backlight to max_level in this case.
1119          */
1120         for (i = 2; i < br->count; i++)
1121                 if (level == br->levels[i])
1122                         break;
1123         if (i == br->count || !level)
1124                 level = max_level;
1125 
1126 set_level:
1127         result = acpi_video_device_lcd_set_level(device, level);
1128         if (result)
1129                 goto out_free_levels;
1130 
1131         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1132                           "found %d brightness levels\n", count - 2));
1133         kfree(obj);
1134         return result;
1135 
1136 out_free_levels:
1137         kfree(br->levels);
1138 out_free:
1139         kfree(br);
1140 out:
1141         device->brightness = NULL;
1142         kfree(obj);
1143         return result;
1144 }
1145 
1146 /*
1147  *  Arg:
1148  *      device  : video output device (LCD, CRT, ..)
1149  *
1150  *  Return Value:
1151  *      None
1152  *
1153  *  Find out all required AML methods defined under the output
1154  *  device.
1155  */
1156 
1157 static void acpi_video_device_find_cap(struct acpi_video_device *device)
1158 {
1159         if (acpi_has_method(device->dev->handle, "_ADR"))
1160                 device->cap._ADR = 1;
1161         if (acpi_has_method(device->dev->handle, "_BCL"))
1162                 device->cap._BCL = 1;
1163         if (acpi_has_method(device->dev->handle, "_BCM"))
1164                 device->cap._BCM = 1;
1165         if (acpi_has_method(device->dev->handle, "_BQC")) {
1166                 device->cap._BQC = 1;
1167         } else if (acpi_has_method(device->dev->handle, "_BCQ")) {
1168                 printk(KERN_WARNING FW_BUG "_BCQ is used instead of _BQC\n");
1169                 device->cap._BCQ = 1;
1170         }
1171 
1172         if (acpi_has_method(device->dev->handle, "_DDC"))
1173                 device->cap._DDC = 1;
1174 }
1175 
1176 /*
1177  *  Arg:
1178  *      device  : video output device (VGA)
1179  *
1180  *  Return Value:
1181  *      None
1182  *
1183  *  Find out all required AML methods defined under the video bus device.
1184  */
1185 
1186 static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
1187 {
1188         if (acpi_has_method(video->device->handle, "_DOS"))
1189                 video->cap._DOS = 1;
1190         if (acpi_has_method(video->device->handle, "_DOD"))
1191                 video->cap._DOD = 1;
1192         if (acpi_has_method(video->device->handle, "_ROM"))
1193                 video->cap._ROM = 1;
1194         if (acpi_has_method(video->device->handle, "_GPD"))
1195                 video->cap._GPD = 1;
1196         if (acpi_has_method(video->device->handle, "_SPD"))
1197                 video->cap._SPD = 1;
1198         if (acpi_has_method(video->device->handle, "_VPO"))
1199                 video->cap._VPO = 1;
1200 }
1201 
1202 /*
1203  * Check whether the video bus device has required AML method to
1204  * support the desired features
1205  */
1206 
1207 static int acpi_video_bus_check(struct acpi_video_bus *video)
1208 {
1209         acpi_status status = -ENOENT;
1210         struct pci_dev *dev;
1211 
1212         if (!video)
1213                 return -EINVAL;
1214 
1215         dev = acpi_get_pci_dev(video->device->handle);
1216         if (!dev)
1217                 return -ENODEV;
1218         pci_dev_put(dev);
1219 
1220         /*
1221          * Since there is no HID, CID and so on for VGA driver, we have
1222          * to check well known required nodes.
1223          */
1224 
1225         /* Does this device support video switching? */
1226         if (video->cap._DOS || video->cap._DOD) {
1227                 if (!video->cap._DOS) {
1228                         printk(KERN_WARNING FW_BUG
1229                                 "ACPI(%s) defines _DOD but not _DOS\n",
1230                                 acpi_device_bid(video->device));
1231                 }
1232                 video->flags.multihead = 1;
1233                 status = 0;
1234         }
1235 
1236         /* Does this device support retrieving a video ROM? */
1237         if (video->cap._ROM) {
1238                 video->flags.rom = 1;
1239                 status = 0;
1240         }
1241 
1242         /* Does this device support configuring which video device to POST? */
1243         if (video->cap._GPD && video->cap._SPD && video->cap._VPO) {
1244                 video->flags.post = 1;
1245                 status = 0;
1246         }
1247 
1248         return status;
1249 }
1250 
1251 /*
1252  * --------------------------------------------------------------------------
1253  *                               Driver Interface
1254  * --------------------------------------------------------------------------
1255  */
1256 
1257 /* device interface */
1258 static struct acpi_video_device_attrib *
1259 acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id)
1260 {
1261         struct acpi_video_enumerated_device *ids;
1262         int i;
1263 
1264         for (i = 0; i < video->attached_count; i++) {
1265                 ids = &video->attached_array[i];
1266                 if ((ids->value.int_val & 0xffff) == device_id)
1267                         return &ids->value.attrib;
1268         }
1269 
1270         return NULL;
1271 }
1272 
1273 static int
1274 acpi_video_get_device_type(struct acpi_video_bus *video,
1275                            unsigned long device_id)
1276 {
1277         struct acpi_video_enumerated_device *ids;
1278         int i;
1279 
1280         for (i = 0; i < video->attached_count; i++) {
1281                 ids = &video->attached_array[i];
1282                 if ((ids->value.int_val & 0xffff) == device_id)
1283                         return ids->value.int_val;
1284         }
1285 
1286         return 0;
1287 }
1288 
1289 static int
1290 acpi_video_bus_get_one_device(struct acpi_device *device,
1291                               struct acpi_video_bus *video)
1292 {
1293         unsigned long long device_id;
1294         int status, device_type;
1295         struct acpi_video_device *data;
1296         struct acpi_video_device_attrib *attribute;
1297 
1298         status =
1299             acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
1300         /* Some device omits _ADR, we skip them instead of fail */
1301         if (ACPI_FAILURE(status))
1302                 return 0;
1303 
1304         data = kzalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
1305         if (!data)
1306                 return -ENOMEM;
1307 
1308         strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
1309         strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
1310         device->driver_data = data;
1311 
1312         data->device_id = device_id;
1313         data->video = video;
1314         data->dev = device;
1315         INIT_DELAYED_WORK(&data->switch_brightness_work,
1316                           acpi_video_switch_brightness);
1317 
1318         attribute = acpi_video_get_device_attr(video, device_id);
1319 
1320         if (attribute && attribute->device_id_scheme) {
1321                 switch (attribute->display_type) {
1322                 case ACPI_VIDEO_DISPLAY_CRT:
1323                         data->flags.crt = 1;
1324                         break;
1325                 case ACPI_VIDEO_DISPLAY_TV:
1326                         data->flags.tvout = 1;
1327                         break;
1328                 case ACPI_VIDEO_DISPLAY_DVI:
1329                         data->flags.dvi = 1;
1330                         break;
1331                 case ACPI_VIDEO_DISPLAY_LCD:
1332                         data->flags.lcd = 1;
1333                         break;
1334                 default:
1335                         data->flags.unknown = 1;
1336                         break;
1337                 }
1338                 if (attribute->bios_can_detect)
1339                         data->flags.bios = 1;
1340         } else {
1341                 /* Check for legacy IDs */
1342                 device_type = acpi_video_get_device_type(video, device_id);
1343                 /* Ignore bits 16 and 18-20 */
1344                 switch (device_type & 0xffe2ffff) {
1345                 case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
1346                         data->flags.crt = 1;
1347                         break;
1348                 case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
1349                         data->flags.lcd = 1;
1350                         break;
1351                 case ACPI_VIDEO_DISPLAY_LEGACY_TV:
1352                         data->flags.tvout = 1;
1353                         break;
1354                 default:
1355                         data->flags.unknown = 1;
1356                 }
1357         }
1358 
1359         acpi_video_device_bind(video, data);
1360         acpi_video_device_find_cap(data);
1361 
1362         mutex_lock(&video->device_list_lock);
1363         list_add_tail(&data->entry, &video->video_device_list);
1364         mutex_unlock(&video->device_list_lock);
1365 
1366         return status;
1367 }
1368 
1369 /*
1370  *  Arg:
1371  *      video   : video bus device
1372  *
1373  *  Return:
1374  *      none
1375  *
1376  *  Enumerate the video device list of the video bus,
1377  *  bind the ids with the corresponding video devices
1378  *  under the video bus.
1379  */
1380 
1381 static void acpi_video_device_rebind(struct acpi_video_bus *video)
1382 {
1383         struct acpi_video_device *dev;
1384 
1385         mutex_lock(&video->device_list_lock);
1386 
1387         list_for_each_entry(dev, &video->video_device_list, entry)
1388                 acpi_video_device_bind(video, dev);
1389 
1390         mutex_unlock(&video->device_list_lock);
1391 }
1392 
1393 /*
1394  *  Arg:
1395  *      video   : video bus device
1396  *      device  : video output device under the video
1397  *              bus
1398  *
1399  *  Return:
1400  *      none
1401  *
1402  *  Bind the ids with the corresponding video devices
1403  *  under the video bus.
1404  */
1405 
1406 static void
1407 acpi_video_device_bind(struct acpi_video_bus *video,
1408                        struct acpi_video_device *device)
1409 {
1410         struct acpi_video_enumerated_device *ids;
1411         int i;
1412 
1413         for (i = 0; i < video->attached_count; i++) {
1414                 ids = &video->attached_array[i];
1415                 if (device->device_id == (ids->value.int_val & 0xffff)) {
1416                         ids->bind_info = device;
1417                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "device_bind %d\n", i));
1418                 }
1419         }
1420 }
1421 
1422 /*
1423  *  Arg:
1424  *      video   : video bus device
1425  *
1426  *  Return:
1427  *      < 0     : error
1428  *
1429  *  Call _DOD to enumerate all devices attached to display adapter
1430  *
1431  */
1432 
1433 static int acpi_video_device_enumerate(struct acpi_video_bus *video)
1434 {
1435         int status;
1436         int count;
1437         int i;
1438         struct acpi_video_enumerated_device *active_list;
1439         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1440         union acpi_object *dod = NULL;
1441         union acpi_object *obj;
1442 
1443         status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
1444         if (!ACPI_SUCCESS(status)) {
1445                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
1446                 return status;
1447         }
1448 
1449         dod = buffer.pointer;
1450         if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
1451                 ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
1452                 status = -EFAULT;
1453                 goto out;
1454         }
1455 
1456         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d video heads in _DOD\n",
1457                           dod->package.count));
1458 
1459         active_list = kcalloc(1 + dod->package.count,
1460                               sizeof(struct acpi_video_enumerated_device),
1461                               GFP_KERNEL);
1462         if (!active_list) {
1463                 status = -ENOMEM;
1464                 goto out;
1465         }
1466 
1467         count = 0;
1468         for (i = 0; i < dod->package.count; i++) {
1469                 obj = &dod->package.elements[i];
1470 
1471                 if (obj->type != ACPI_TYPE_INTEGER) {
1472                         printk(KERN_ERR PREFIX
1473                                 "Invalid _DOD data in element %d\n", i);
1474                         continue;
1475                 }
1476 
1477                 active_list[count].value.int_val = obj->integer.value;
1478                 active_list[count].bind_info = NULL;
1479                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "dod element[%d] = %d\n", i,
1480                                   (int)obj->integer.value));
1481                 count++;
1482         }
1483 
1484         kfree(video->attached_array);
1485 
1486         video->attached_array = active_list;
1487         video->attached_count = count;
1488 
1489 out:
1490         kfree(buffer.pointer);
1491         return status;
1492 }
1493 
1494 static int
1495 acpi_video_get_next_level(struct acpi_video_device *device,
1496                           u32 level_current, u32 event)
1497 {
1498         int min, max, min_above, max_below, i, l, delta = 255;
1499         max = max_below = 0;
1500         min = min_above = 255;
1501         /* Find closest level to level_current */
1502         for (i = 2; i < device->brightness->count; i++) {
1503                 l = device->brightness->levels[i];
1504                 if (abs(l - level_current) < abs(delta)) {
1505                         delta = l - level_current;
1506                         if (!delta)
1507                                 break;
1508                 }
1509         }
1510         /* Ajust level_current to closest available level */
1511         level_current += delta;
1512         for (i = 2; i < device->brightness->count; i++) {
1513                 l = device->brightness->levels[i];
1514                 if (l < min)
1515                         min = l;
1516                 if (l > max)
1517                         max = l;
1518                 if (l < min_above && l > level_current)
1519                         min_above = l;
1520                 if (l > max_below && l < level_current)
1521                         max_below = l;
1522         }
1523 
1524         switch (event) {
1525         case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:
1526                 return (level_current < max) ? min_above : min;
1527         case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:
1528                 return (level_current < max) ? min_above : max;
1529         case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:
1530                 return (level_current > min) ? max_below : min;
1531         case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS:
1532         case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:
1533                 return 0;
1534         default:
1535                 return level_current;
1536         }
1537 }
1538 
1539 static void
1540 acpi_video_switch_brightness(struct work_struct *work)
1541 {
1542         struct acpi_video_device *device = container_of(to_delayed_work(work),
1543                              struct acpi_video_device, switch_brightness_work);
1544         unsigned long long level_current, level_next;
1545         int event = device->switch_brightness_event;
1546         int result = -EINVAL;
1547 
1548         /* no warning message if acpi_backlight=vendor or a quirk is used */
1549         if (!acpi_video_verify_backlight_support())
1550                 return;
1551 
1552         if (!device->brightness)
1553                 goto out;
1554 
1555         result = acpi_video_device_lcd_get_level_current(device,
1556                                                          &level_current,
1557                                                          false);
1558         if (result)
1559                 goto out;
1560 
1561         level_next = acpi_video_get_next_level(device, level_current, event);
1562 
1563         result = acpi_video_device_lcd_set_level(device, level_next);
1564 
1565         if (!result)
1566                 backlight_force_update(device->backlight,
1567                                        BACKLIGHT_UPDATE_HOTKEY);
1568 
1569 out:
1570         if (result)
1571                 printk(KERN_ERR PREFIX "Failed to switch the brightness\n");
1572 }
1573 
1574 int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
1575                         void **edid)
1576 {
1577         struct acpi_video_bus *video;
1578         struct acpi_video_device *video_device;
1579         union acpi_object *buffer = NULL;
1580         acpi_status status;
1581         int i, length;
1582 
1583         if (!device || !acpi_driver_data(device))
1584                 return -EINVAL;
1585 
1586         video = acpi_driver_data(device);
1587 
1588         for (i = 0; i < video->attached_count; i++) {
1589                 video_device = video->attached_array[i].bind_info;
1590                 length = 256;
1591 
1592                 if (!video_device)
1593                         continue;
1594 
1595                 if (!video_device->cap._DDC)
1596                         continue;
1597 
1598                 if (type) {
1599                         switch (type) {
1600                         case ACPI_VIDEO_DISPLAY_CRT:
1601                                 if (!video_device->flags.crt)
1602                                         continue;
1603                                 break;
1604                         case ACPI_VIDEO_DISPLAY_TV:
1605                                 if (!video_device->flags.tvout)
1606                                         continue;
1607                                 break;
1608                         case ACPI_VIDEO_DISPLAY_DVI:
1609                                 if (!video_device->flags.dvi)
1610                                         continue;
1611                                 break;
1612                         case ACPI_VIDEO_DISPLAY_LCD:
1613                                 if (!video_device->flags.lcd)
1614                                         continue;
1615                                 break;
1616                         }
1617                 } else if (video_device->device_id != device_id) {
1618                         continue;
1619                 }
1620 
1621                 status = acpi_video_device_EDID(video_device, &buffer, length);
1622 
1623                 if (ACPI_FAILURE(status) || !buffer ||
1624                     buffer->type != ACPI_TYPE_BUFFER) {
1625                         length = 128;
1626                         status = acpi_video_device_EDID(video_device, &buffer,
1627                                                         length);
1628                         if (ACPI_FAILURE(status) || !buffer ||
1629                             buffer->type != ACPI_TYPE_BUFFER) {
1630                                 continue;
1631                         }
1632                 }
1633 
1634                 *edid = buffer->buffer.pointer;
1635                 return length;
1636         }
1637 
1638         return -ENODEV;
1639 }
1640 EXPORT_SYMBOL(acpi_video_get_edid);
1641 
1642 static int
1643 acpi_video_bus_get_devices(struct acpi_video_bus *video,
1644                            struct acpi_device *device)
1645 {
1646         int status = 0;
1647         struct acpi_device *dev;
1648 
1649         /*
1650          * There are systems where video module known to work fine regardless
1651          * of broken _DOD and ignoring returned value here doesn't cause
1652          * any issues later.
1653          */
1654         acpi_video_device_enumerate(video);
1655 
1656         list_for_each_entry(dev, &device->children, node) {
1657 
1658                 status = acpi_video_bus_get_one_device(dev, video);
1659                 if (status) {
1660                         dev_err(&dev->dev, "Can't attach device\n");
1661                         break;
1662                 }
1663         }
1664         return status;
1665 }
1666 
1667 /* acpi_video interface */
1668 
1669 /*
1670  * Win8 requires setting bit2 of _DOS to let firmware know it shouldn't
1671  * preform any automatic brightness change on receiving a notification.
1672  */
1673 static int acpi_video_bus_start_devices(struct acpi_video_bus *video)
1674 {
1675         return acpi_video_bus_DOS(video, 0,
1676                                   acpi_osi_is_win8() ? 1 : 0);
1677 }
1678 
1679 static int acpi_video_bus_stop_devices(struct acpi_video_bus *video)
1680 {
1681         return acpi_video_bus_DOS(video, 0,
1682                                   acpi_osi_is_win8() ? 0 : 1);
1683 }
1684 
1685 static void acpi_video_bus_notify(struct acpi_device *device, u32 event)
1686 {
1687         struct acpi_video_bus *video = acpi_driver_data(device);
1688         struct input_dev *input;
1689         int keycode = 0;
1690 
1691         if (!video || !video->input)
1692                 return;
1693 
1694         input = video->input;
1695 
1696         switch (event) {
1697         case ACPI_VIDEO_NOTIFY_SWITCH:  /* User requested a switch,
1698                                          * most likely via hotkey. */
1699                 keycode = KEY_SWITCHVIDEOMODE;
1700                 break;
1701 
1702         case ACPI_VIDEO_NOTIFY_PROBE:   /* User plugged in or removed a video
1703                                          * connector. */
1704                 acpi_video_device_enumerate(video);
1705                 acpi_video_device_rebind(video);
1706                 keycode = KEY_SWITCHVIDEOMODE;
1707                 break;
1708 
1709         case ACPI_VIDEO_NOTIFY_CYCLE:   /* Cycle Display output hotkey pressed. */
1710                 keycode = KEY_SWITCHVIDEOMODE;
1711                 break;
1712         case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:     /* Next Display output hotkey pressed. */
1713                 keycode = KEY_VIDEO_NEXT;
1714                 break;
1715         case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:     /* previous Display output hotkey pressed. */
1716                 keycode = KEY_VIDEO_PREV;
1717                 break;
1718 
1719         default:
1720                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1721                                   "Unsupported event [0x%x]\n", event));
1722                 break;
1723         }
1724 
1725         if (acpi_notifier_call_chain(device, event, 0))
1726                 /* Something vetoed the keypress. */
1727                 keycode = 0;
1728 
1729         if (keycode) {
1730                 input_report_key(input, keycode, 1);
1731                 input_sync(input);
1732                 input_report_key(input, keycode, 0);
1733                 input_sync(input);
1734         }
1735 
1736         return;
1737 }
1738 
1739 static void brightness_switch_event(struct acpi_video_device *video_device,
1740                                     u32 event)
1741 {
1742         if (!brightness_switch_enabled)
1743                 return;
1744 
1745         video_device->switch_brightness_event = event;
1746         schedule_delayed_work(&video_device->switch_brightness_work, HZ / 10);
1747 }
1748 
1749 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
1750 {
1751         struct acpi_video_device *video_device = data;
1752         struct acpi_device *device = NULL;
1753         struct acpi_video_bus *bus;
1754         struct input_dev *input;
1755         int keycode = 0;
1756 
1757         if (!video_device)
1758                 return;
1759 
1760         device = video_device->dev;
1761         bus = video_device->video;
1762         input = bus->input;
1763 
1764         switch (event) {
1765         case ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS:        /* Cycle brightness */
1766                 brightness_switch_event(video_device, event);
1767                 keycode = KEY_BRIGHTNESS_CYCLE;
1768                 break;
1769         case ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS:  /* Increase brightness */
1770                 brightness_switch_event(video_device, event);
1771                 keycode = KEY_BRIGHTNESSUP;
1772                 break;
1773         case ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS:  /* Decrease brightness */
1774                 brightness_switch_event(video_device, event);
1775                 keycode = KEY_BRIGHTNESSDOWN;
1776                 break;
1777         case ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS: /* zero brightness */
1778                 brightness_switch_event(video_device, event);
1779                 keycode = KEY_BRIGHTNESS_ZERO;
1780                 break;
1781         case ACPI_VIDEO_NOTIFY_DISPLAY_OFF:     /* display device off */
1782                 brightness_switch_event(video_device, event);
1783                 keycode = KEY_DISPLAY_OFF;
1784                 break;
1785         default:
1786                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1787                                   "Unsupported event [0x%x]\n", event));
1788                 break;
1789         }
1790 
1791         acpi_notifier_call_chain(device, event, 0);
1792 
1793         if (keycode) {
1794                 input_report_key(input, keycode, 1);
1795                 input_sync(input);
1796                 input_report_key(input, keycode, 0);
1797                 input_sync(input);
1798         }
1799 
1800         return;
1801 }
1802 
1803 static int acpi_video_resume(struct notifier_block *nb,
1804                                 unsigned long val, void *ign)
1805 {
1806         struct acpi_video_bus *video;
1807         struct acpi_video_device *video_device;
1808         int i;
1809 
1810         switch (val) {
1811         case PM_HIBERNATION_PREPARE:
1812         case PM_SUSPEND_PREPARE:
1813         case PM_RESTORE_PREPARE:
1814                 return NOTIFY_DONE;
1815         }
1816 
1817         video = container_of(nb, struct acpi_video_bus, pm_nb);
1818 
1819         dev_info(&video->device->dev, "Restoring backlight state\n");
1820 
1821         for (i = 0; i < video->attached_count; i++) {
1822                 video_device = video->attached_array[i].bind_info;
1823                 if (video_device && video_device->backlight)
1824                         acpi_video_set_brightness(video_device->backlight);
1825         }
1826 
1827         return NOTIFY_OK;
1828 }
1829 
1830 static acpi_status
1831 acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
1832                         void **return_value)
1833 {
1834         struct acpi_device *device = context;
1835         struct acpi_device *sibling;
1836         int result;
1837 
1838         if (handle == device->handle)
1839                 return AE_CTRL_TERMINATE;
1840 
1841         result = acpi_bus_get_device(handle, &sibling);
1842         if (result)
1843                 return AE_OK;
1844 
1845         if (!strcmp(acpi_device_name(sibling), ACPI_VIDEO_BUS_NAME))
1846                         return AE_ALREADY_EXISTS;
1847 
1848         return AE_OK;
1849 }
1850 
1851 static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
1852 {
1853         struct backlight_properties props;
1854         struct pci_dev *pdev;
1855         acpi_handle acpi_parent;
1856         struct device *parent = NULL;
1857         int result;
1858         static int count;
1859         char *name;
1860 
1861         result = acpi_video_init_brightness(device);
1862         if (result)
1863                 return;
1864         name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
1865         if (!name)
1866                 return;
1867         count++;
1868 
1869         acpi_get_parent(device->dev->handle, &acpi_parent);
1870 
1871         pdev = acpi_get_pci_dev(acpi_parent);
1872         if (pdev) {
1873                 parent = &pdev->dev;
1874                 pci_dev_put(pdev);
1875         }
1876 
1877         memset(&props, 0, sizeof(struct backlight_properties));
1878         props.type = BACKLIGHT_FIRMWARE;
1879         props.max_brightness = device->brightness->count - 3;
1880         device->backlight = backlight_device_register(name,
1881                                                       parent,
1882                                                       device,
1883                                                       &acpi_backlight_ops,
1884                                                       &props);
1885         kfree(name);
1886         if (IS_ERR(device->backlight))
1887                 return;
1888 
1889         /*
1890          * Save current brightness level in case we have to restore it
1891          * before acpi_video_device_lcd_set_level() is called next time.
1892          */
1893         device->backlight->props.brightness =
1894                         acpi_video_get_brightness(device->backlight);
1895 
1896         device->cooling_dev = thermal_cooling_device_register("LCD",
1897                                 device->dev, &video_cooling_ops);
1898         if (IS_ERR(device->cooling_dev)) {
1899                 /*
1900                  * Set cooling_dev to NULL so we don't crash trying to free it.
1901                  * Also, why the hell we are returning early and not attempt to
1902                  * register video output if cooling device registration failed?
1903                  * -- dtor
1904                  */
1905                 device->cooling_dev = NULL;
1906                 return;
1907         }
1908 
1909         dev_info(&device->dev->dev, "registered as cooling_device%d\n",
1910                  device->cooling_dev->id);
1911         result = sysfs_create_link(&device->dev->dev.kobj,
1912                         &device->cooling_dev->device.kobj,
1913                         "thermal_cooling");
1914         if (result)
1915                 printk(KERN_ERR PREFIX "Create sysfs link\n");
1916         result = sysfs_create_link(&device->cooling_dev->device.kobj,
1917                         &device->dev->dev.kobj, "device");
1918         if (result)
1919                 printk(KERN_ERR PREFIX "Create sysfs link\n");
1920 }
1921 
1922 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
1923 {
1924         struct acpi_video_device *dev;
1925 
1926         if (video->backlight_registered)
1927                 return 0;
1928 
1929         if (!acpi_video_verify_backlight_support())
1930                 return 0;
1931 
1932         mutex_lock(&video->device_list_lock);
1933         list_for_each_entry(dev, &video->video_device_list, entry)
1934                 acpi_video_dev_register_backlight(dev);
1935         mutex_unlock(&video->device_list_lock);
1936 
1937         video->backlight_registered = true;
1938 
1939         video->pm_nb.notifier_call = acpi_video_resume;
1940         video->pm_nb.priority = 0;
1941         return register_pm_notifier(&video->pm_nb);
1942 }
1943 
1944 static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device)
1945 {
1946         if (device->backlight) {
1947                 backlight_device_unregister(device->backlight);
1948                 device->backlight = NULL;
1949         }
1950         if (device->brightness) {
1951                 kfree(device->brightness->levels);
1952                 kfree(device->brightness);
1953                 device->brightness = NULL;
1954         }
1955         if (device->cooling_dev) {
1956                 sysfs_remove_link(&device->dev->dev.kobj, "thermal_cooling");
1957                 sysfs_remove_link(&device->cooling_dev->device.kobj, "device");
1958                 thermal_cooling_device_unregister(device->cooling_dev);
1959                 device->cooling_dev = NULL;
1960         }
1961 }
1962 
1963 static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
1964 {
1965         struct acpi_video_device *dev;
1966         int error;
1967 
1968         if (!video->backlight_registered)
1969                 return 0;
1970 
1971         error = unregister_pm_notifier(&video->pm_nb);
1972 
1973         mutex_lock(&video->device_list_lock);
1974         list_for_each_entry(dev, &video->video_device_list, entry)
1975                 acpi_video_dev_unregister_backlight(dev);
1976         mutex_unlock(&video->device_list_lock);
1977 
1978         video->backlight_registered = false;
1979 
1980         return error;
1981 }
1982 
1983 static void acpi_video_dev_add_notify_handler(struct acpi_video_device *device)
1984 {
1985         acpi_status status;
1986         struct acpi_device *adev = device->dev;
1987 
1988         status = acpi_install_notify_handler(adev->handle, ACPI_DEVICE_NOTIFY,
1989                                              acpi_video_device_notify, device);
1990         if (ACPI_FAILURE(status))
1991                 dev_err(&adev->dev, "Error installing notify handler\n");
1992         else
1993                 device->flags.notify = 1;
1994 }
1995 
1996 static int acpi_video_bus_add_notify_handler(struct acpi_video_bus *video)
1997 {
1998         struct input_dev *input;
1999         struct acpi_video_device *dev;
2000         int error;
2001 
2002         video->input = input = input_allocate_device();
2003         if (!input) {
2004                 error = -ENOMEM;
2005                 goto out;
2006         }
2007 
2008         error = acpi_video_bus_start_devices(video);
2009         if (error)
2010                 goto err_free_input;
2011 
2012         snprintf(video->phys, sizeof(video->phys),
2013                         "%s/video/input0", acpi_device_hid(video->device));
2014 
2015         input->name = acpi_device_name(video->device);
2016         input->phys = video->phys;
2017         input->id.bustype = BUS_HOST;
2018         input->id.product = 0x06;
2019         input->dev.parent = &video->device->dev;
2020         input->evbit[0] = BIT(EV_KEY);
2021         set_bit(KEY_SWITCHVIDEOMODE, input->keybit);
2022         set_bit(KEY_VIDEO_NEXT, input->keybit);
2023         set_bit(KEY_VIDEO_PREV, input->keybit);
2024         set_bit(KEY_BRIGHTNESS_CYCLE, input->keybit);
2025         set_bit(KEY_BRIGHTNESSUP, input->keybit);
2026         set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
2027         set_bit(KEY_BRIGHTNESS_ZERO, input->keybit);
2028         set_bit(KEY_DISPLAY_OFF, input->keybit);
2029 
2030         error = input_register_device(input);
2031         if (error)
2032                 goto err_stop_dev;
2033 
2034         mutex_lock(&video->device_list_lock);
2035         list_for_each_entry(dev, &video->video_device_list, entry)
2036                 acpi_video_dev_add_notify_handler(dev);
2037         mutex_unlock(&video->device_list_lock);
2038 
2039         return 0;
2040 
2041 err_stop_dev:
2042         acpi_video_bus_stop_devices(video);
2043 err_free_input:
2044         input_free_device(input);
2045         video->input = NULL;
2046 out:
2047         return error;
2048 }
2049 
2050 static void acpi_video_dev_remove_notify_handler(struct acpi_video_device *dev)
2051 {
2052         if (dev->flags.notify) {
2053                 acpi_remove_notify_handler(dev->dev->handle, ACPI_DEVICE_NOTIFY,
2054                                            acpi_video_device_notify);
2055                 dev->flags.notify = 0;
2056         }
2057 }
2058 
2059 static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
2060 {
2061         struct acpi_video_device *dev;
2062 
2063         mutex_lock(&video->device_list_lock);
2064         list_for_each_entry(dev, &video->video_device_list, entry)
2065                 acpi_video_dev_remove_notify_handler(dev);
2066         mutex_unlock(&video->device_list_lock);
2067 
2068         acpi_video_bus_stop_devices(video);
2069         input_unregister_device(video->input);
2070         video->input = NULL;
2071 }
2072 
2073 static int acpi_video_backlight_notify(struct notifier_block *nb,
2074                                         unsigned long val, void *bd)
2075 {
2076         struct backlight_device *backlight = bd;
2077         struct acpi_video_bus *video;
2078 
2079         /* acpi_video_verify_backlight_support only cares about raw devices */
2080         if (backlight->props.type != BACKLIGHT_RAW)
2081                 return NOTIFY_DONE;
2082 
2083         video = container_of(nb, struct acpi_video_bus, backlight_nb);
2084 
2085         switch (val) {
2086         case BACKLIGHT_REGISTERED:
2087                 if (!acpi_video_verify_backlight_support())
2088                         acpi_video_bus_unregister_backlight(video);
2089                 break;
2090         case BACKLIGHT_UNREGISTERED:
2091                 acpi_video_bus_register_backlight(video);
2092                 break;
2093         }
2094 
2095         return NOTIFY_OK;
2096 }
2097 
2098 static int acpi_video_bus_add_backlight_notify_handler(
2099                                                 struct acpi_video_bus *video)
2100 {
2101         int error;
2102 
2103         video->backlight_nb.notifier_call = acpi_video_backlight_notify;
2104         video->backlight_nb.priority = 0;
2105         error = backlight_register_notifier(&video->backlight_nb);
2106         if (error == 0)
2107                 video->backlight_notifier_registered = true;
2108 
2109         return error;
2110 }
2111 
2112 static int acpi_video_bus_remove_backlight_notify_handler(
2113                                                 struct acpi_video_bus *video)
2114 {
2115         if (!video->backlight_notifier_registered)
2116                 return 0;
2117 
2118         video->backlight_notifier_registered = false;
2119 
2120         return backlight_unregister_notifier(&video->backlight_nb);
2121 }
2122 
2123 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
2124 {
2125         struct acpi_video_device *dev, *next;
2126 
2127         mutex_lock(&video->device_list_lock);
2128         list_for_each_entry_safe(dev, next, &video->video_device_list, entry) {
2129                 list_del(&dev->entry);
2130                 kfree(dev);
2131         }
2132         mutex_unlock(&video->device_list_lock);
2133 
2134         return 0;
2135 }
2136 
2137 static int instance;
2138 
2139 static int acpi_video_bus_add(struct acpi_device *device)
2140 {
2141         struct acpi_video_bus *video;
2142         int error;
2143         acpi_status status;
2144 
2145         status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
2146                                 device->parent->handle, 1,
2147                                 acpi_video_bus_match, NULL,
2148                                 device, NULL);
2149         if (status == AE_ALREADY_EXISTS) {
2150                 printk(KERN_WARNING FW_BUG
2151                         "Duplicate ACPI video bus devices for the"
2152                         " same VGA controller, please try module "
2153                         "parameter \"video.allow_duplicates=1\""
2154                         "if the current driver doesn't work.\n");
2155                 if (!allow_duplicates)
2156                         return -ENODEV;
2157         }
2158 
2159         video = kzalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
2160         if (!video)
2161                 return -ENOMEM;
2162 
2163         /* a hack to fix the duplicate name "VID" problem on T61 */
2164         if (!strcmp(device->pnp.bus_id, "VID")) {
2165                 if (instance)
2166                         device->pnp.bus_id[3] = '' + instance;
2167                 instance++;
2168         }
2169         /* a hack to fix the duplicate name "VGA" problem on Pa 3553 */
2170         if (!strcmp(device->pnp.bus_id, "VGA")) {
2171                 if (instance)
2172                         device->pnp.bus_id[3] = '' + instance;
2173                 instance++;
2174         }
2175 
2176         video->device = device;
2177         strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
2178         strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
2179         device->driver_data = video;
2180 
2181         acpi_video_bus_find_cap(video);
2182         error = acpi_video_bus_check(video);
2183         if (error)
2184                 goto err_free_video;
2185 
2186         mutex_init(&video->device_list_lock);
2187         INIT_LIST_HEAD(&video->video_device_list);
2188 
2189         error = acpi_video_bus_get_devices(video, device);
2190         if (error)
2191                 goto err_put_video;
2192 
2193         printk(KERN_INFO PREFIX "%s [%s] (multi-head: %s  rom: %s  post: %s)\n",
2194                ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
2195                video->flags.multihead ? "yes" : "no",
2196                video->flags.rom ? "yes" : "no",
2197                video->flags.post ? "yes" : "no");
2198         mutex_lock(&video_list_lock);
2199         list_add_tail(&video->entry, &video_bus_head);
2200         mutex_unlock(&video_list_lock);
2201 
2202         acpi_video_bus_register_backlight(video);
2203         acpi_video_bus_add_notify_handler(video);
2204         acpi_video_bus_add_backlight_notify_handler(video);
2205 
2206         return 0;
2207 
2208 err_put_video:
2209         acpi_video_bus_put_devices(video);
2210         kfree(video->attached_array);
2211 err_free_video:
2212         kfree(video);
2213         device->driver_data = NULL;
2214 
2215         return error;
2216 }
2217 
2218 static int acpi_video_bus_remove(struct acpi_device *device)
2219 {
2220         struct acpi_video_bus *video = NULL;
2221 
2222 
2223         if (!device || !acpi_driver_data(device))
2224                 return -EINVAL;
2225 
2226         video = acpi_driver_data(device);
2227 
2228         acpi_video_bus_remove_backlight_notify_handler(video);
2229         acpi_video_bus_remove_notify_handler(video);
2230         acpi_video_bus_unregister_backlight(video);
2231         acpi_video_bus_put_devices(video);
2232 
2233         mutex_lock(&video_list_lock);
2234         list_del(&video->entry);
2235         mutex_unlock(&video_list_lock);
2236 
2237         kfree(video->attached_array);
2238         kfree(video);
2239 
2240         return 0;
2241 }
2242 
2243 static int __init is_i740(struct pci_dev *dev)
2244 {
2245         if (dev->device == 0x00D1)
2246                 return 1;
2247         if (dev->device == 0x7000)
2248                 return 1;
2249         return 0;
2250 }
2251 
2252 static int __init intel_opregion_present(void)
2253 {
2254         int opregion = 0;
2255         struct pci_dev *dev = NULL;
2256         u32 address;
2257 
2258         for_each_pci_dev(dev) {
2259                 if ((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
2260                         continue;
2261                 if (dev->vendor != PCI_VENDOR_ID_INTEL)
2262                         continue;
2263                 /* We don't want to poke around undefined i740 registers */
2264                 if (is_i740(dev))
2265                         continue;
2266                 pci_read_config_dword(dev, 0xfc, &address);
2267                 if (!address)
2268                         continue;
2269                 opregion = 1;
2270         }
2271         return opregion;
2272 }
2273 
2274 int acpi_video_register(void)
2275 {
2276         int result = 0;
2277         if (register_count) {
2278                 /*
2279                  * if the function of acpi_video_register is already called,
2280                  * don't register the acpi_vide_bus again and return no error.
2281                  */
2282                 return 0;
2283         }
2284 
2285         mutex_init(&video_list_lock);
2286         INIT_LIST_HEAD(&video_bus_head);
2287 
2288         result = acpi_bus_register_driver(&acpi_video_bus);
2289         if (result < 0)
2290                 return -ENODEV;
2291 
2292         /*
2293          * When the acpi_video_bus is loaded successfully, increase
2294          * the counter reference.
2295          */
2296         register_count = 1;
2297 
2298         return 0;
2299 }
2300 EXPORT_SYMBOL(acpi_video_register);
2301 
2302 void acpi_video_unregister(void)
2303 {
2304         if (!register_count) {
2305                 /*
2306                  * If the acpi video bus is already unloaded, don't
2307                  * unload it again and return directly.
2308                  */
2309                 return;
2310         }
2311         acpi_bus_unregister_driver(&acpi_video_bus);
2312 
2313         register_count = 0;
2314 
2315         return;
2316 }
2317 EXPORT_SYMBOL(acpi_video_unregister);
2318 
2319 void acpi_video_unregister_backlight(void)
2320 {
2321         struct acpi_video_bus *video;
2322 
2323         if (!register_count)
2324                 return;
2325 
2326         mutex_lock(&video_list_lock);
2327         list_for_each_entry(video, &video_bus_head, entry)
2328                 acpi_video_bus_unregister_backlight(video);
2329         mutex_unlock(&video_list_lock);
2330 }
2331 EXPORT_SYMBOL(acpi_video_unregister_backlight);
2332 
2333 /*
2334  * This is kind of nasty. Hardware using Intel chipsets may require
2335  * the video opregion code to be run first in order to initialise
2336  * state before any ACPI video calls are made. To handle this we defer
2337  * registration of the video class until the opregion code has run.
2338  */
2339 
2340 static int __init acpi_video_init(void)
2341 {
2342         dmi_check_system(video_dmi_table);
2343 
2344         if (intel_opregion_present())
2345                 return 0;
2346 
2347         return acpi_video_register();
2348 }
2349 
2350 static void __exit acpi_video_exit(void)
2351 {
2352         acpi_video_unregister();
2353 
2354         return;
2355 }
2356 
2357 module_init(acpi_video_init);
2358 module_exit(acpi_video_exit);
2359 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us