1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30#include <linux/acpi.h>
31#include <linux/acpi_io.h>
32#include <acpi/video.h>
33
34#include <drm/drmP.h>
35#include <drm/i915_drm.h>
36#include "i915_drv.h"
37#include "intel_drv.h"
38
39#define PCI_ASLE 0xe4
40#define PCI_ASLS 0xfc
41
42#define OPREGION_HEADER_OFFSET 0
43#define OPREGION_ACPI_OFFSET 0x100
44#define ACPI_CLID 0x01ac
45#define ACPI_CDCK 0x01b0
46#define OPREGION_SWSCI_OFFSET 0x200
47#define OPREGION_ASLE_OFFSET 0x300
48#define OPREGION_VBT_OFFSET 0x400
49
50#define OPREGION_SIGNATURE "IntelGraphicsMem"
51#define MBOX_ACPI (1<<0)
52#define MBOX_SWSCI (1<<1)
53#define MBOX_ASLE (1<<2)
54
55struct opregion_header {
56 u8 signature[16];
57 u32 size;
58 u32 opregion_ver;
59 u8 bios_ver[32];
60 u8 vbios_ver[16];
61 u8 driver_ver[16];
62 u32 mboxes;
63 u8 reserved[164];
64} __attribute__((packed));
65
66
67struct opregion_acpi {
68 u32 drdy;
69 u32 csts;
70 u32 cevt;
71 u8 rsvd1[20];
72 u32 didl[8];
73 u32 cpdl[8];
74 u32 cadl[8];
75 u32 nadl[8];
76 u32 aslp;
77 u32 tidx;
78 u32 chpd;
79 u32 clid;
80 u32 cdck;
81 u32 sxsw;
82 u32 evts;
83 u32 cnot;
84 u32 nrdy;
85 u8 rsvd2[60];
86} __attribute__((packed));
87
88
89struct opregion_swsci {
90 u32 scic;
91 u32 parm;
92 u32 dslp;
93 u8 rsvd[244];
94} __attribute__((packed));
95
96
97struct opregion_asle {
98 u32 ardy;
99 u32 aslc;
100 u32 tche;
101 u32 alsi;
102 u32 bclp;
103 u32 pfit;
104 u32 cblv;
105 u16 bclm[20];
106 u32 cpfm;
107 u32 epfm;
108 u8 plut[74];
109 u32 pfmb;
110 u8 rsvd[102];
111} __attribute__((packed));
112
113
114#define ASLE_ARDY_READY (1 << 0)
115#define ASLE_ARDY_NOT_READY (0 << 0)
116
117
118#define ASLE_SET_ALS_ILLUM (1 << 0)
119#define ASLE_SET_BACKLIGHT (1 << 1)
120#define ASLE_SET_PFIT (1 << 2)
121#define ASLE_SET_PWM_FREQ (1 << 3)
122#define ASLE_REQ_MSK 0xf
123
124
125#define ASLE_ALS_ILLUM_FAILED (1<<10)
126#define ASLE_BACKLIGHT_FAILED (1<<12)
127#define ASLE_PFIT_FAILED (1<<14)
128#define ASLE_PWM_FREQ_FAILED (1<<16)
129
130
131#define ASLE_TCHE_ALS_EN (1 << 0)
132#define ASLE_TCHE_BLC_EN (1 << 1)
133#define ASLE_TCHE_PFIT_EN (1 << 2)
134#define ASLE_TCHE_PFMB_EN (1 << 3)
135
136
137#define ASLE_BCLP_VALID (1<<31)
138#define ASLE_BCLP_MSK (~(1<<31))
139
140
141#define ASLE_PFIT_VALID (1<<31)
142#define ASLE_PFIT_CENTER (1<<0)
143#define ASLE_PFIT_STRETCH_TEXT (1<<1)
144#define ASLE_PFIT_STRETCH_GFX (1<<2)
145
146
147#define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
148#define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
149#define ASLE_PFMB_PWM_MASK (0x7ffffe00)
150#define ASLE_PFMB_PWM_VALID (1<<31)
151
152#define ASLE_CBLV_VALID (1<<31)
153
154#define ACPI_OTHER_OUTPUT (0<<8)
155#define ACPI_VGA_OUTPUT (1<<8)
156#define ACPI_TV_OUTPUT (2<<8)
157#define ACPI_DIGITAL_OUTPUT (3<<8)
158#define ACPI_LVDS_OUTPUT (4<<8)
159
160#ifdef CONFIG_ACPI
161static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
162{
163 struct drm_i915_private *dev_priv = dev->dev_private;
164 struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
165
166 DRM_DEBUG_DRIVER("bclp = 0x%08x\n", bclp);
167
168 if (!(bclp & ASLE_BCLP_VALID))
169 return ASLE_BACKLIGHT_FAILED;
170
171 bclp &= ASLE_BCLP_MSK;
172 if (bclp > 255)
173 return ASLE_BACKLIGHT_FAILED;
174
175 intel_panel_set_backlight(dev, bclp, 255);
176 iowrite32((bclp*0x64)/0xff | ASLE_CBLV_VALID, &asle->cblv);
177
178 return 0;
179}
180
181static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
182{
183
184
185 DRM_DEBUG_DRIVER("Illum is not supported\n");
186 return ASLE_ALS_ILLUM_FAILED;
187}
188
189static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
190{
191 DRM_DEBUG_DRIVER("PWM freq is not supported\n");
192 return ASLE_PWM_FREQ_FAILED;
193}
194
195static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
196{
197
198
199 DRM_DEBUG_DRIVER("Pfit is not supported\n");
200 return ASLE_PFIT_FAILED;
201}
202
203void intel_opregion_asle_intr(struct drm_device *dev)
204{
205 struct drm_i915_private *dev_priv = dev->dev_private;
206 struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
207 u32 asle_stat = 0;
208 u32 asle_req;
209
210 if (!asle)
211 return;
212
213 asle_req = ioread32(&asle->aslc) & ASLE_REQ_MSK;
214
215 if (!asle_req) {
216 DRM_DEBUG_DRIVER("non asle set request??\n");
217 return;
218 }
219
220 if (asle_req & ASLE_SET_ALS_ILLUM)
221 asle_stat |= asle_set_als_illum(dev, ioread32(&asle->alsi));
222
223 if (asle_req & ASLE_SET_BACKLIGHT)
224 asle_stat |= asle_set_backlight(dev, ioread32(&asle->bclp));
225
226 if (asle_req & ASLE_SET_PFIT)
227 asle_stat |= asle_set_pfit(dev, ioread32(&asle->pfit));
228
229 if (asle_req & ASLE_SET_PWM_FREQ)
230 asle_stat |= asle_set_pwm_freq(dev, ioread32(&asle->pfmb));
231
232 iowrite32(asle_stat, &asle->aslc);
233}
234
235#define ACPI_EV_DISPLAY_SWITCH (1<<0)
236#define ACPI_EV_LID (1<<1)
237#define ACPI_EV_DOCK (1<<2)
238
239static struct intel_opregion *system_opregion;
240
241static int intel_opregion_video_event(struct notifier_block *nb,
242 unsigned long val, void *data)
243{
244
245
246
247
248
249 struct opregion_acpi __iomem *acpi;
250 struct acpi_bus_event *event = data;
251 int ret = NOTIFY_OK;
252
253 if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
254 return NOTIFY_DONE;
255
256 if (!system_opregion)
257 return NOTIFY_DONE;
258
259 acpi = system_opregion->acpi;
260
261 if (event->type == 0x80 &&
262 (ioread32(&acpi->cevt) & 1) == 0)
263 ret = NOTIFY_BAD;
264
265 iowrite32(0, &acpi->csts);
266
267 return ret;
268}
269
270static struct notifier_block intel_opregion_notifier = {
271 .notifier_call = intel_opregion_video_event,
272};
273
274
275
276
277
278
279
280static void intel_didl_outputs(struct drm_device *dev)
281{
282 struct drm_i915_private *dev_priv = dev->dev_private;
283 struct intel_opregion *opregion = &dev_priv->opregion;
284 struct drm_connector *connector;
285 acpi_handle handle;
286 struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
287 unsigned long long device_id;
288 acpi_status status;
289 u32 temp;
290 int i = 0;
291
292 handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
293 if (!handle || acpi_bus_get_device(handle, &acpi_dev))
294 return;
295
296 if (acpi_is_video_device(handle))
297 acpi_video_bus = acpi_dev;
298 else {
299 list_for_each_entry(acpi_cdev, &acpi_dev->children, node) {
300 if (acpi_is_video_device(acpi_cdev->handle)) {
301 acpi_video_bus = acpi_cdev;
302 break;
303 }
304 }
305 }
306
307 if (!acpi_video_bus) {
308 pr_warn("No ACPI video bus found\n");
309 return;
310 }
311
312 list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
313 if (i >= 8) {
314 dev_dbg(&dev->pdev->dev,
315 "More than 8 outputs detected via ACPI\n");
316 return;
317 }
318 status =
319 acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
320 NULL, &device_id);
321 if (ACPI_SUCCESS(status)) {
322 if (!device_id)
323 goto blind_set;
324 iowrite32((u32)(device_id & 0x0f0f),
325 &opregion->acpi->didl[i]);
326 i++;
327 }
328 }
329
330end:
331
332 if (i < 8)
333 iowrite32(0, &opregion->acpi->didl[i]);
334 return;
335
336blind_set:
337 i = 0;
338 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
339 int output_type = ACPI_OTHER_OUTPUT;
340 if (i >= 8) {
341 dev_dbg(&dev->pdev->dev,
342 "More than 8 outputs in connector list\n");
343 return;
344 }
345 switch (connector->connector_type) {
346 case DRM_MODE_CONNECTOR_VGA:
347 case DRM_MODE_CONNECTOR_DVIA:
348 output_type = ACPI_VGA_OUTPUT;
349 break;
350 case DRM_MODE_CONNECTOR_Composite:
351 case DRM_MODE_CONNECTOR_SVIDEO:
352 case DRM_MODE_CONNECTOR_Component:
353 case DRM_MODE_CONNECTOR_9PinDIN:
354 output_type = ACPI_TV_OUTPUT;
355 break;
356 case DRM_MODE_CONNECTOR_DVII:
357 case DRM_MODE_CONNECTOR_DVID:
358 case DRM_MODE_CONNECTOR_DisplayPort:
359 case DRM_MODE_CONNECTOR_HDMIA:
360 case DRM_MODE_CONNECTOR_HDMIB:
361 output_type = ACPI_DIGITAL_OUTPUT;
362 break;
363 case DRM_MODE_CONNECTOR_LVDS:
364 output_type = ACPI_LVDS_OUTPUT;
365 break;
366 }
367 temp = ioread32(&opregion->acpi->didl[i]);
368 iowrite32(temp | (1<<31) | output_type | i,
369 &opregion->acpi->didl[i]);
370 i++;
371 }
372 goto end;
373}
374
375static void intel_setup_cadls(struct drm_device *dev)
376{
377 struct drm_i915_private *dev_priv = dev->dev_private;
378 struct intel_opregion *opregion = &dev_priv->opregion;
379 int i = 0;
380 u32 disp_id;
381
382
383
384
385
386
387
388 do {
389 disp_id = ioread32(&opregion->acpi->didl[i]);
390 iowrite32(disp_id, &opregion->acpi->cadl[i]);
391 } while (++i < 8 && disp_id != 0);
392}
393
394void intel_opregion_init(struct drm_device *dev)
395{
396 struct drm_i915_private *dev_priv = dev->dev_private;
397 struct intel_opregion *opregion = &dev_priv->opregion;
398
399 if (!opregion->header)
400 return;
401
402 if (opregion->acpi) {
403 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
404 intel_didl_outputs(dev);
405 intel_setup_cadls(dev);
406 }
407
408
409
410
411 iowrite32(0, &opregion->acpi->csts);
412 iowrite32(1, &opregion->acpi->drdy);
413
414 system_opregion = opregion;
415 register_acpi_notifier(&intel_opregion_notifier);
416 }
417
418 if (opregion->asle) {
419 iowrite32(ASLE_TCHE_BLC_EN, &opregion->asle->tche);
420 iowrite32(ASLE_ARDY_READY, &opregion->asle->ardy);
421 }
422}
423
424void intel_opregion_fini(struct drm_device *dev)
425{
426 struct drm_i915_private *dev_priv = dev->dev_private;
427 struct intel_opregion *opregion = &dev_priv->opregion;
428
429 if (!opregion->header)
430 return;
431
432 if (opregion->asle)
433 iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
434
435 if (opregion->acpi) {
436 iowrite32(0, &opregion->acpi->drdy);
437
438 system_opregion = NULL;
439 unregister_acpi_notifier(&intel_opregion_notifier);
440 }
441
442
443 iounmap(opregion->header);
444 opregion->header = NULL;
445 opregion->acpi = NULL;
446 opregion->swsci = NULL;
447 opregion->asle = NULL;
448 opregion->vbt = NULL;
449}
450#endif
451
452int intel_opregion_setup(struct drm_device *dev)
453{
454 struct drm_i915_private *dev_priv = dev->dev_private;
455 struct intel_opregion *opregion = &dev_priv->opregion;
456 void __iomem *base;
457 u32 asls, mboxes;
458 char buf[sizeof(OPREGION_SIGNATURE)];
459 int err = 0;
460
461 pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
462 DRM_DEBUG_DRIVER("graphic opregion physical addr: 0x%x\n", asls);
463 if (asls == 0) {
464 DRM_DEBUG_DRIVER("ACPI OpRegion not supported!\n");
465 return -ENOTSUPP;
466 }
467
468 base = acpi_os_ioremap(asls, OPREGION_SIZE);
469 if (!base)
470 return -ENOMEM;
471
472 memcpy_fromio(buf, base, sizeof(buf));
473
474 if (memcmp(buf, OPREGION_SIGNATURE, 16)) {
475 DRM_DEBUG_DRIVER("opregion signature mismatch\n");
476 err = -EINVAL;
477 goto err_out;
478 }
479 opregion->header = base;
480 opregion->vbt = base + OPREGION_VBT_OFFSET;
481
482 opregion->lid_state = base + ACPI_CLID;
483
484 mboxes = ioread32(&opregion->header->mboxes);
485 if (mboxes & MBOX_ACPI) {
486 DRM_DEBUG_DRIVER("Public ACPI methods supported\n");
487 opregion->acpi = base + OPREGION_ACPI_OFFSET;
488 }
489
490 if (mboxes & MBOX_SWSCI) {
491 DRM_DEBUG_DRIVER("SWSCI supported\n");
492 opregion->swsci = base + OPREGION_SWSCI_OFFSET;
493 }
494 if (mboxes & MBOX_ASLE) {
495 DRM_DEBUG_DRIVER("ASLE supported\n");
496 opregion->asle = base + OPREGION_ASLE_OFFSET;
497
498 iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
499 }
500
501 return 0;
502
503err_out:
504 iounmap(base);
505 return err;
506}
507