2e2c71fcc9ed502dc3a013089d53a3270999ad51
[linux-2.6-microblaze.git] / drivers / gpu / drm / i915 / intel_opregion.c
1 /*
2  * Copyright 2008 Intel Corporation <hong.liu@intel.com>
3  * Copyright 2008 Red Hat <mjg@redhat.com>
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files (the
7  * "Software"), to deal in the Software without restriction, including
8  * without limitation the rights to use, copy, modify, merge, publish,
9  * distribute, sub license, and/or sell copies of the Software, and to
10  * permit persons to whom the Software is furnished to do so, subject to
11  * the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial
15  * portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20  * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE
21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24  * SOFTWARE.
25  *
26  */
27
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30 #include <linux/acpi.h>
31 #include <acpi/video.h>
32
33 #include <drm/drmP.h>
34 #include <drm/i915_drm.h>
35 #include "i915_drv.h"
36 #include "intel_drv.h"
37
38 #define PCI_ASLE                0xe4
39 #define PCI_ASLS                0xfc
40 #define PCI_SWSCI               0xe8
41 #define PCI_SWSCI_SCISEL        (1 << 15)
42 #define PCI_SWSCI_GSSCIE        (1 << 0)
43
44 #define OPREGION_HEADER_OFFSET 0
45 #define OPREGION_ACPI_OFFSET   0x100
46 #define   ACPI_CLID 0x01ac /* current lid state indicator */
47 #define   ACPI_CDCK 0x01b0 /* current docking state indicator */
48 #define OPREGION_SWSCI_OFFSET  0x200
49 #define OPREGION_ASLE_OFFSET   0x300
50 #define OPREGION_VBT_OFFSET    0x400
51
52 #define OPREGION_SIGNATURE "IntelGraphicsMem"
53 #define MBOX_ACPI      (1<<0)
54 #define MBOX_SWSCI     (1<<1)
55 #define MBOX_ASLE      (1<<2)
56
57 struct opregion_header {
58         u8 signature[16];
59         u32 size;
60         u32 opregion_ver;
61         u8 bios_ver[32];
62         u8 vbios_ver[16];
63         u8 driver_ver[16];
64         u32 mboxes;
65         u8 reserved[164];
66 } __packed;
67
68 /* OpRegion mailbox #1: public ACPI methods */
69 struct opregion_acpi {
70         u32 drdy;       /* driver readiness */
71         u32 csts;       /* notification status */
72         u32 cevt;       /* current event */
73         u8 rsvd1[20];
74         u32 didl[8];    /* supported display devices ID list */
75         u32 cpdl[8];    /* currently presented display list */
76         u32 cadl[8];    /* currently active display list */
77         u32 nadl[8];    /* next active devices list */
78         u32 aslp;       /* ASL sleep time-out */
79         u32 tidx;       /* toggle table index */
80         u32 chpd;       /* current hotplug enable indicator */
81         u32 clid;       /* current lid state*/
82         u32 cdck;       /* current docking state */
83         u32 sxsw;       /* Sx state resume */
84         u32 evts;       /* ASL supported events */
85         u32 cnot;       /* current OS notification */
86         u32 nrdy;       /* driver status */
87         u8 rsvd2[60];
88 } __packed;
89
90 /* OpRegion mailbox #2: SWSCI */
91 struct opregion_swsci {
92         u32 scic;       /* SWSCI command|status|data */
93         u32 parm;       /* command parameters */
94         u32 dslp;       /* driver sleep time-out */
95         u8 rsvd[244];
96 } __packed;
97
98 /* OpRegion mailbox #3: ASLE */
99 struct opregion_asle {
100         u32 ardy;       /* driver readiness */
101         u32 aslc;       /* ASLE interrupt command */
102         u32 tche;       /* technology enabled indicator */
103         u32 alsi;       /* current ALS illuminance reading */
104         u32 bclp;       /* backlight brightness to set */
105         u32 pfit;       /* panel fitting state */
106         u32 cblv;       /* current brightness level */
107         u16 bclm[20];   /* backlight level duty cycle mapping table */
108         u32 cpfm;       /* current panel fitting mode */
109         u32 epfm;       /* enabled panel fitting modes */
110         u8 plut[74];    /* panel LUT and identifier */
111         u32 pfmb;       /* PWM freq and min brightness */
112         u32 cddv;       /* color correction default values */
113         u32 pcft;       /* power conservation features */
114         u32 srot;       /* supported rotation angles */
115         u32 iuer;       /* IUER events */
116         u8 rsvd[86];
117 } __packed;
118
119 /* Driver readiness indicator */
120 #define ASLE_ARDY_READY         (1 << 0)
121 #define ASLE_ARDY_NOT_READY     (0 << 0)
122
123 /* ASLE Interrupt Command (ASLC) bits */
124 #define ASLC_SET_ALS_ILLUM              (1 << 0)
125 #define ASLC_SET_BACKLIGHT              (1 << 1)
126 #define ASLC_SET_PFIT                   (1 << 2)
127 #define ASLC_SET_PWM_FREQ               (1 << 3)
128 #define ASLC_SUPPORTED_ROTATION_ANGLES  (1 << 4)
129 #define ASLC_BUTTON_ARRAY               (1 << 5)
130 #define ASLC_CONVERTIBLE_INDICATOR      (1 << 6)
131 #define ASLC_DOCKING_INDICATOR          (1 << 7)
132 #define ASLC_ISCT_STATE_CHANGE          (1 << 8)
133 #define ASLC_REQ_MSK                    0x1ff
134 /* response bits */
135 #define ASLC_ALS_ILLUM_FAILED           (1 << 10)
136 #define ASLC_BACKLIGHT_FAILED           (1 << 12)
137 #define ASLC_PFIT_FAILED                (1 << 14)
138 #define ASLC_PWM_FREQ_FAILED            (1 << 16)
139 #define ASLC_ROTATION_ANGLES_FAILED     (1 << 18)
140 #define ASLC_BUTTON_ARRAY_FAILED        (1 << 20)
141 #define ASLC_CONVERTIBLE_FAILED         (1 << 22)
142 #define ASLC_DOCKING_FAILED             (1 << 24)
143 #define ASLC_ISCT_STATE_FAILED          (1 << 26)
144
145 /* Technology enabled indicator */
146 #define ASLE_TCHE_ALS_EN        (1 << 0)
147 #define ASLE_TCHE_BLC_EN        (1 << 1)
148 #define ASLE_TCHE_PFIT_EN       (1 << 2)
149 #define ASLE_TCHE_PFMB_EN       (1 << 3)
150
151 /* ASLE backlight brightness to set */
152 #define ASLE_BCLP_VALID                (1<<31)
153 #define ASLE_BCLP_MSK          (~(1<<31))
154
155 /* ASLE panel fitting request */
156 #define ASLE_PFIT_VALID         (1<<31)
157 #define ASLE_PFIT_CENTER (1<<0)
158 #define ASLE_PFIT_STRETCH_TEXT (1<<1)
159 #define ASLE_PFIT_STRETCH_GFX (1<<2)
160
161 /* PWM frequency and minimum brightness */
162 #define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
163 #define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
164 #define ASLE_PFMB_PWM_MASK (0x7ffffe00)
165 #define ASLE_PFMB_PWM_VALID (1<<31)
166
167 #define ASLE_CBLV_VALID         (1<<31)
168
169 /* IUER */
170 #define ASLE_IUER_DOCKING               (1 << 7)
171 #define ASLE_IUER_CONVERTIBLE           (1 << 6)
172 #define ASLE_IUER_ROTATION_LOCK_BTN     (1 << 4)
173 #define ASLE_IUER_VOLUME_DOWN_BTN       (1 << 3)
174 #define ASLE_IUER_VOLUME_UP_BTN         (1 << 2)
175 #define ASLE_IUER_WINDOWS_BTN           (1 << 1)
176 #define ASLE_IUER_POWER_BTN             (1 << 0)
177
178 /* Software System Control Interrupt (SWSCI) */
179 #define SWSCI_SCIC_INDICATOR            (1 << 0)
180 #define SWSCI_SCIC_MAIN_FUNCTION_SHIFT  1
181 #define SWSCI_SCIC_MAIN_FUNCTION_MASK   (0xf << 1)
182 #define SWSCI_SCIC_SUB_FUNCTION_SHIFT   8
183 #define SWSCI_SCIC_SUB_FUNCTION_MASK    (0xff << 8)
184 #define SWSCI_SCIC_EXIT_PARAMETER_SHIFT 8
185 #define SWSCI_SCIC_EXIT_PARAMETER_MASK  (0xff << 8)
186 #define SWSCI_SCIC_EXIT_STATUS_SHIFT    5
187 #define SWSCI_SCIC_EXIT_STATUS_MASK     (7 << 5)
188 #define SWSCI_SCIC_EXIT_STATUS_SUCCESS  1
189
190 #define SWSCI_FUNCTION_CODE(main, sub) \
191         ((main) << SWSCI_SCIC_MAIN_FUNCTION_SHIFT | \
192          (sub) << SWSCI_SCIC_SUB_FUNCTION_SHIFT)
193
194 /* SWSCI: Get BIOS Data (GBDA) */
195 #define SWSCI_GBDA                      4
196 #define SWSCI_GBDA_SUPPORTED_CALLS      SWSCI_FUNCTION_CODE(SWSCI_GBDA, 0)
197 #define SWSCI_GBDA_REQUESTED_CALLBACKS  SWSCI_FUNCTION_CODE(SWSCI_GBDA, 1)
198 #define SWSCI_GBDA_BOOT_DISPLAY_PREF    SWSCI_FUNCTION_CODE(SWSCI_GBDA, 4)
199 #define SWSCI_GBDA_PANEL_DETAILS        SWSCI_FUNCTION_CODE(SWSCI_GBDA, 5)
200 #define SWSCI_GBDA_TV_STANDARD          SWSCI_FUNCTION_CODE(SWSCI_GBDA, 6)
201 #define SWSCI_GBDA_INTERNAL_GRAPHICS    SWSCI_FUNCTION_CODE(SWSCI_GBDA, 7)
202 #define SWSCI_GBDA_SPREAD_SPECTRUM      SWSCI_FUNCTION_CODE(SWSCI_GBDA, 10)
203
204 /* SWSCI: System BIOS Callbacks (SBCB) */
205 #define SWSCI_SBCB                      6
206 #define SWSCI_SBCB_SUPPORTED_CALLBACKS  SWSCI_FUNCTION_CODE(SWSCI_SBCB, 0)
207 #define SWSCI_SBCB_INIT_COMPLETION      SWSCI_FUNCTION_CODE(SWSCI_SBCB, 1)
208 #define SWSCI_SBCB_PRE_HIRES_SET_MODE   SWSCI_FUNCTION_CODE(SWSCI_SBCB, 3)
209 #define SWSCI_SBCB_POST_HIRES_SET_MODE  SWSCI_FUNCTION_CODE(SWSCI_SBCB, 4)
210 #define SWSCI_SBCB_DISPLAY_SWITCH       SWSCI_FUNCTION_CODE(SWSCI_SBCB, 5)
211 #define SWSCI_SBCB_SET_TV_FORMAT        SWSCI_FUNCTION_CODE(SWSCI_SBCB, 6)
212 #define SWSCI_SBCB_ADAPTER_POWER_STATE  SWSCI_FUNCTION_CODE(SWSCI_SBCB, 7)
213 #define SWSCI_SBCB_DISPLAY_POWER_STATE  SWSCI_FUNCTION_CODE(SWSCI_SBCB, 8)
214 #define SWSCI_SBCB_SET_BOOT_DISPLAY     SWSCI_FUNCTION_CODE(SWSCI_SBCB, 9)
215 #define SWSCI_SBCB_SET_PANEL_DETAILS    SWSCI_FUNCTION_CODE(SWSCI_SBCB, 10)
216 #define SWSCI_SBCB_SET_INTERNAL_GFX     SWSCI_FUNCTION_CODE(SWSCI_SBCB, 11)
217 #define SWSCI_SBCB_POST_HIRES_TO_DOS_FS SWSCI_FUNCTION_CODE(SWSCI_SBCB, 16)
218 #define SWSCI_SBCB_SUSPEND_RESUME       SWSCI_FUNCTION_CODE(SWSCI_SBCB, 17)
219 #define SWSCI_SBCB_SET_SPREAD_SPECTRUM  SWSCI_FUNCTION_CODE(SWSCI_SBCB, 18)
220 #define SWSCI_SBCB_POST_VBE_PM          SWSCI_FUNCTION_CODE(SWSCI_SBCB, 19)
221 #define SWSCI_SBCB_ENABLE_DISABLE_AUDIO SWSCI_FUNCTION_CODE(SWSCI_SBCB, 21)
222
223 #define ACPI_OTHER_OUTPUT (0<<8)
224 #define ACPI_VGA_OUTPUT (1<<8)
225 #define ACPI_TV_OUTPUT (2<<8)
226 #define ACPI_DIGITAL_OUTPUT (3<<8)
227 #define ACPI_LVDS_OUTPUT (4<<8)
228
229 #define MAX_DSLP        1500
230
231 #ifdef CONFIG_ACPI
232 static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out)
233 {
234         struct drm_i915_private *dev_priv = dev->dev_private;
235         struct opregion_swsci __iomem *swsci = dev_priv->opregion.swsci;
236         u32 main_function, sub_function, scic;
237         u16 pci_swsci;
238         u32 dslp;
239
240         if (!swsci)
241                 return -ENODEV;
242
243         main_function = (function & SWSCI_SCIC_MAIN_FUNCTION_MASK) >>
244                 SWSCI_SCIC_MAIN_FUNCTION_SHIFT;
245         sub_function = (function & SWSCI_SCIC_SUB_FUNCTION_MASK) >>
246                 SWSCI_SCIC_SUB_FUNCTION_SHIFT;
247
248         /* Check if we can call the function. See swsci_setup for details. */
249         if (main_function == SWSCI_SBCB) {
250                 if ((dev_priv->opregion.swsci_sbcb_sub_functions &
251                      (1 << sub_function)) == 0)
252                         return -EINVAL;
253         } else if (main_function == SWSCI_GBDA) {
254                 if ((dev_priv->opregion.swsci_gbda_sub_functions &
255                      (1 << sub_function)) == 0)
256                         return -EINVAL;
257         }
258
259         /* Driver sleep timeout in ms. */
260         dslp = ioread32(&swsci->dslp);
261         if (!dslp) {
262                 /* The spec says 2ms should be the default, but it's too small
263                  * for some machines. */
264                 dslp = 50;
265         } else if (dslp > MAX_DSLP) {
266                 /* Hey bios, trust must be earned. */
267                 DRM_INFO_ONCE("ACPI BIOS requests an excessive sleep of %u ms, "
268                               "using %u ms instead\n", dslp, MAX_DSLP);
269                 dslp = MAX_DSLP;
270         }
271
272         /* The spec tells us to do this, but we are the only user... */
273         scic = ioread32(&swsci->scic);
274         if (scic & SWSCI_SCIC_INDICATOR) {
275                 DRM_DEBUG_DRIVER("SWSCI request already in progress\n");
276                 return -EBUSY;
277         }
278
279         scic = function | SWSCI_SCIC_INDICATOR;
280
281         iowrite32(parm, &swsci->parm);
282         iowrite32(scic, &swsci->scic);
283
284         /* Ensure SCI event is selected and event trigger is cleared. */
285         pci_read_config_word(dev->pdev, PCI_SWSCI, &pci_swsci);
286         if (!(pci_swsci & PCI_SWSCI_SCISEL) || (pci_swsci & PCI_SWSCI_GSSCIE)) {
287                 pci_swsci |= PCI_SWSCI_SCISEL;
288                 pci_swsci &= ~PCI_SWSCI_GSSCIE;
289                 pci_write_config_word(dev->pdev, PCI_SWSCI, pci_swsci);
290         }
291
292         /* Use event trigger to tell bios to check the mail. */
293         pci_swsci |= PCI_SWSCI_GSSCIE;
294         pci_write_config_word(dev->pdev, PCI_SWSCI, pci_swsci);
295
296         /* Poll for the result. */
297 #define C (((scic = ioread32(&swsci->scic)) & SWSCI_SCIC_INDICATOR) == 0)
298         if (wait_for(C, dslp)) {
299                 DRM_DEBUG_DRIVER("SWSCI request timed out\n");
300                 return -ETIMEDOUT;
301         }
302
303         scic = (scic & SWSCI_SCIC_EXIT_STATUS_MASK) >>
304                 SWSCI_SCIC_EXIT_STATUS_SHIFT;
305
306         /* Note: scic == 0 is an error! */
307         if (scic != SWSCI_SCIC_EXIT_STATUS_SUCCESS) {
308                 DRM_DEBUG_DRIVER("SWSCI request error %u\n", scic);
309                 return -EIO;
310         }
311
312         if (parm_out)
313                 *parm_out = ioread32(&swsci->parm);
314
315         return 0;
316
317 #undef C
318 }
319
320 #define DISPLAY_TYPE_CRT                        0
321 #define DISPLAY_TYPE_TV                         1
322 #define DISPLAY_TYPE_EXTERNAL_FLAT_PANEL        2
323 #define DISPLAY_TYPE_INTERNAL_FLAT_PANEL        3
324
325 int intel_opregion_notify_encoder(struct intel_encoder *intel_encoder,
326                                   bool enable)
327 {
328         struct drm_device *dev = intel_encoder->base.dev;
329         u32 parm = 0;
330         u32 type = 0;
331         u32 port;
332
333         /* don't care about old stuff for now */
334         if (!HAS_DDI(dev))
335                 return 0;
336
337         port = intel_ddi_get_encoder_port(intel_encoder);
338         if (port == PORT_E) {
339                 port = 0;
340         } else {
341                 parm |= 1 << port;
342                 port++;
343         }
344
345         if (!enable)
346                 parm |= 4 << 8;
347
348         switch (intel_encoder->type) {
349         case INTEL_OUTPUT_ANALOG:
350                 type = DISPLAY_TYPE_CRT;
351                 break;
352         case INTEL_OUTPUT_UNKNOWN:
353         case INTEL_OUTPUT_DISPLAYPORT:
354         case INTEL_OUTPUT_HDMI:
355                 type = DISPLAY_TYPE_EXTERNAL_FLAT_PANEL;
356                 break;
357         case INTEL_OUTPUT_EDP:
358                 type = DISPLAY_TYPE_INTERNAL_FLAT_PANEL;
359                 break;
360         default:
361                 WARN_ONCE(1, "unsupported intel_encoder type %d\n",
362                           intel_encoder->type);
363                 return -EINVAL;
364         }
365
366         parm |= type << (16 + port * 3);
367
368         return swsci(dev, SWSCI_SBCB_DISPLAY_POWER_STATE, parm, NULL);
369 }
370
371 static const struct {
372         pci_power_t pci_power_state;
373         u32 parm;
374 } power_state_map[] = {
375         { PCI_D0,       0x00 },
376         { PCI_D1,       0x01 },
377         { PCI_D2,       0x02 },
378         { PCI_D3hot,    0x04 },
379         { PCI_D3cold,   0x04 },
380 };
381
382 int intel_opregion_notify_adapter(struct drm_device *dev, pci_power_t state)
383 {
384         int i;
385
386         if (!HAS_DDI(dev))
387                 return 0;
388
389         for (i = 0; i < ARRAY_SIZE(power_state_map); i++) {
390                 if (state == power_state_map[i].pci_power_state)
391                         return swsci(dev, SWSCI_SBCB_ADAPTER_POWER_STATE,
392                                      power_state_map[i].parm, NULL);
393         }
394
395         return -EINVAL;
396 }
397
398 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
399 {
400         struct drm_i915_private *dev_priv = dev->dev_private;
401         struct intel_connector *intel_connector;
402         struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
403
404         DRM_DEBUG_DRIVER("bclp = 0x%08x\n", bclp);
405
406         if (!(bclp & ASLE_BCLP_VALID))
407                 return ASLC_BACKLIGHT_FAILED;
408
409         bclp &= ASLE_BCLP_MSK;
410         if (bclp > 255)
411                 return ASLC_BACKLIGHT_FAILED;
412
413         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
414
415         /*
416          * Update backlight on all connectors that support backlight (usually
417          * only one).
418          */
419         DRM_DEBUG_KMS("updating opregion backlight %d/255\n", bclp);
420         list_for_each_entry(intel_connector, &dev->mode_config.connector_list, base.head)
421                 intel_panel_set_backlight(intel_connector, bclp, 255);
422         iowrite32(DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID, &asle->cblv);
423
424         drm_modeset_unlock(&dev->mode_config.connection_mutex);
425
426
427         return 0;
428 }
429
430 static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
431 {
432         /* alsi is the current ALS reading in lux. 0 indicates below sensor
433            range, 0xffff indicates above sensor range. 1-0xfffe are valid */
434         DRM_DEBUG_DRIVER("Illum is not supported\n");
435         return ASLC_ALS_ILLUM_FAILED;
436 }
437
438 static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
439 {
440         DRM_DEBUG_DRIVER("PWM freq is not supported\n");
441         return ASLC_PWM_FREQ_FAILED;
442 }
443
444 static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
445 {
446         /* Panel fitting is currently controlled by the X code, so this is a
447            noop until modesetting support works fully */
448         DRM_DEBUG_DRIVER("Pfit is not supported\n");
449         return ASLC_PFIT_FAILED;
450 }
451
452 static u32 asle_set_supported_rotation_angles(struct drm_device *dev, u32 srot)
453 {
454         DRM_DEBUG_DRIVER("SROT is not supported\n");
455         return ASLC_ROTATION_ANGLES_FAILED;
456 }
457
458 static u32 asle_set_button_array(struct drm_device *dev, u32 iuer)
459 {
460         if (!iuer)
461                 DRM_DEBUG_DRIVER("Button array event is not supported (nothing)\n");
462         if (iuer & ASLE_IUER_ROTATION_LOCK_BTN)
463                 DRM_DEBUG_DRIVER("Button array event is not supported (rotation lock)\n");
464         if (iuer & ASLE_IUER_VOLUME_DOWN_BTN)
465                 DRM_DEBUG_DRIVER("Button array event is not supported (volume down)\n");
466         if (iuer & ASLE_IUER_VOLUME_UP_BTN)
467                 DRM_DEBUG_DRIVER("Button array event is not supported (volume up)\n");
468         if (iuer & ASLE_IUER_WINDOWS_BTN)
469                 DRM_DEBUG_DRIVER("Button array event is not supported (windows)\n");
470         if (iuer & ASLE_IUER_POWER_BTN)
471                 DRM_DEBUG_DRIVER("Button array event is not supported (power)\n");
472
473         return ASLC_BUTTON_ARRAY_FAILED;
474 }
475
476 static u32 asle_set_convertible(struct drm_device *dev, u32 iuer)
477 {
478         if (iuer & ASLE_IUER_CONVERTIBLE)
479                 DRM_DEBUG_DRIVER("Convertible is not supported (clamshell)\n");
480         else
481                 DRM_DEBUG_DRIVER("Convertible is not supported (slate)\n");
482
483         return ASLC_CONVERTIBLE_FAILED;
484 }
485
486 static u32 asle_set_docking(struct drm_device *dev, u32 iuer)
487 {
488         if (iuer & ASLE_IUER_DOCKING)
489                 DRM_DEBUG_DRIVER("Docking is not supported (docked)\n");
490         else
491                 DRM_DEBUG_DRIVER("Docking is not supported (undocked)\n");
492
493         return ASLC_DOCKING_FAILED;
494 }
495
496 static u32 asle_isct_state(struct drm_device *dev)
497 {
498         DRM_DEBUG_DRIVER("ISCT is not supported\n");
499         return ASLC_ISCT_STATE_FAILED;
500 }
501
502 static void asle_work(struct work_struct *work)
503 {
504         struct intel_opregion *opregion =
505                 container_of(work, struct intel_opregion, asle_work);
506         struct drm_i915_private *dev_priv =
507                 container_of(opregion, struct drm_i915_private, opregion);
508         struct drm_device *dev = dev_priv->dev;
509         struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
510         u32 aslc_stat = 0;
511         u32 aslc_req;
512
513         if (!asle)
514                 return;
515
516         aslc_req = ioread32(&asle->aslc);
517
518         if (!(aslc_req & ASLC_REQ_MSK)) {
519                 DRM_DEBUG_DRIVER("No request on ASLC interrupt 0x%08x\n",
520                                  aslc_req);
521                 return;
522         }
523
524         if (aslc_req & ASLC_SET_ALS_ILLUM)
525                 aslc_stat |= asle_set_als_illum(dev, ioread32(&asle->alsi));
526
527         if (aslc_req & ASLC_SET_BACKLIGHT)
528                 aslc_stat |= asle_set_backlight(dev, ioread32(&asle->bclp));
529
530         if (aslc_req & ASLC_SET_PFIT)
531                 aslc_stat |= asle_set_pfit(dev, ioread32(&asle->pfit));
532
533         if (aslc_req & ASLC_SET_PWM_FREQ)
534                 aslc_stat |= asle_set_pwm_freq(dev, ioread32(&asle->pfmb));
535
536         if (aslc_req & ASLC_SUPPORTED_ROTATION_ANGLES)
537                 aslc_stat |= asle_set_supported_rotation_angles(dev,
538                                                         ioread32(&asle->srot));
539
540         if (aslc_req & ASLC_BUTTON_ARRAY)
541                 aslc_stat |= asle_set_button_array(dev, ioread32(&asle->iuer));
542
543         if (aslc_req & ASLC_CONVERTIBLE_INDICATOR)
544                 aslc_stat |= asle_set_convertible(dev, ioread32(&asle->iuer));
545
546         if (aslc_req & ASLC_DOCKING_INDICATOR)
547                 aslc_stat |= asle_set_docking(dev, ioread32(&asle->iuer));
548
549         if (aslc_req & ASLC_ISCT_STATE_CHANGE)
550                 aslc_stat |= asle_isct_state(dev);
551
552         iowrite32(aslc_stat, &asle->aslc);
553 }
554
555 void intel_opregion_asle_intr(struct drm_device *dev)
556 {
557         struct drm_i915_private *dev_priv = dev->dev_private;
558
559         if (dev_priv->opregion.asle)
560                 schedule_work(&dev_priv->opregion.asle_work);
561 }
562
563 #define ACPI_EV_DISPLAY_SWITCH (1<<0)
564 #define ACPI_EV_LID            (1<<1)
565 #define ACPI_EV_DOCK           (1<<2)
566
567 static struct intel_opregion *system_opregion;
568
569 static int intel_opregion_video_event(struct notifier_block *nb,
570                                       unsigned long val, void *data)
571 {
572         /* The only video events relevant to opregion are 0x80. These indicate
573            either a docking event, lid switch or display switch request. In
574            Linux, these are handled by the dock, button and video drivers.
575         */
576
577         struct opregion_acpi __iomem *acpi;
578         struct acpi_bus_event *event = data;
579         int ret = NOTIFY_OK;
580
581         if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
582                 return NOTIFY_DONE;
583
584         if (!system_opregion)
585                 return NOTIFY_DONE;
586
587         acpi = system_opregion->acpi;
588
589         if (event->type == 0x80 &&
590             (ioread32(&acpi->cevt) & 1) == 0)
591                 ret = NOTIFY_BAD;
592
593         iowrite32(0, &acpi->csts);
594
595         return ret;
596 }
597
598 static struct notifier_block intel_opregion_notifier = {
599         .notifier_call = intel_opregion_video_event,
600 };
601
602 /*
603  * Initialise the DIDL field in opregion. This passes a list of devices to
604  * the firmware. Values are defined by section B.4.2 of the ACPI specification
605  * (version 3)
606  */
607
608 static void intel_didl_outputs(struct drm_device *dev)
609 {
610         struct drm_i915_private *dev_priv = dev->dev_private;
611         struct intel_opregion *opregion = &dev_priv->opregion;
612         struct drm_connector *connector;
613         acpi_handle handle;
614         struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
615         unsigned long long device_id;
616         acpi_status status;
617         u32 temp;
618         int i = 0;
619
620         handle = ACPI_HANDLE(&dev->pdev->dev);
621         if (!handle || acpi_bus_get_device(handle, &acpi_dev))
622                 return;
623
624         if (acpi_is_video_device(handle))
625                 acpi_video_bus = acpi_dev;
626         else {
627                 list_for_each_entry(acpi_cdev, &acpi_dev->children, node) {
628                         if (acpi_is_video_device(acpi_cdev->handle)) {
629                                 acpi_video_bus = acpi_cdev;
630                                 break;
631                         }
632                 }
633         }
634
635         if (!acpi_video_bus) {
636                 pr_warn("No ACPI video bus found\n");
637                 return;
638         }
639
640         list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
641                 if (i >= 8) {
642                         dev_dbg(&dev->pdev->dev,
643                                 "More than 8 outputs detected via ACPI\n");
644                         return;
645                 }
646                 status =
647                         acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
648                                                 NULL, &device_id);
649                 if (ACPI_SUCCESS(status)) {
650                         if (!device_id)
651                                 goto blind_set;
652                         iowrite32((u32)(device_id & 0x0f0f),
653                                   &opregion->acpi->didl[i]);
654                         i++;
655                 }
656         }
657
658 end:
659         /* If fewer than 8 outputs, the list must be null terminated */
660         if (i < 8)
661                 iowrite32(0, &opregion->acpi->didl[i]);
662         return;
663
664 blind_set:
665         i = 0;
666         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
667                 int output_type = ACPI_OTHER_OUTPUT;
668                 if (i >= 8) {
669                         dev_dbg(&dev->pdev->dev,
670                                 "More than 8 outputs in connector list\n");
671                         return;
672                 }
673                 switch (connector->connector_type) {
674                 case DRM_MODE_CONNECTOR_VGA:
675                 case DRM_MODE_CONNECTOR_DVIA:
676                         output_type = ACPI_VGA_OUTPUT;
677                         break;
678                 case DRM_MODE_CONNECTOR_Composite:
679                 case DRM_MODE_CONNECTOR_SVIDEO:
680                 case DRM_MODE_CONNECTOR_Component:
681                 case DRM_MODE_CONNECTOR_9PinDIN:
682                         output_type = ACPI_TV_OUTPUT;
683                         break;
684                 case DRM_MODE_CONNECTOR_DVII:
685                 case DRM_MODE_CONNECTOR_DVID:
686                 case DRM_MODE_CONNECTOR_DisplayPort:
687                 case DRM_MODE_CONNECTOR_HDMIA:
688                 case DRM_MODE_CONNECTOR_HDMIB:
689                         output_type = ACPI_DIGITAL_OUTPUT;
690                         break;
691                 case DRM_MODE_CONNECTOR_LVDS:
692                         output_type = ACPI_LVDS_OUTPUT;
693                         break;
694                 }
695                 temp = ioread32(&opregion->acpi->didl[i]);
696                 iowrite32(temp | (1<<31) | output_type | i,
697                           &opregion->acpi->didl[i]);
698                 i++;
699         }
700         goto end;
701 }
702
703 static void intel_setup_cadls(struct drm_device *dev)
704 {
705         struct drm_i915_private *dev_priv = dev->dev_private;
706         struct intel_opregion *opregion = &dev_priv->opregion;
707         int i = 0;
708         u32 disp_id;
709
710         /* Initialize the CADL field by duplicating the DIDL values.
711          * Technically, this is not always correct as display outputs may exist,
712          * but not active. This initialization is necessary for some Clevo
713          * laptops that check this field before processing the brightness and
714          * display switching hotkeys. Just like DIDL, CADL is NULL-terminated if
715          * there are less than eight devices. */
716         do {
717                 disp_id = ioread32(&opregion->acpi->didl[i]);
718                 iowrite32(disp_id, &opregion->acpi->cadl[i]);
719         } while (++i < 8 && disp_id != 0);
720 }
721
722 void intel_opregion_init(struct drm_device *dev)
723 {
724         struct drm_i915_private *dev_priv = dev->dev_private;
725         struct intel_opregion *opregion = &dev_priv->opregion;
726
727         if (!opregion->header)
728                 return;
729
730         if (opregion->acpi) {
731                 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
732                         intel_didl_outputs(dev);
733                         intel_setup_cadls(dev);
734                 }
735
736                 /* Notify BIOS we are ready to handle ACPI video ext notifs.
737                  * Right now, all the events are handled by the ACPI video module.
738                  * We don't actually need to do anything with them. */
739                 iowrite32(0, &opregion->acpi->csts);
740                 iowrite32(1, &opregion->acpi->drdy);
741
742                 system_opregion = opregion;
743                 register_acpi_notifier(&intel_opregion_notifier);
744         }
745
746         if (opregion->asle) {
747                 iowrite32(ASLE_TCHE_BLC_EN, &opregion->asle->tche);
748                 iowrite32(ASLE_ARDY_READY, &opregion->asle->ardy);
749         }
750 }
751
752 void intel_opregion_fini(struct drm_device *dev)
753 {
754         struct drm_i915_private *dev_priv = dev->dev_private;
755         struct intel_opregion *opregion = &dev_priv->opregion;
756
757         if (!opregion->header)
758                 return;
759
760         if (opregion->asle)
761                 iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
762
763         cancel_work_sync(&dev_priv->opregion.asle_work);
764
765         if (opregion->acpi) {
766                 iowrite32(0, &opregion->acpi->drdy);
767
768                 system_opregion = NULL;
769                 unregister_acpi_notifier(&intel_opregion_notifier);
770         }
771
772         /* just clear all opregion memory pointers now */
773         iounmap(opregion->header);
774         opregion->header = NULL;
775         opregion->acpi = NULL;
776         opregion->swsci = NULL;
777         opregion->asle = NULL;
778         opregion->vbt = NULL;
779         opregion->lid_state = NULL;
780 }
781
782 static void swsci_setup(struct drm_device *dev)
783 {
784         struct drm_i915_private *dev_priv = dev->dev_private;
785         struct intel_opregion *opregion = &dev_priv->opregion;
786         bool requested_callbacks = false;
787         u32 tmp;
788
789         /* Sub-function code 0 is okay, let's allow them. */
790         opregion->swsci_gbda_sub_functions = 1;
791         opregion->swsci_sbcb_sub_functions = 1;
792
793         /* We use GBDA to ask for supported GBDA calls. */
794         if (swsci(dev, SWSCI_GBDA_SUPPORTED_CALLS, 0, &tmp) == 0) {
795                 /* make the bits match the sub-function codes */
796                 tmp <<= 1;
797                 opregion->swsci_gbda_sub_functions |= tmp;
798         }
799
800         /*
801          * We also use GBDA to ask for _requested_ SBCB callbacks. The driver
802          * must not call interfaces that are not specifically requested by the
803          * bios.
804          */
805         if (swsci(dev, SWSCI_GBDA_REQUESTED_CALLBACKS, 0, &tmp) == 0) {
806                 /* here, the bits already match sub-function codes */
807                 opregion->swsci_sbcb_sub_functions |= tmp;
808                 requested_callbacks = true;
809         }
810
811         /*
812          * But we use SBCB to ask for _supported_ SBCB calls. This does not mean
813          * the callback is _requested_. But we still can't call interfaces that
814          * are not requested.
815          */
816         if (swsci(dev, SWSCI_SBCB_SUPPORTED_CALLBACKS, 0, &tmp) == 0) {
817                 /* make the bits match the sub-function codes */
818                 u32 low = tmp & 0x7ff;
819                 u32 high = tmp & ~0xfff; /* bit 11 is reserved */
820                 tmp = (high << 4) | (low << 1) | 1;
821
822                 /* best guess what to do with supported wrt requested */
823                 if (requested_callbacks) {
824                         u32 req = opregion->swsci_sbcb_sub_functions;
825                         if ((req & tmp) != req)
826                                 DRM_DEBUG_DRIVER("SWSCI BIOS requested (%08x) SBCB callbacks that are not supported (%08x)\n", req, tmp);
827                         /* XXX: for now, trust the requested callbacks */
828                         /* opregion->swsci_sbcb_sub_functions &= tmp; */
829                 } else {
830                         opregion->swsci_sbcb_sub_functions |= tmp;
831                 }
832         }
833
834         DRM_DEBUG_DRIVER("SWSCI GBDA callbacks %08x, SBCB callbacks %08x\n",
835                          opregion->swsci_gbda_sub_functions,
836                          opregion->swsci_sbcb_sub_functions);
837 }
838 #else /* CONFIG_ACPI */
839 static inline void swsci_setup(struct drm_device *dev) {}
840 #endif  /* CONFIG_ACPI */
841
842 int intel_opregion_setup(struct drm_device *dev)
843 {
844         struct drm_i915_private *dev_priv = dev->dev_private;
845         struct intel_opregion *opregion = &dev_priv->opregion;
846         void __iomem *base;
847         u32 asls, mboxes;
848         char buf[sizeof(OPREGION_SIGNATURE)];
849         int err = 0;
850
851         pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
852         DRM_DEBUG_DRIVER("graphic opregion physical addr: 0x%x\n", asls);
853         if (asls == 0) {
854                 DRM_DEBUG_DRIVER("ACPI OpRegion not supported!\n");
855                 return -ENOTSUPP;
856         }
857
858 #ifdef CONFIG_ACPI
859         INIT_WORK(&opregion->asle_work, asle_work);
860 #endif
861
862         base = acpi_os_ioremap(asls, OPREGION_SIZE);
863         if (!base)
864                 return -ENOMEM;
865
866         memcpy_fromio(buf, base, sizeof(buf));
867
868         if (memcmp(buf, OPREGION_SIGNATURE, 16)) {
869                 DRM_DEBUG_DRIVER("opregion signature mismatch\n");
870                 err = -EINVAL;
871                 goto err_out;
872         }
873         opregion->header = base;
874         opregion->vbt = base + OPREGION_VBT_OFFSET;
875
876         opregion->lid_state = base + ACPI_CLID;
877
878         mboxes = ioread32(&opregion->header->mboxes);
879         if (mboxes & MBOX_ACPI) {
880                 DRM_DEBUG_DRIVER("Public ACPI methods supported\n");
881                 opregion->acpi = base + OPREGION_ACPI_OFFSET;
882         }
883
884         if (mboxes & MBOX_SWSCI) {
885                 DRM_DEBUG_DRIVER("SWSCI supported\n");
886                 opregion->swsci = base + OPREGION_SWSCI_OFFSET;
887                 swsci_setup(dev);
888         }
889         if (mboxes & MBOX_ASLE) {
890                 DRM_DEBUG_DRIVER("ASLE supported\n");
891                 opregion->asle = base + OPREGION_ASLE_OFFSET;
892
893                 iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
894         }
895
896         return 0;
897
898 err_out:
899         iounmap(base);
900         return err;
901 }