Esempio n. 1
0
static int 
mtk_cl_mddulthro_get_cur_state(struct thermal_cooling_device *cdev,
                          unsigned long *state)
{
  MTK_CL_MDDULTHRO_GET_CURR_STATE(*state, *((unsigned long*) cdev->devdata));
  mtk_cooler_mddulthro_dprintk("mtk_cl_mddulthro_get_cur_state() %s %d\n", cdev->type, *state);
  return 0;
}
Esempio n. 2
0
static int _mtk_cl_mddulthro_proc_read(char *buf, char **start, off_t off, int count, int *eof, void *data)
{
    int len = 0;
    char *p = buf;

    mtk_cooler_mddulthro_dprintk("[_mtk_cl_mddulthro_proc_read] invoked.\n");

    /**
     * The format to print out: 
     *  kernel_log <0 or 1>
     *  <mtk-cl-mddulthro<ID>> <bcc limit>
     *  ..
     */
    if (NULL == data)
    {
        mtk_cooler_mddulthro_dprintk("[_mtk_cl_mddulthro_proc_read] null data\n");
    }
    else
    {
        int i = 0;

        p += sprintf(p, "klog %d\n", cl_mddulthro_klog_on);
        p += sprintf(p, "curr_limit %d\n", cl_mddulthro_cur_limit);

        for (; i < MAX_NUM_INSTANCE_MTK_COOLER_MDDULTHRO; i++)
        {
            int limit;
            unsigned int curr_state;
            
            MTK_CL_MDDULTHRO_GET_LIMIT(limit, cl_mddulthro_state[i]);
            MTK_CL_MDDULTHRO_GET_CURR_STATE(curr_state, cl_mddulthro_state[i]);
        
            p += sprintf(p, "mtk-cl-mddulthro%02d lv %d, state %d\n", i, limit, curr_state);
        }
    }

    *start = buf + off;

    len = p - buf;
    if (len > off)
        len -= off;
    else
        len = 0;

    return len < count ? len  : count;
}
static void 
mtk_cl_mddulthro_set_mddulthro_limit(void)
{
  // TODO: optimize
  int i = 0;
  int min_limit = 0;
  for (; i < MAX_NUM_INSTANCE_MTK_COOLER_MDDULTHRO; i++)
  {
    unsigned long curr_state;

    MTK_CL_MDDULTHRO_GET_CURR_STATE(curr_state, cl_mddulthro_state[i]);
    if (1 == curr_state)
    {
      int limit;
      MTK_CL_MDDULTHRO_GET_LIMIT(limit, cl_mddulthro_state[i]);
      if ((min_limit < limit) && (limit > 0))
        min_limit = limit;
    }
  }

  if (min_limit != cl_mddulthro_cur_limit)
  {
    cl_mddulthro_cur_limit = min_limit;
#if 1
    if (0 >= cl_mddulthro_cur_limit)
    {
      int ret = 
        amddulthro_backoff(0);
      mtk_cooler_mddulthro_dprintk_always("mtk_cl_mddulthro_set_mddulthro_limit() ret %d limit=0\n", ret);
    }
    else
    {
      int ret = 
        amddulthro_backoff(cl_mddulthro_cur_limit);
      mtk_cooler_mddulthro_dprintk_always("mtk_cl_mddulthro_set_mddulthro_limit() ret %d limit=%d\n", cl_mddulthro_cur_limit);
    }
#endif
  }
}