drivers/gpu/drm/i915/i915_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 #include <linux/acpi.h>
  29 #include <acpi/video.h>
  30
  31 #include "drmP.h"
  32 #include "i915_drm.h"
  33 #include "i915_drv.h"
  34
  35 #define PCI_ASLE 0xe4
  36 #define PCI_LBPC 0xf4
  37 #define PCI_ASLS 0xfc
  38
  39 #define OPREGION_SZ            (8*1024)
  40 #define OPREGION_HEADER_OFFSET 0
  41 #define OPREGION_ACPI_OFFSET   0x100
  42 #define OPREGION_SWSCI_OFFSET  0x200
  43 #define OPREGION_ASLE_OFFSET   0x300
  44 #define OPREGION_VBT_OFFSET    0x1000
  45
  46 #define OPREGION_SIGNATURE "IntelGraphicsMem"
  47 #define MBOX_ACPI      (1<<0)
  48 #define MBOX_SWSCI     (1<<1)
  49 #define MBOX_ASLE      (1<<2)
  50
  51 struct opregion_header {
  52        u8 signature[16];
  53        u32 size;
  54        u32 opregion_ver;
  55        u8 bios_ver[32];
  56        u8 vbios_ver[16];
  57        u8 driver_ver[16];
  58        u32 mboxes;
  59        u8 reserved[164];
  60 } __attribute__((packed));
  61
  62 /* OpRegion mailbox #1: public ACPI methods */
  63 struct opregion_acpi {
  64        u32 drdy;       /* driver readiness */
  65        u32 csts;       /* notification status */
  66        u32 cevt;       /* current event */
  67        u8 rsvd1[20];
  68        u32 didl[8];    /* supported display devices ID list */
  69        u32 cpdl[8];    /* currently presented display list */
  70        u32 cadl[8];    /* currently active display list */
  71        u32 nadl[8];    /* next active devices list */
  72        u32 aslp;       /* ASL sleep time-out */
  73        u32 tidx;       /* toggle table index */
  74        u32 chpd;       /* current hotplug enable indicator */
  75        u32 clid;       /* current lid state*/
  76        u32 cdck;       /* current docking state */
  77        u32 sxsw;       /* Sx state resume */
  78        u32 evts;       /* ASL supported events */
  79        u32 cnot;       /* current OS notification */
  80        u32 nrdy;       /* driver status */
  81        u8 rsvd2[60];
  82 } __attribute__((packed));
  83
  84 /* OpRegion mailbox #2: SWSCI */
  85 struct opregion_swsci {
  86        u32 scic;       /* SWSCI command|status|data */
  87        u32 parm;       /* command parameters */
  88        u32 dslp;       /* driver sleep time-out */
  89        u8 rsvd[244];
  90 } __attribute__((packed));
  91
  92 /* OpRegion mailbox #3: ASLE */
  93 struct opregion_asle {
  94        u32 ardy;       /* driver readiness */
  95        u32 aslc;       /* ASLE interrupt command */
  96        u32 tche;       /* technology enabled indicator */
  97        u32 alsi;       /* current ALS illuminance reading */
  98        u32 bclp;       /* backlight brightness to set */
  99        u32 pfit;       /* panel fitting state */
 100        u32 cblv;       /* current brightness level */
 101        u16 bclm[20];   /* backlight level duty cycle mapping table */
 102        u32 cpfm;       /* current panel fitting mode */
 103        u32 epfm;       /* enabled panel fitting modes */
 104        u8 plut[74];    /* panel LUT and identifier */
 105        u32 pfmb;       /* PWM freq and min brightness */
 106        u8 rsvd[102];
 107 } __attribute__((packed));
 108
 109 /* ASLE irq request bits */
 110 #define ASLE_SET_ALS_ILLUM     (1 << 0)
 111 #define ASLE_SET_BACKLIGHT     (1 << 1)
 112 #define ASLE_SET_PFIT          (1 << 2)
 113 #define ASLE_SET_PWM_FREQ      (1 << 3)
 114 #define ASLE_REQ_MSK           0xf
 115
 116 /* response bits of ASLE irq request */
 117 #define ASLE_ALS_ILLUM_FAIL    (2<<10)
 118 #define ASLE_BACKLIGHT_FAIL    (2<<12)
 119 #define ASLE_PFIT_FAIL         (2<<14)
 120 #define ASLE_PWM_FREQ_FAIL     (2<<16)
 121
 122 /* ASLE backlight brightness to set */
 123 #define ASLE_BCLP_VALID                (1<<31)
 124 #define ASLE_BCLP_MSK          (~(1<<31))
 125
 126 /* ASLE panel fitting request */
 127 #define ASLE_PFIT_VALID         (1<<31)
 128 #define ASLE_PFIT_CENTER (1<<0)
 129 #define ASLE_PFIT_STRETCH_TEXT (1<<1)
 130 #define ASLE_PFIT_STRETCH_GFX (1<<2)
 131
 132 /* PWM frequency and minimum brightness */
 133 #define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
 134 #define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
 135 #define ASLE_PFMB_PWM_MASK (0x7ffffe00)
 136 #define ASLE_PFMB_PWM_VALID (1<<31)
 137
 138 #define ASLE_CBLV_VALID         (1<<31)
 139
 140 #define ACPI_OTHER_OUTPUT (0<<8)
 141 #define ACPI_VGA_OUTPUT (1<<8)
 142 #define ACPI_TV_OUTPUT (2<<8)
 143 #define ACPI_DIGITAL_OUTPUT (3<<8)
 144 #define ACPI_LVDS_OUTPUT (4<<8)
 145
 146 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
 147 {
 148         struct drm_i915_private *dev_priv = dev->dev_private;
 149         struct opregion_asle *asle = dev_priv->opregion.asle;
 150         u32 blc_pwm_ctl, blc_pwm_ctl2;
 151
 152         if (!(bclp & ASLE_BCLP_VALID))
 153                 return ASLE_BACKLIGHT_FAIL;
 154
 155         bclp &= ASLE_BCLP_MSK;
 156         if (bclp < 0 || bclp > 255)
 157                 return ASLE_BACKLIGHT_FAIL;
 158
 159         blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
 160         blc_pwm_ctl &= ~BACKLIGHT_DUTY_CYCLE_MASK;
 161         blc_pwm_ctl2 = I915_READ(BLC_PWM_CTL2);
 162
 163         if (blc_pwm_ctl2 & BLM_COMBINATION_MODE)
 164                 pci_write_config_dword(dev->pdev, PCI_LBPC, bclp);
 165         else
 166                 I915_WRITE(BLC_PWM_CTL, blc_pwm_ctl | ((bclp * 0x101)-1));
 167
 168         asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;
 169
 170         return 0;
 171 }
 172
 173 static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
 174 {
 175         /* alsi is the current ALS reading in lux. 0 indicates below sensor
 176            range, 0xffff indicates above sensor range. 1-0xfffe are valid */
 177         return 0;
 178 }
 179
 180 static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
 181 {
 182         struct drm_i915_private *dev_priv = dev->dev_private;
 183         if (pfmb & ASLE_PFMB_PWM_VALID) {
 184                 u32 blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
 185                 u32 pwm = pfmb & ASLE_PFMB_PWM_MASK;
 186                 blc_pwm_ctl &= BACKLIGHT_DUTY_CYCLE_MASK;
 187                 pwm = pwm >> 9;
 188                 /* FIXME - what do we do with the PWM? */
 189         }
 190         return 0;
 191 }
 192
 193 static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
 194 {
 195         /* Panel fitting is currently controlled by the X code, so this is a
 196            noop until modesetting support works fully */
 197         if (!(pfit & ASLE_PFIT_VALID))
 198                 return ASLE_PFIT_FAIL;
 199         return 0;
 200 }
 201
 202 void opregion_asle_intr(struct drm_device *dev)
 203 {
 204         struct drm_i915_private *dev_priv = dev->dev_private;
 205         struct opregion_asle *asle = dev_priv->opregion.asle;
 206         u32 asle_stat = 0;
 207         u32 asle_req;
 208
 209         if (!asle)
 210                 return;
 211
 212         asle_req = asle->aslc & ASLE_REQ_MSK;
 213
 214         if (!asle_req) {
 215                 DRM_DEBUG("non asle set request??\n");
 216                 return;
 217         }
 218
 219         if (asle_req & ASLE_SET_ALS_ILLUM)
 220                 asle_stat |= asle_set_als_illum(dev, asle->alsi);
 221
 222         if (asle_req & ASLE_SET_BACKLIGHT)
 223                 asle_stat |= asle_set_backlight(dev, asle->bclp);
 224
 225         if (asle_req & ASLE_SET_PFIT)
 226                 asle_stat |= asle_set_pfit(dev, asle->pfit);
 227
 228         if (asle_req & ASLE_SET_PWM_FREQ)
 229                 asle_stat |= asle_set_pwm_freq(dev, asle->pfmb);
 230
 231         asle->aslc = asle_stat;
 232 }
 233
 234 #define ASLE_ALS_EN    (1<<0)
 235 #define ASLE_BLC_EN    (1<<1)
 236 #define ASLE_PFIT_EN   (1<<2)
 237 #define ASLE_PFMB_EN   (1<<3)
 238
 239 void opregion_enable_asle(struct drm_device *dev)
 240 {
 241         struct drm_i915_private *dev_priv = dev->dev_private;
 242         struct opregion_asle *asle = dev_priv->opregion.asle;
 243
 244         if (asle) {
 245                 if (IS_MOBILE(dev)) {
 246                         unsigned long irqflags;
 247
 248                         spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
 249                         i915_enable_pipestat(dev_priv, 1,
 250                                              I915_LEGACY_BLC_EVENT_ENABLE);
 251                         spin_unlock_irqrestore(&dev_priv->user_irq_lock,
 252                                                irqflags);
 253                 }
 254
 255                 asle->tche = ASLE_ALS_EN | ASLE_BLC_EN | ASLE_PFIT_EN |
 256                         ASLE_PFMB_EN;
 257                 asle->ardy = 1;
 258         }
 259 }
 260
 261 #define ACPI_EV_DISPLAY_SWITCH (1<<0)
 262 #define ACPI_EV_LID            (1<<1)
 263 #define ACPI_EV_DOCK           (1<<2)
 264
 265 static struct intel_opregion *system_opregion;
 266
 267 static int intel_opregion_video_event(struct notifier_block *nb,
 268                                       unsigned long val, void *data)
 269 {
 270         /* The only video events relevant to opregion are 0x80. These indicate
 271            either a docking event, lid switch or display switch request. In
 272            Linux, these are handled by the dock, button and video drivers.
 273            We might want to fix the video driver to be opregion-aware in
 274            future, but right now we just indicate to the firmware that the
 275            request has been handled */
 276
 277         struct opregion_acpi *acpi;
 278
 279         if (!system_opregion)
 280                 return NOTIFY_DONE;
 281
 282         acpi = system_opregion->acpi;
 283         acpi->csts = 0;
 284
 285         return NOTIFY_OK;
 286 }
 287
 288 static struct notifier_block intel_opregion_notifier = {
 289         .notifier_call = intel_opregion_video_event,
 290 };
 291
 292 /*
 293  * Initialise the DIDL field in opregion. This passes a list of devices to
 294  * the firmware. Values are defined by section B.4.2 of the ACPI specification
 295  * (version 3)
 296  */
 297
 298 static void intel_didl_outputs(struct drm_device *dev)
 299 {
 300         struct drm_i915_private *dev_priv = dev->dev_private;
 301         struct intel_opregion *opregion = &dev_priv->opregion;
 302         struct drm_connector *connector;
 303         int i = 0;
 304
 305         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 306                 int output_type = ACPI_OTHER_OUTPUT;
 307                 if (i >= 8) {
 308                         dev_printk (KERN_ERR, &dev->pdev->dev,
 309                                     "More than 8 outputs detected\n");
 310                         return;
 311                 }
 312                 switch (connector->connector_type) {
 313                 case DRM_MODE_CONNECTOR_VGA:
 314                 case DRM_MODE_CONNECTOR_DVIA:
 315                         output_type = ACPI_VGA_OUTPUT;
 316                         break;
 317                 case DRM_MODE_CONNECTOR_Composite:
 318                 case DRM_MODE_CONNECTOR_SVIDEO:
 319                 case DRM_MODE_CONNECTOR_Component:
 320                 case DRM_MODE_CONNECTOR_9PinDIN:
 321                         output_type = ACPI_TV_OUTPUT;
 322                         break;
 323                 case DRM_MODE_CONNECTOR_DVII:
 324                 case DRM_MODE_CONNECTOR_DVID:
 325                 case DRM_MODE_CONNECTOR_DisplayPort:
 326                 case DRM_MODE_CONNECTOR_HDMIA:
 327                 case DRM_MODE_CONNECTOR_HDMIB:
 328                         output_type = ACPI_DIGITAL_OUTPUT;
 329                         break;
 330                 case DRM_MODE_CONNECTOR_LVDS:
 331                         output_type = ACPI_LVDS_OUTPUT;
 332                         break;
 333                 }
 334                 opregion->acpi->didl[i] |= (1<<31) | output_type | i;
 335                 i++;
 336         }
 337
 338         /* If fewer than 8 outputs, the list must be null terminated */
 339         if (i < 8)
 340                 opregion->acpi->didl[i] = 0;
 341 }
 342
 343 int intel_opregion_init(struct drm_device *dev, int resume)
 344 {
 345         struct drm_i915_private *dev_priv = dev->dev_private;
 346         struct intel_opregion *opregion = &dev_priv->opregion;
 347         void *base;
 348         u32 asls, mboxes;
 349         int err = 0;
 350
 351         pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
 352         DRM_DEBUG("graphic opregion physical addr: 0x%x\n", asls);
 353         if (asls == 0) {
 354                 DRM_DEBUG("ACPI OpRegion not supported!\n");
 355                 return -ENOTSUPP;
 356         }
 357
 358         base = ioremap(asls, OPREGION_SZ);
 359         if (!base)
 360                 return -ENOMEM;
 361
 362         opregion->header = base;
 363         if (memcmp(opregion->header->signature, OPREGION_SIGNATURE, 16)) {
 364                 DRM_DEBUG("opregion signature mismatch\n");
 365                 err = -EINVAL;
 366                 goto err_out;
 367         }
 368
 369         mboxes = opregion->header->mboxes;
 370         if (mboxes & MBOX_ACPI) {
 371                 DRM_DEBUG("Public ACPI methods supported\n");
 372                 opregion->acpi = base + OPREGION_ACPI_OFFSET;
 373                 if (drm_core_check_feature(dev, DRIVER_MODESET))
 374                         intel_didl_outputs(dev);
 375         } else {
 376                 DRM_DEBUG("Public ACPI methods not supported\n");
 377                 err = -ENOTSUPP;
 378                 goto err_out;
 379         }
 380         opregion->enabled = 1;
 381
 382         if (mboxes & MBOX_SWSCI) {
 383                 DRM_DEBUG("SWSCI supported\n");
 384                 opregion->swsci = base + OPREGION_SWSCI_OFFSET;
 385         }
 386         if (mboxes & MBOX_ASLE) {
 387                 DRM_DEBUG("ASLE supported\n");
 388                 opregion->asle = base + OPREGION_ASLE_OFFSET;
 389                 opregion_enable_asle(dev);
 390         }
 391
 392         if (!resume)
 393                 acpi_video_register();
 394
 395
 396         /* Notify BIOS we are ready to handle ACPI video ext notifs.
 397          * Right now, all the events are handled by the ACPI video module.
 398          * We don't actually need to do anything with them. */
 399         opregion->acpi->csts = 0;
 400         opregion->acpi->drdy = 1;
 401
 402         system_opregion = opregion;
 403         register_acpi_notifier(&intel_opregion_notifier);
 404
 405         return 0;
 406
 407 err_out:
 408         iounmap(opregion->header);
 409         opregion->header = NULL;
 410         return err;
 411 }
 412
 413 void intel_opregion_free(struct drm_device *dev, int suspend)
 414 {
 415         struct drm_i915_private *dev_priv = dev->dev_private;
 416         struct intel_opregion *opregion = &dev_priv->opregion;
 417
 418         if (!opregion->enabled)
 419                 return;
 420
 421         if (!suspend)
 422                 acpi_video_unregister();
 423
 424         opregion->acpi->drdy = 0;
 425
 426         system_opregion = NULL;
 427         unregister_acpi_notifier(&intel_opregion_notifier);
 428
 429         /* just clear all opregion memory pointers now */
 430         iounmap(opregion->header);
 431         opregion->header = NULL;
 432         opregion->acpi = NULL;
 433         opregion->swsci = NULL;
 434         opregion->asle = NULL;
 435
 436         opregion->enabled = 0;
 437 }