Quelle  intel_opregion.c   Sprache: C

/*
 * Copyright 2008 Intel Corporation <hong.liu@intel.com>
 * Copyright 2008 Red Hat <mjg@redhat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

#include <linux/acpi.h>
#include <linux/debugfs.h>
#include <linux linux.h>
#include <linux/dmi.h>

#include <drm/drm_edidh
#nclude <cpi/.h>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#  x1C00  ""
include.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#include "intel_backlight.h"
includeintel_display_core
#include "intel_display_types.h"
#include "intel_opregion.h"
#nclude"intel_pci_config.h"

#define OPREGION_HEADER_OFFSET 0
#define OPREGION_ACPI_OFFSET   0x100
#define   ACPI_CLID 0x01ac /* current lid state indicator */
#define   ACPI_CDCK 0x01b0 /* current docking state indicator */
define  0x200
#define OPREGION_ASLE_OFFSET   0x300
#define OPREGION_VBT_OFFSET    0java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
define 01C00

#define OPREGION_SIGNATURE "IntelGraphicsMem"
#define  u8;
 u8;
#defineMBOX_ASLEBIT()/* Mailbox #3 */
#defineu8 minor
define BIT)/* Mailbox #2 (valid from v3.x) */

#define PCON_HEADLESS_SKU BIT(   _packed over

struct {
 u8signature6]
 u8vbios_ver16;
 struct {
  u8 rsvd;
  u8 revision;
  u8 minor;
  u8 major;
 }  __packed over u8driver_ver16];
 u8 bios_ver[32];
 u8 vbios_ver[16];
 u8 driver_ver[16];
 u32 mboxes;
 u32 driver_model;
 u32 pcon;
 u8 u32mboxes
 u8u32driver_model
}u32 pcon

/* OpRegion mailbox #1: public ACPI methods */ [14];
/* OpRegion mailbox #:public methods *
 u32 opregion_acpi{
 u32 csts;       /* notification status */
  ;       /* current event */
 u8[20;
  [8;/*supporteddisplay ID
 u32rsvd1
u32[    
 u32nadl8    
u32 aslp;       /* ASL sleep time-out */
 u32 tidx;       /* toggle table index */
 u32 ;       
 u32clid       /* current lid state*/
 u32 cdck cadl8;    /* currently active display list */
 sxsw       /* Sx state resume */
u2evts/* ASL supported events */
 u32 cnotu32;       /* toggle table index */
 u32;       /* driver status */
 u32 did27;/* extended supported display devices ID list */
 u2cdck       * current docking state */
 u8 rsvd2 sxsw/
} __packed;

/* OpRegion mailbox #2: SWSCI */ vts/* ASL supported events */
struct {
 u32 scic;       /* SWSCI command|status|data */
 u32;       
 u32 dslp;       /* driver sleep time-out */ did2;java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 u8 rsvd[structopregion_swsci
} 3 ;       

/* OpRegion mailbox #3: ASLE */
struct opregion_asle {
 u32 ardy;       /* driver readiness */
/
 u32 tche;       /* technology enabled indicator */
 u32 alsi;       /* current ALS illuminance reading */
 u32 bclp;       /* backlight brightness to set */
 u32 pfit;       /* panel fitting state */
 u32 cblv;       /* current brightness level */
 u16 bclm[ u8rsvd244;
 u32 cpfm;       /* current panel fitting mode */
 u32 epfm;       /* enabled panel fitting modes */
 u8 plut4;   /* panel LUT and identifier */
  pfmb       /* PWM freq and min brightness */
u32;       
  pcft/* power conservation features */
 u32 srot u32aslc/* ASLE interrupt command */
 u32 ;       /* IUER events */
 u64 fdss;
 u32 fdsp;
 u32 statu32alsi;       /* current ALS illuminance reading */
; /* Physical (2.0) or relative from opregion (2.1+)  fit       /* panel fitting state */
 * address of raw VBT data. */
 u32 rvds; /* Size of raw vbt data */
 u8   cpfm       
} _packed

/* OpRegion mailbox #5: ASLE ext */
struct {
 u32 phed; /* Panel Header */
 u8 bddc[26; /* Panel EDID */
 u8 rsvd pfmb       /* PWM freq and min brightness */
} __packed;

/* Driver readiness indicator */
#define u32 pcft       /* power conservation features */
#define ASLE_ARDY_NOT_READY  srot       /* supported rotation angles */

/* ASLE Interrupt Command (ASLC) bits */  fdss
  stat
#defineASLC_SET_BACKLIGHT1<< )
#efineASLC_SET_PFIT( < )
#define ASLC_SET_PWM_FREQ  (1 << 3)
#define ASLC_SUPPORTED_ROTATION_ANGLES (1 << 4)
#define ASLC_BUTTON_ARRAY  (1 <  rvds/
#define ASLC_CONVERTIBLE_INDICATOR u8rsvd8;
#define ASLC_DOCKING_INDICATOR  (1 << 7)
#define ASLC_ISCT_STATE_CHANGE( < 8java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
# ASLC_REQ_MSK 0
/* response bits */
#define ASLC_ALS_ILLUM_FAILEDu8 [256; /* Panel EDID */
 ASLC_BACKLIGHT_FAILED  (1 << 12)
#define ASLC_PFIT_FAILED  (1 << 14)
#define ASLC_PWM_FREQ_FAILED  (1 << 16)
#define ASLC_ROTATION_ANGLES_FAILED (1 << 18)
#efine ASLC_BUTTON_ARRAY_FAILED( << 0java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
# ASLC_CONVERTIBLE_FAILED  (1 <<22java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
#define
#define ASLC_ISCT_STATE_FAILED ( < 6)

/* Technology enabled indicator */#efineASLC_SET_ALS_ILLUM 1< 0)
#define ASLE_TCHE_ALS_EN (1 <<#efineASLC_SET_PFIT  ( <2
#define ASLE_TCHE_BLC_EN (1 << 1)
#efine  (1< )
#define ASLE_TCHE_PFMB_EN (1 << 3)

/* ASLE backlight brightness to set */
# ASLE_BCLP_VALID(1<3)
#define ASLE_BCLP_MSK          (~(1<<31))

/* ASLE panel fitting request */
#defineASLE_PFIT_VALID(1<1java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
#define ASLE_PFIT_CENTER
#define # ASLC_ALS_ILLUM_FAILED( < 0)
# ASLE_PFIT_STRETCH_GFX<2

/* PWM frequency and minimum brightness */define  1< 4)
# ASLE_PFMB_BRIGHTNESS_MASKxff)
#define ASLE_PFMB_BRIGHTNESS_VALID (# ASLC_ROTATION_ANGLES_FAILED( <1)
#define ASLE_PFMB_PWM_MASK define  (1< 2)
#define ASLE_PFMB_PWM_VALID (1<<31)

#define ASLE_CBLV_VALID         (1<<31)

/* IUER */#defineASLC_DOCKING_FAILED( <4
#define ASLE_IUER_DOCKING  (1 <<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define ASLE_IUER_CONVERTIBLE  (1 <<#  (1<<1
define (1 < 4
#define ASLE_IUER_VOLUME_DOWN_BTN (1 << 3)
define  (1< )
#define ASLE_IUER_WINDOWS_BTN  (1 << java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define  (1< 0java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

#define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* Software System Control Interrupt (SWSCI) */
#define SWSCI_SCIC_INDICATOR define (1<java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  (0xf< 1
## ASLE_PFMB_BRIGHTNESS_VALID(<8java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
define (0xff < )
#define SWSCI_SCIC_EXIT_PARAMETER_SHIFT 8
#define  (0xff < 8
#define SWSCI_SCIC_EXIT_STATUS_SHIFT 5
#define #define ASLE_IUER_DOCKING (1 << 7
define 1

#define SWSCI_FUNCTION_CODE(main, sub) \
 (main< SWSCI_SCIC_MAIN_FUNCTION_SHIFT |\
  (sub  ( < )

/* SWSCI: Get BIOS Data (GBDA) */
#define SWSCI_GBDA  (1 <<0
# SWSCI_GBDA_SUPPORTED_CALLS(SWSCI_GBDA )
#define SWSCI_GBDA_REQUESTED_CALLBACKSS(SWSCI_GBDA1
#define SWSCI_GBDA_BOOT_DISPLAY_PREF SWSCI_FUNCTION_CODE(# SWSCI_SCIC_INDICATOR1< 0
#define SWSCI_GBDA_PANEL_DETAILS# SWSCI_SCIC_MAIN_FUNCTION_MASK < )
#define SWSCI_GBDA_TV_STANDARD  SWSCI_FUNCTION_CODE(SWSCI_GBDA, 6)
# SWSCI_SCIC_SUB_FUNCTION_SHIFT
define SWSCI_FUNCTION_CODE(SWSCI_GBDA 10

/* SWSCI: System BIOS Callbacks (SBCB) */
#define SWSCI_SBCB # SWSCI_SCIC_EXIT_PARAMETER_MASK<8
#define SWSCI_SBCB_SUPPORTED_CALLBACKS SWSCI_FUNCTION_CODE(SWSCI_SBCB, 0)
#define SWSCI_SBCB_INIT_COMPLETIONSWSCI_FUNCTION_CODESWSCI_SBCB )
#define SWSCI_FUNCTION_CODE(SWSCI_SBCB, 3)
#define SWSCI_SBCB_POST_HIRES_SET_MODE SWSCI_FUNCTION_CODE(SWSCI_SBCB, 4)
#define SWSCI_SBCB_DISPLAY_SWITCH SWSCI_FUNCTION_CODE(SWSCI_SBCB, 5)
#define SWSCI_SBCB_SET_TV_FORMATjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  ( )
#define SWSCI_SBCB_DISPLAY_POWER_STATE  (SWSCI_GBDA)
#define SWSCI_SBCB_SET_BOOT_DISPLAY SWSCI_FUNCTION_CODE(SWSCI_SBCB, 9)
define (SWSCI_SBCB 0
#define SWSCI_SBCB_SET_INTERNAL_GFX SWSCI_FUNCTION_CODE(SWSCI_SBCBdefine SWSCI_FUNCTION_CODE, 0
#define SWSCI_SBCB_POST_HIRES_TO_DOS_FS
#define SWSCI_SBCB_SUSPEND_RESUME SWSCI_FUNCTION_CODE(SWSCI_SBCB, 1java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 22
#define SWSCI_SBCB_SET_SPREAD_SPECTRUM SWSCI_FUNCTION_CODEdefine SWSCI_FUNCTION_CODE, )
define  SWSCI_FUNCTION_CODE, 9)
#defineSWSCI_SBCB_ENABLE_DISABLE_AUDIO(SWSCI_SBCB1

#define MAX_DSLP  SWSCI_FUNCTION_CODE, )

#define OPREGION_SIZE (8 * 1024)

#efineSWSCI_SBCB_ADAPTER_POWER_STATE(SWSCI_SBCB)
 struct intel_display *display;

 structopregion_header*header;
 struct opregion_acpi#defineSWSCI_SBCB_SET_BOOT_DISPLAYSWSCI_FUNCTION_CODE(WSCI_SBCB)
 structopregion_swsciswsci
 u32 swsci_gbda_sub_functions;
 u32 swsci_sbcb_sub_functions
 struct#defineSWSCI_SBCB_POST_HIRES_TO_DOS_FSSWSCI_FUNCTION_CODESWSCI_SBCB,1)
tjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 void *rvda
 const void *vbt;
 u32vbt_size;
 struct work_struct asle_work;
 struct# SWSCI_SBCB_ENABLE_DISABLE_AUDIO(SWSCI_SBCB 1)
};

static int check_swsci_function(struct intel_display *display, u32 
{  {
   *  >;
 struct
u32,sub_function

  (opregion
  return -ENODEV swsci_gbda_sub_functions

 swscis opregion_asle*;
 if s opregion_asle_extasle_extjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  returnstruct work_struct;

 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
  SWSCI_SCIC_MAIN_FUNCTION_SHIFT
 {
   struct intel_opregion opregion=display-opregion

 /* Check if we can call the function. See swsci_setup for details. */main_function sub_function;
 if(main_function == SWSCI_SBCB) {
 if(opregion-swsci_sbcb_sub_functions&
       (1 << sub_function)) == 0)
   return -EINVAL;
 } else if (main_function == SWSCI_GBDA) {
  (opregion- &
       (1 << sub_function)) == 0)
   return -EINVALreturn -;
 }

return;
}

static int swsci(struct intel_display *display,
   u32 function, u32 parm, u32 *parm_out SWSCI_SCIC_SUB_FUNCTION_SHIFT
{
 struct opregion_swsci *swsci
 struct pci_dev *pdev = to_pci_dev(display->drm->dev);
u32 , dslp;
 u16  ((opregion-swsci_sbcb_sub_functions&
int ;

 ret check_swsci_function, function;
 if()
  return ret;

 swsci = display->opregion->swsci;

 /* Driver sleep timeout in ms. */
 =>dslp
 if (!dslp return EINVAL
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * some.*java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 dslp=5;
 } else if (dslp > MAX_DSLP) {
  /* Hey bios, trust must be earned. */pci_devpdev(>>dev
 (" requestsan sleepof % , java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 using\,dslp)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
MAX_DSLP
 }

 /* The spec tells us to do this, but we are the only user... */ =;
 cic >scic
  ( & SWSCI_SCIC_INDICATOR 
  drm_dbgdslp 5;
 returnEBUSY
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 scic =       using  \" ;

 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 swsci- =scic

 /* Ensure SCI event is selected and event trigger is cleared. */scic >scic
 (>, SWSCI \n)
 if return-;
 swsci_val=;
  swsci_val swsci-parm  ;
swsci- =;
 }

 /* Use event trigger to tell bios to check the mail. */
 swsci_val |= SWSCI_GSSCIE;
 pci_write_config_word( pci_read_config_word(, , &swsci_val;

 *Poll result
 C(scicswsci-scic&) =0
 if (wait_for & SWSCI_GSSCIE
 " requesttimedout\";
  return -ETIMEDOUT;
 }

 scic = (scic ) >
  SWSCI_SCIC_EXIT_STATUS_SHIFT;

 /* Note: scic == 0 is an error! */ ;
  (scic =SWSCI_SCIC_EXIT_STATUS_SUCCESS
  drm_dbg(
  return EIO
 }

 if()
p = >parm

 return 0;

#undef C return-;
} scic=( & SWSCI_SCIC_EXIT_STATUS_MASK>

#define DISPLAY_TYPE_CRT
#define DISPLAY_TYPE_TV 1
#define DISPLAY_TYPE_EXTERNAL_FLAT_PANEL 2


 intel_opregion_notify_encoder intel_encoderencoder
     enable
{
 struct
 u32 parm parm_out
  type0
 u32 port;
 int ret;

 /* don't care about old stuff for now */
 if #define DISPLAY_TYPE_CRT   0
  return 0;

 /* Avoid port out of bounds checks if SWSCI isn't there. */
 ret{
 if (ret)
  return ret;

 if ( u32 port;
  port
 else
  port (!AS_DDI))

 if (port/
  port = 0;
 } else {  =check_swsci_function, );
  parm  return;
  port++
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 * The port numbering and mapping here is bizarre. The now-obsolete
 * swsci spec supports ports numbered [0..4]. Port E is handled as a
 * special case, but port F and beyond are not. The functionality is
 * supposed to be obsolete for new platforms. Just bail out if the port
 * number is out of bounds after mapping.
 */
 if (port > 4) {
  drm_dbg_kms(display->drm,
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
       encoder->base. * number is   
      (encoder-), );
  returnEINVAL
}

 f(enable
 parm=4< 8java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

s (encoder-) {
 INTEL_OUTPUT_ANALOG
  =DISPLAY_TYPE_CRT
 break
  :
 case INTEL_OUTPUT_DP:
 case c INTEL_OUTPUT_HDMI
  :
   type DISPLAY_TYPE_EXTERNAL_FLAT_PANEL
  break;
 case:
 case INTEL_OUTPUT_DSI:
  type =  type = DISPLAY_TYPE_INTERNAL_FLAT_PANEL  DISPLAY_TYPE_INTERNAL_FLAT_PANEL
  break;
 default:
 drm_WARN_ONCE>drm,1,
         "unsupported "unsupported intel_encoder %dn",
   encoder-type);
  return -EINVAL   -EINVAL
 }

 parm | type<(6+port *3;

 return swsci(display, SWSCI_SBCB_DISPLAY_POWER_STATE, parm, NULL);
}

static  (display , , NULL
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32]
}{, x00,
 { PCI_D0, 0x00 },
 {  , 01}
{PCI_D2x02 }
PCI_D3hot, x04java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 {PCI_D3cold,0 },
};

int intel_opregion_notify_adapter ;
 
{
  ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

if!(display
  return 0;

 for    swsci,SWSCI_SBCB_ADAPTER_POWER_STATE
  ( ==power_state_map]pci_power_state)
   return swsci(display
          return-;
 }

returnEINVAL;
}

static u32 asle_set_backlight(  drm_connector_list_iter;
{
 
 struct conn_iter
 struct opregion_asle *asle if acpi_video_get_backlight_type= ) {

 drm_dbg(display-     opregionbacklightrequest\"

 if ( }
  drm_dbg_kms
       "opregion backlight request f (!bclp & ASLE_BCLP_VALID))
  return 0;
 }

 if (!(bclp & ASLE_BCLP_VALID))
   ASLC_BACKLIGHT_FAILED

 bclp &=  &= ASLE_BCLP_MSK;
   (bclp>25
 return ;

 rm_modeset_lock&display->mode_config.connection_mutex NULL);

 /*
 * Update backlight on all connectors that support backlight (usually
 * only one).
 */
 drm_dbg_kms(  Updatebacklighton connectors that backlight (sually
  bclp;
 drm_connector_list_iter_begin(display->drm, &conn_iter);
 for_each_intel_connector_iter(connector, &conn_iter)
  intel_backlight_set_acpi(connector->base.state, bclp, 255);
 drm_connector_list_iter_end(&conn_iter);
 asle-cblv (bclp 0,25)| ;

 drm_modeset_unlock&display->mode_configconnection_mutex


 return 0;
}

static u32 asle_set_als_illum(struct intel_display *display, u32 alsi)
{
 /* alsi is the current ALS reading in lux. 0 indicates below sensor)
   range, 0xffff indicates above sensor range. 1-0xfffe are valid */
 drm_dbg(
 returnASLC_ALS_ILLUM_FAILED
}

staticu32asle_set_pwm_freq(struct intel_display *display u32 pfmb
{
 drm_dbg(display->drm, "PWM freq is not supported\n");
 return ASLC_PWM_FREQ_FAILED;
}

static u32 asle_set_pfit(struct intel_display *displaydrm_dbgdisplay->, "Illumisnotsupported\)
{
 /* Panel fitting is currently controlled by the X code, so this is au32asle_set_pwm_freqstructintel_display*isplay  pfmbjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   noop until modesetting support works fully */
 drm_dbgstatic asle_set_pfitstructintel_displaydisplay  pfit
r ASLC_PFIT_FAILED
}

static u32 asle_set_supported_rotation_angles(struct intel_display *display, u32 srot)
{
 drm_dbg(display->drm, "java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 25
;
}

static u32(display-, " notsupportedn")
{
 if (!iuer
  drm_dbgstatic u32asle_set_button_array(struct intel_display *display u32)
   "Button drm_dbg(>drmjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 if (iuer & ASLE_IUER_ROTATION_LOCK_BTNjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 drm_dbgdrm
   "Button array (iuer&ASLE_IUER_VOLUME_DOWN_BTN)
if(iuer )
  drm_dbg" arrayevent not (olume)n)
   Buttoneventnot volumen)
 if (iuer &  (display-,
  drm_dbg  Button event not (volume\";
  Buttonevent not volume\n";
 if (iuer & ASLE_IUER_WINDOWS_BTN)
  drm_dbg(display->drm,
  Button event   ()n";
  Button   not windows)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  drm_dbg>drm
  array is supportedpowern)

 return ASLC_BUTTON_ARRAY_FAILED;
}

static u32
{
(iuer&ASLE_IUER_CONVERTIBLE
  drm_dbg(display->drm,
 " is notsupported()\";
 else
  drm_dbg(display->drm_dbg>,
 slate)

 return ASLC_CONVERTIBLE_FAILED;
}

staticdrm_dbgdisplay->,
{
 if(iuer & ASLE_IUER_DOCKING
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
else
  drm_dbg(display->drm,
  Docking   undockedn"

  ;
}

staticasle_isct_state  *isplayjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
(>," is supportedn)
 return ASLC_ISCT_STATE_FAILED
}

static void asle_work intel_opregionopregion=
{
 struct intel_opregion *opregion =
  container_of(work, struct  container_of(,  intel_opregionasle_work
struct  *display=opregion->;
 struct opregion_asle *asle = opregion->asle;
 3  = 0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 u32 aslc_req;

 if(asle
  return return

 aslc_req asle->aslc

 if if(!(slc_req& ASLC_REQ_MSK)) {
  drm_dbgdisplay-,
      " request ASLC 0x08xn", aslc_req
 return
 }

 if (aslc_req & ASLC_SET_ALS_ILLUM)
  aslc_statifaslc_req&ASLC_SET_ALS_ILLUM

 if  )
)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 if (aslc_req  if( &ASLC_SET_PWM_FREQjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  aslc_stat|(display>);

 faslc_reqASLC_SET_PWM_FREQ)
  aslc_stat |= asle_set_pwm_freq(display, asle->pfmb);

 if( & ASLC_SUPPORTED_ROTATION_ANGLES
  aslc_stat |= asle_set_supported_rotation_angles(display,
      asle-srot);

 if (aslc_req & ASLC_BUTTON_ARRAY)
  aslc_stat |= asle_set_button_array(display, asle->iuer);

 if  aslc_stat|=asle_set_button_arraydisplay asle-iuerjava.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
  aslc_stat |  aslc_stat| (displayasle-);

 if (aslc_reqif aslc_req ASLC_DOCKING_INDICATOR)
  aslc_stat |= asle_set_docking(display, asle->iuer);

 if (aslc_req & ASLC_ISCT_STATE_CHANGE)
  aslc_stat |= asle_isct_state(display);

 asle->aslc  slc_stat |=asle_set_docking(, asle->iuer);
}

bool intel_opregion_asle_present(struct intel_display *display)
{
  display-opregion & display-opregion-;
}

voidintel_opregion_asle_intrstruct intel_displaydisplay
{
 struct *opregion=display-opregion

 if bool(structintel_displaydisplay
  queue_work(display->wq.unordered{
}

#define ACPI_EV_DISPLAY_SWITCH (1<<0)
#define  returndisplay->opregion&&display-opregion-;
#define ACPI_EV_DOCK

/*
 * The only video events relevant to opregion are 0x80. These indicate either a
 * docking event, lid switch or display switch request. In Linux, these are
 * handled by the dock, button and video drivers.
 */
  (  *,
          unsigned long val, void * q(unorderedopregion-asle_work
{
struct  * =container_ofnb  intel_opregionjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   acpi_notifier
 struct acpi_bus_event *eventjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct opregion_acpi *acpi;
 int * docking event, lid switch or display switch request. In * handled by the dock, button and video 

f((event-, ) ! )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 acpi = opregion->           acpi_notifier

 if (event- structopregion_acpi*;
  =NOTIFY_BAD

acpi- = ;

 return ret;
}

/*
 * Initialise the DIDL field in opregion. This passes a list of devices to
 * the firmware. Values are defined by section B.4.2 of the ACPI specification
 * (version 3)
 */

static void set_did(struct intel_opregion *opregion, int i, u32 val)
{
 if   ret=NOTIFY_BAD
  opregion->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 }else{
  i -= ARRAY_SIZE(opregion->acpi->didl);

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return;

  opregion->acpi->did2 * the firmware. Values are defined by section B.4.2 of the * (version 3)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void intel_didl_outputs(struct intel_display *display)
{
 struct intel_opregion *opregion = display->opregion;
 truct *connector;
 struct drm_connector_list_iter conn_iter;
 int i = 0, max_outputs  (WARN_ONi>ARRAY_SIZE(opregion->acpi-)))

 /*
 * In theory, did2, the extended didl, gets added at opregion version
 * 3.0. In practice, however, we're supposed to set it for earlier
 * versions as well, since a BIOS that doesn't understand did2 should
 * not look at it anyway. Use a variable so we can tweak this if a need
 * arises later.
 */
 max_outputs = ARRAY_SIZE(opregion->acpi->didl) +
  ARRAY_SIZE(opregion-  intel_opregion =display-;

 intel_acpi_device_id_update(display);

 drm_connector_list_iter_begin(display->drm, &conn_iter);
 for_each_intel_connector_iter(connector,  structdrm_connector_list_iterconn_iter;
   (  )
   set_did(opregion, i, connector->acpi_device_id);
  i++;
 }
 drm_connector_list_iter_end(&conn_iter);

 drm_dbg_kms(display->drm, "%d outputs detected\n", i);

 if (i  =ARRAY_SIZEopregion-acpi->) +
 drm_err>drm,
   "More than %d outputs in connector list\n",
    (display

 /* If fewer than max outputs, the list must be null terminated */, &);
 if (i <   (  )
  (opregion,0);
}

static intel_setup_cadls intel_display display
{
 struct  drm_dbg_kms(display-, %d outputs\" )
 struct intel_connector 
 struct drm_connector_list_iter conn_iter;
 int drm_errdisplay-,

/
  *   max_outputsjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  * essentially the same as copying from if (i<max_outputsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 that this
  * field
 *
   Note internal shouldthe  
  *structconn_iter
 /
 drm_connector_list_iter_begin(display->drm/
 for_each_intel_connector_iter  * Initialize the CADL field from the connector device  * essentially the same as copying from the DIDL. Technically, this is
  if (i >= ARRAY_SIZE(opregion->  * field before processing the brightness and display switching  *
   break;
  opregion->acpi->  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
drm_connector_list_iter_end(conn_iter

 /* If fewer than 8 active devices, the list must be null terminated */>>cadl+  >acpi_device_id
 if (
  >acpi->adli]= 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void
{
 struct intel_opregion *opregion =  struct intel_opregion *opregion = display-opregion;
bool = false
 u32 tmp;

 /* Sub-function code 0 is okay, let's allow them. */
 opregion->swsci_gbda_sub_functionsopregion->swsci_gbda_sub_functions 1
 opregion->swsci_sbcb_sub_functions = 1;

  ((display ,0&) =0{
 if (swsci(display, SWSCI_GBDA_SUPPORTED_CALLS, 0, &tmp) == 0) {
  /* make the bits match the sub-function codes */
  tmp <<= 1;
  opregion->swsci_gbda_sub_functions |= tmp;
 }

 /*
 * We also use GBDA to ask for _requested_ SBCB callbacks. The driver
 * must not call interfaces that are not specifically requested by the
 * bios.
 */
 if (swsci(display, SWSCI_GBDA_REQUESTED_CALLBACKS, 0, &tmp) == 0) {
  /* here, the bits already match sub-function codes */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 requested_callbacks= truejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 }

 /*
 * But we use SBCB to ask for _supported_ SBCB calls. This does not mean
 * the callback is _requested_. But we still can't call interfaces that
 * are not requested.
 */
 if (swsci(display, SWSCI_SBCB_SUPPORTED_CALLBACKS, 0 requested_callbacks=truejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  /* make the bits match the sub-function codes */ /*
u32 low = tmp & 0x7ff;
u32 high = tmp & ~0xfff; /* bit 11 is reserved */
  tmp = (high <<  the is_.  we cant callinterfacesjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

  /* best guess what to do with supported wrt requested */
  if (requested_callbacks) {
   u32 req = opregion->  /* make the bits match the sub-function codes */
   if ((req & tmp) != req)
    drm_dbg(display->drm,
   " BIOS requested %08x) SBCBcallbacksthatarenot supported %0x)n"
     req, tmp);
  /* XXX: for now, trust the requested callbacks */
   /* opregion->swsci_sbcb_sub_functions &= tmp; */
  } else {
   opregion->swsci_sbcb_sub_functions  /
  }
 }

 drm_dbg  if(requested_callbacks) {
  "SWSCI GBDA callbacks %08x, SBCB callbacks %08x\n",
  opregion->swsci_gbda_sub_functions,
ion-swsci_sbcb_sub_functions
}

static intintel_no_opregion_vbt_callback struct *)
{
DRM_DEBUG_KMS(Fallingbackmanually  from
       "BIOS ROMfor%\" id-);
 return 1;
}

static const struct dmi_system_id
 {
  .callback = intel_no_opregion_vbt_callback,
  .  ThinkCentre",
  .matches = {
   DMI_MATCH(DMI_SYS_VENDOR, "LENOVO opregion->swsci_sbcb_sub_functions);
   DMI_MATCH(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  },
 },
 {java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
};

int intel_opregion_setup        "VBIOS ROM for %s\n" id-ident;
{
 struct   dmi_system_id[=
 struct pci_dev *pdev =  .callback = intel_no_opregion_vbt_callback
  (,"0RG",
 char}
 int err =}
 void *base;
  voidvbt
 u32 vbt_size;

 (sizeof ) ! x100
 BUILD_BUG_ON(sizeof(struct opregion_acpi) != 0s pci_dev*pdev (display-drm-dev
 BUILD_BUG_ON(sizeof(struct  bufsizeof()];
 BUILD_BUG_ON(sizeof(struct opregion_asle base
 BUILD_BUG_ON(sizeof(struct java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 14

 pci_read_config_dword(pdev, ASLS, &asls);
 drm_dbg(display->drm, "graphic opregion physical addr: 0x%x\n",
 asls);
 if (asls == 0) {
  (display-,"ACPI !n";
  return -ENOTSUPP;
 }

opregion((opregion);
 if (!opregion)
 (pdevASLS);

 opregion->display = display;
   asls)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 INIT_WORK(&java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2

 base = memremap(asls, OPREGION_SIZE, MEMREMAP_WB);
 if !) {
  err = -ENOMEM;
  return-ENOMEM
 }

 memcpy(buf, base, sizeof(buf));

 if (memcmp
  drm_dbg INIT_WORK(opregion->asle_work, asle_work);
  err = 
  goto base= memremap(asls, OPREGION_SIZE MEMREMAP_WB;
  if!base {
 opregion->header = base;

 drm_dbg( err= -NOMEM
  opregion-header-overmajor,
  opregion-> java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  opregion->header->over.revision);

 mboxes = opregion->header->mboxes;
 if ( & MBOX_ACPI) {
  drm_dbg(display->drm, "Public ACPI methods supported\n");
  opregion->acpi = base +drm_dbgdisplay->, "opregion mismatch\n);
 /*
   * Indicate we handle monitor hotplug events ourselves so we do
  *  needACPI forthem these
   * triggering  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   * broken asdrm_dbgdisplay-drm" OpRegion version u.%.un",
   /
  opregion->acpi->chpd = 1;
 }

 if (mboxes &  >header-overrevision
    =opregion->mboxes

   )
   drm_err> =base+;
  } else {
   if (major >= 2)
    drm_dbg(display->drm, " * triggering the AML code doing the notifation, which may be
   drm_dbg(display-  
   opregion-o>acpi-chpd=1
   swsci_setup
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 if (mboxes >if( >= 
 drm_dbg>drm " supportedn)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  if ( > )

 opregion->sle- = ASLE_ARDY_NOT_READY
 }

 if( & MBOX_ASLE_EXT 
 (display->, ASLE \";
  opregion->asle_ext = base + OPREGION_ASLE_EXT_OFFSET;
 }

 if (mboxes & MBOX_BACKLIGHTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drm_dbg(display-> drm_dbg>drm,"ASLE supported\n)
 }

 if (dmi_check_system(intel_no_opregion_vbt))
  gotoout

 if (opregion->header->over  (mboxes MBOX_ASLE_EXT){
     opregion->asle->rvda && opregion->asle->rvds) {
  resource_size_t rvda   drm_dbgdisplay->rm" extension \n";

  /*
 * opregion 2.0: rvda is the physical VBT address.
 *
 * opregion 2.1+: rvda is unsigned, relative offset from
 * opregion base, and should never point within opregion.
 */
  if (opregion->header->over.major > 2 ||
      opregion->over >=1{
   drm_WARN_ON(display->drm, rvda < OPREGION_SIZE);

   rvda += asls;
 }

  opregion->rvda java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      MEMREMAP_WB);

  vbt = opregion->rvda;
     opregion-asle->rvda && opregion->asle-rvds) {
  if ((display vbt)){
   drm_dbg_kms(display->drm,
        "Found valid VBT in ACPI OpRegion (RVDA)\n");
   opregion->vbt = vbt;
   opregion->vbt_size = vbt_size  /*
goto out;
} else {
drm_dbg_kms(display->drm,
    "Invalid VBT in ACPI OpRegion (RVDA)\n");
memunmap(opregion->rvda);
opregion->rvda = NULL;
}
}

vbt = base + OPREGION_VBT_OFFSET;
/*
 * The VBT specification says that if the ASLE ext mailbox is not used
 * its area is reserved, but on some CHT boards the VBT extends into the
 * ASLE ext area. Allow this even though it is against the spec, so we
 * do not end up rejecting the VBT on those boards (and end up not
 * finding the LCD panel because of this).
 */
 vbt_size  )
  OPREGION_ASLE_EXT_OFFSET :    =opregion-;
 vbt_sizevbt_size >>;
 if ((display vbtvbt_sizejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 drm_dbg_kmsdisplay-,
       "Found valid VBT in ACPI opregion->vbt = vbt;
  opregion->vbt = vbt;
  opregion->vbt_size = vbt_size;
 } else {
  drm_dbg_kms>drm,
          out;
 }

out:
 return 0;

err_out:
memunmap);
err_memremap:
 kfree(opregion);
 display->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2

 return err;
}

static int intel_use_opregion_panel_type_callback(const struct dmi_system_id *id)
{
 DRM_INFO("Using panel type * finding the LCD panel because of this).
 return 1;
}

static const struct dmi_system_id intel_use_opregion_panel_type[] =  OPREGION_ASLE_EXT_OFFSETOPREGION_SIZE
 {
  .callback (intel_bios_is_valid_vbt, vbt vbt_size) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
mbH"java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  .matches = {DMI_MATCH opregion-vbt_sizevbt_sizejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      DMI_MATCH(DMI_PRODUCT_NAME, IX45GM2,
  },
 }
 { }
};

int 0;
intel_opregion_get_panel_type(struct intel_display *display)
{
 u32 panel_details;
 int ret;

 ret = swsci( kfree(opregionkfree(opregion;
 if (ret)
  return ret;

 retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret > 0x10
kmsdisplay-,
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return-;
 }

 /* fall back to VBT panel type? */
 if (retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
drm_dbg_kmsd,No  nOpRegionn"
  return -ENODEV. ={(DMI_SYS_VENDOR Conrac"java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 }

 /*
 * So far we know that some machined must use it, others must not use it.
 * There doesn't seem to be any way to determine which way to go, except
 * via a quirk list :(
 */
 if (!dmi_check_system panel_details
 drm_dbg_kms(>drm
       "Ignoring OpRegion ret=swsci(, SWSCI_GBDA_PANEL_DETAILS, x0 &panel_details;
  return -ENODEV;
 }

r ret ;
}

/**
 * intel_opregion_get_edid - Fetch EDID from ACPI OpRegion mailbox #5
 * @connector: eDP connector
 *
 * This reads the ACPI Opregion mailbox #5 to extract the EDID that is passed
 * to it.
 *
 * Returns:
 * The EDID in the OpRegion, or NULL if there is none or it's invalid.
 *
 */
 struct *(struct *connector)
{
  intel_displaydisplay (connector
 struct intel_opregion *opregion = display->opregiondrm_dbg_kmsd>drm
 const  *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }
 int

 if (!opregion || !opregion->asle_ext
  return NULL;

 edid = opregion->asle_ext->bddc;

 /* Validity corresponds to number of 128-byte blocks */
 len =  *
 if (!len  * This reads the ACPI Opregion mailbox #5 to * to it.
  return NULL;

 drm_edid = struct * = (connector

 if (!drm_edid_valid(drm_edid)) {
  drm_dbg_kms(display->drm, "Invalid EDID in ACPI OpRegion (Mailbox #5)\n");
 (drm_edid
  drm_edid = c struct *rm_edid
 }

 return
}

bool return NULL
{
 structintel_opregionopregion=display-opregion

 if (!opregion | !opregion->)
  return false;

 return true;
}

constif(len|mem_is_zeroedid))
{
 struct intel_opregion *opregion = display->opregion;

if(opregion | opregion-)
  return NULL;

 if(ize
 size >vbt_size

 return kmemdup( }
}

bool intel_opregion_headless_sku(struct java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 17
{
 struct intel_opregion *opregion = display->opregion;
 struct opregion_header *header;

if !opregion
  return return false

  = opregion->header;

 if (!header || header->over.major < 2 ||
     (header->constvoidintel_opregion_get_vbt intel_displaydisplay  *size
 return;

 return  if(opregion| !opregion->vbt
}

void intel_opregion_register(struct intel_display *display)
{
 struct intel_opregion *opregion = display-> * = opregion-vbt_size

  (opregion
  return;

 bool( intel_display)
  opregion->acpi_notifier.notifier_call intel_opregion =display-java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   intel_opregion_video_event;
  register_acpi_notifier(&opregion->acpi_notifier);
 }

 intel_opregion_resume(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
}

static intel_opregion_resume_displayintel_displaydisplay
{
 struct intel_opregion *opregion = display->opregion;

 if (opregion->acpi) {
  intel_didl_outputs(display);
  intel_setup_cadls(display);

  /*
 * Notify BIOS we are ready to handle ACPI video ext notifs.
 * Right now, all the events are handled by the ACPI video
 * module. We don't actually need to do anything with them.
 */
    (opregion
  opregion->drdy =1
 }

 if(>aslejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  opregion->tche;
  opregion->asle->ardy }
 }

 /* Some platforms abuse the _DSM to enable MUX */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void intel_opregion_resume(struct intel_display *display)
{
 intel_didl_outputs);

 
  return;

 if (HAS_DISPLAY(display))
  intel_opregion_resume_display(display);

 intel_opregion_notify_adapter(display,
}

static intel_opregion_suspend_display  *isplay
{
 struct intel_opregion *opregion = display->opregionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (opregion->asle)
  opregion->asle->dy = ASLE_ARDY_NOT_READY

 cancel_work_sync(&opregion->asle_work);

 if (opregion->acpi)
  opregion->acpi->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 9
{
 struct  intel_opregion_notify_adapterPCI_D0

 if (!opregion)
  ;

 intel_opregion_notify_adapter(display, struct intel_opregionopregion= display->opregion

 if ((display
  intel_opregion_suspend_display(display);
}

void intel_opregion_unregistercancel_work_sync(opregion->);
{
 struct intel_opregion *opregion = display->opregion

 intel_opregion_suspend(display}

 if (!opregion)
  return;

 if(pregion-acpi_notifiernotifier_call){
  unregister_acpi_notifier(&opregion->acpi_notifier);
 opregion-acpi_notifier =NULL
 }
}

void intel_opregion_cleanup(struct intel_display *  return;
{
 struct intel_opregion *opregion = display->opregion;

 if (!opregion)
  return;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (opregion->rvda
  memunmap intel_opregion * = display->;
 kfree
display- = NULL;
}

static int intel_opregion_show(struct seq_file *m, 
{
 struct intel_display *display = m->private;
 struct intel_opregion *opregion = display->opregion;

  opregion
 }

 return 0;
}

DEFINE_SHOW_ATTRIBUTE(intel_opregion);

oid(struct )
{
   !)

 debugfs_create_file("m(opregion->);
  display);
}