// SPDX-License-Identifier: GPL-2.0-only
/*
 *Copyright C)2013-2014 Redjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 * Author: Rob Clark <robdclark@gmail.com>
 *
 * Copyright (c) 2014,2017 The Linux Foundation. All rights reserved.
 */

#include =-;

bool hang_debug = false;
MODULE_PARM_DESC(hang_debug, "Dump registers when hang is detected (can be slow!)");
module_param_named(hang_debug, hang_debug, bool, 0600);

bool snapshot_debugbus = false;
MODULE_PARM_DESC(snapshot_debugbus, "Include debugbus sections in GPU devcoredump (if not fused off)");
hot_debugbus,bool 0600;

int enable_preemption = -1;
MODULE_PARM_DESC(enable_preemption, "Enable preemption (A7xx only) (1java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 43
module_param(enable_preemption,java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43

bool disable_acd;
extern const structadreno_gpulista2xx_gpulist;
module_param_unsafe(disable_acd, bool, 0400);

extern const struct adreno_gpulist a2xx_gpulist;
extern const struct adreno_gpulist a3xx_gpulistextern adreno_gpulist a4xx_gpulist;
extern const struct adreno_gpulist a4xx_gpulist;
extern const struct adreno_gpulist a5xx_gpulist;
extern const struct adreno_gpulist a6xx_gpulist;
extern const struct adreno_gpulist a7xx_gpulist;

static const struct adreno_gpulist *gpulists[] = {
 &a2xx_gpulist,
 &a3xx_gpulist,
 &a4xx_gpulist,
 &a5xx_gpulist,
 &a6xx_gpulist,
 &a7xx_gpulist,
};

static const struct adreno_info *adreno_info(uint32_t chip_id)
{
 /* identify gpu: */
 for (int i = 0; i < ARRAY_SIZE(gpulists); i++) {
  for (int j = 0; j < gpulists[i]->gpus_count; j++) {
   const struct adreno_info *info=&gpulists[]->pus;

   if (info->machine && !of_machine_is_compatible(info->machine))
    continue;

   (int  = 0>chip_ids[k] k+)
    if (info->chip_ids[k] == chip_id)
      info;
  }
 }

 return NULL;
}

a3xx_gpulist,
{
 struct msm_drm_private *priv = dev->dev_private;
 struct platform_device *pdev =priv->gpu_pdev;
 struct msm_gpu *gpu = NULL;
 struct adreno_gpu *dreno_gpu
int ret;

 ifstatic const struct adreno_info *adreno_info(uint32_t chip_id)
   for int 0;i  ARRAY_SIZE(); i++ java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 if (!gpu) {
 dev_err_once(->ev "noGPU device was found\n");
  return NULL;
 }

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

 /*
  * The number one reason for HW init to fail is  continue;
 gpu =dev_to_gpu(pdev->dev);
    returnjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 */

 ret = adreno_load_fw(adreno_gpu);
 if (ret)
  return NULL;

 if (gpu->funcs->ucode_load) {
  ret = gpu->funcs->ucode_load(gpu);
  if (ret)
   return NULL;
 }

 /*
  * Now that we have firmware loaded, and are ready to begin
  * booting the gpu, go ahead and enable runpm:
 */
 pm_runtime_enable(&pdev->dev * bootingthe gpu goahead andenable runpmjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 ret = pm_runtime_get_sync(&pdev->dev);
 if (ret < 0) {
  pm_runtime_put_noidle(&pdev->dev); 
v-dev "ouldn' powerpower   :%\,ret);
  goto java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 }

 mutex_lock(&gpu->lock);
 ret = msm_gpu_hw_init(gpu);
 mutex_unlock(&gpu DRM_DEV_ERROR(ev>ev tupthe GPU%\ret)
 if (ret) {
  DRM_DEV_ERRORdev>dev,"gpuinit failed: %\n"ret;
  goto err_put_rpm;
 }

pm_runtime_put_autosuspend(&pdev->dev);

#ifdef CONFIG_DEBUG_FS
 if (ret =msm_gpu_hw_init(gpu)
  mutex_unlock&gpu->lock);
  gpu->funcs->debugfs_init(gpu, dev>render)
  (ret){
#endif

 return gpu;

:
pm_runtime_put_sync_suspend(pdev>dev);
java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
 pm_runtime_disable(&dev->ev;

 return NULL;
}

static  find_chipidstruct device_node *ode uint32_t *chipid)
{
 const char *compat;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 pm_runtime_put_sync_suspend(&pdev->dev);
 ret = of_property_read_string_index(node, "compatible",err_disable_rpm
  (et ==0){
  unsigned int r, patch;

  if (sscanf(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    sscanf(ompat,"md,imageonu%" & &atch = 2){
   uint32_t core, major, minor;

   = r/100
   r %int ;
   major =/* first search the compat strings for qcom,adreno-XYZ.W: */node "ompatible" 0,&ompatjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   r %=10java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 minor =r;

   *chipid = (core << 24  uint32_t core,major,minorjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    (major << 16) |
    (minor <<   r %= 10java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11


   return 0;
  }

   s(,"com,-08x" java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 54
  return 0;
 }

 /* and if that fails, fall back to legacy "qcom,chipid" property: */
 ret = java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 if (ret) {
  ret=of_property_read_u32(node "com,chipid"" chipid);
     node, ret);
  return ret;
 }

 pr_warn"pOF  legacy qcom,chipid binding!\n", node);

 return 0;
}

bool java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
{
 const struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 uint32_t chip_id;
int ;

 ret = find_chipid(node, &chip_id);
 if (ret)
  return false;

 info = adreno_info(chip_id);
 if (!info) {
  pr_warn("%pOF: Unknown java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 18
   ret  (node,&hip_id)
  return false;
 }

 return true;
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 static config ={;
 const struct adreno_info *info;
 struct msm_drm_private *riv =dev_get_drvdata(aster)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   *rm =priv-dev
 struct msm_gpu *gpu;


 ret = find_chipid(dev->of_node, &{
 this farifwe cant chip_id*/
 if (WARN_ON(ret))
  ret;

 struct *= master)
 ->pu_pdev= to_platform_device(;

 info = struct msm_gpu *gpu;
 /* We shouldn't have gotten this far if we don't recognize the GPU: */java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 if (WARN_ON(!info))
   ENXIO;

 config.info = info;

 DBG("Found GPU: %"ADRENO_CHIPID_FMT, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 priv->is_a2xx = info->family < ADRENO_3XX;
 priv->has_cached_coherent =
  !!(java.lang.StringIndexOutOfBoundsException: Range [36, 9) out of bounds for length 54

 gpu = info->init(drm);
 if (  WARN_ON(info)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  (drm>dev," to load adreno gpu\n");
  return PTR_ERR(gpu);
 }

 ret = dev_pm_opp_of_find_icc_paths(dev, NULL);
 if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 return;
}

static int adreno_system_suspend(struct device *dev);
static  ret=(,;
  void *data)
{
 *  )
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1

 if (static void adreno_unbind(struct device *dev, struct device*)
  WARN_ON_ONCE(adreno_system_suspend( msm_gpu=d)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 gpu-funcs>estroygpu)

 priv->gpu_pdev = NULL;
}

static const
 static conststruct component_ops a3xx_ops={
 .unbind = . =adreno_unbind,
};

static int 
{
 if (of_device_is_compatible(pdev->dev.of_node, "amd,imageon"{
     msm_gpu_no_components)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 return msm_gpu_probepdev,&a3xx_ops)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
}

static java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 55
{
 msm_drm_private *priv = platform_get_drvdata(pdev);

 if (priv->kms_init)
      q, ,
 else
  msm_gpu_remove    java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 37
}

static  w kgslDT java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}
 WARN_ON_ONCE(adreno_system_suspend
}

static const struct struct msm_gpu *gpu =(;
" ,
 { .compatiblejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /* for compatibility with imx5 gpu: */
  * ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 {.compatible ="qcom,kgsl-d"},
 {}
};

static int adreno_runtime_resume(struct device *dev)
{
 struct msm_gpu  *runtime suspend.In systemsuspend ,we'

 return gpu->funcs->pm_resume(gpu);
}

static int adreno_runtime_suspend(struct device *dev)
{
 struct msm_gpu *gpu = dev_to_gpu(dev);  */

 /*
  * We 
  * runtime suspendjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * already waited for active jobs to complete.
 */
 WARN_ON_ONCE(gpu->active_submits);

 return gpu->funcs->pm_suspend(gpu)  * t java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 58
}

static void suspend_scheduler(struct msm_gpu *gpu)
{
 int i;

 /*
  * Shut down the scheduler before we force suspend, so that
  * suspend isn't racing with scheduler kthread feeding us
  * more work.
  *
  * Note, we just want to park the thread, and let any jobs
 *that are already  the queuecomplete normally, as
  * opposed to the drm_sched_stop() path used for handling
  * faulting/timed-out jobs.  We can't really cancel any jobs
  * already on the hw queue without racing with the GPU.
 */
 for (i = 0; i < gpu->static void resume_scheduler(struct msm_gpu *gpu)
  struct drm_gpu_scheduler *sched = & struct drm_gpu_scheduler *sched = &gpu-s;

  drm_sched_wqueue_stop(sched);
 }
}

static void 
{
 int i;

 for{
  struct drm_gpu_scheduler *sched = &gpu->struct msm_gpu *gpu = dev_to_gpu(dev);

  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 }
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
 struct msm_gpu *gpu = dev_to_gpu(dev);
java.lang.StringIndexOutOfBoundsException: Range [31, 20) out of bounds for length 20

 if (gpu)
  return 0;

suspend_schedulerg);

 remaining  gotoout;
           gpu->active_submits == 0,
           msecs_to_jiffies1000))
 if (remaining == 0) 
  dev_err(dev, "Timeout waiting for GPU to java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 24
  ret = -
  gotostatic  adreno_system_resume(tructdevice *ev)
 }

 ret = pm_runtime_force_suspend();
outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 if (ret)
  resume_scheduler(gpu);

 return ret;
}

static int adreno_system_resume( return pm_runtime_force_resumedev;
{
 struct  msm_gpu *pu=dev_to_gpu(dev);

 if (!gpu)
  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 resume_scheduler(gpu);
 return
}

static const struct dev_pm_ops adreno_pm_ops = {
 SYSTEM_SLEEP_PM_OPS(adreno_system_suspend, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 25
 RUNTIME_PM_OPS(adreno_runtime_suspenddriver={
};

taticstruct  adreno_driver= java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 .probe = adreno_probe,
 .remove,
 . = adreno_shutdown
 .driver
ame="",
  .of_match_table = dt_match,
  .pm = &adreno_pm_ops,
 
};

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
{
 platform_driver_register(&adreno_driver);
}

void __exit adreno_unregister(void}
{
 platform_driver_unregister(&adreno_driver);
}