蜗窝科技

   1: static struct cpuidle_governor menu_governor = {

   2:         .name =         "menu",

   3:         .rating =       20,

   4:         .enable =       menu_enable_device,

   5:         .select =       menu_select,

   6:         .reflect =      menu_reflect,

   7:         .owner =        THIS_MODULE,

   8: };

   9:  

  10: /**

  11:  * init_menu - initializes the governor

  12:  */

  13: static int __init init_menu(void)

  14: {

  15:         return cpuidle_register_governor(&menu_governor);

  16: }

  17:  

  18: postcore_initcall(init_menu);

   1: static int menu_enable_device(struct cpuidle_driver *drv,

   2:                                 struct cpuidle_device *dev)

   3: {

   4:         struct menu_device *data = &per_cpu(menu_devices, dev->cpu);

   5:         int i;

   6:  

   7:         memset(data, 0, sizeof(struct menu_device));

   8:  

   9:         /*

  10:          * if the correction factor is 0 (eg first time init or cpu hotplug

  11:          * etc), we actually want to start out with a unity factor.

  12:          */

  13:         for(i = 0; i < BUCKETS; i++)

  14:                 data->correction_factor[i] = RESOLUTION * DECAY;

  15:  

  16:         return 0;

  17: }

   1: struct menu_device {

   2:         int             last_state_idx;

   3:         int             needs_update;

   4:  

   5:         unsigned int    next_timer_us;

   6:         unsigned int    predicted_us;

   7:         unsigned int    bucket;

   8:         unsigned int    correction_factor[BUCKETS];

   9:         unsigned int    intervals[INTERVALS];

  10:         int             interval_ptr;

  11: };

   1: /**

   2:  * menu_select - selects the next idle state to enter

   3:  * @drv: cpuidle driver containing state data

   4:  * @dev: the CPU

   5:  */

   6: static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)

   7: {

   8:     struct menu_device *data = this_cpu_ptr(&menu_devices);

   9:     int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY);

  10:     int i;

  11:     unsigned int interactivity_req;

  12:     unsigned long nr_iowaiters, cpu_load;

  13:  

  14:     if (data->needs_update) {

  15:         menu_update(drv, dev);

  16:         data->needs_update = 0;

  17:     }

  18:  

  19:     data->last_state_idx = CPUIDLE_DRIVER_STATE_START - 1;

  20:  

  21:     /* Special case when user has set very strict latency requirement */

  22:     if (unlikely(latency_req == 0))

  23:         return 0;

  24:  

  25:     /* determine the expected residency time, round up */

  26:     data->next_timer_us = ktime_to_us(tick_nohz_get_sleep_length());

  27:  

  28:     get_iowait_load(&nr_iowaiters, &cpu_load);

  29:     data->bucket = which_bucket(data->next_timer_us, nr_iowaiters);

  30:  

  31:     /*

  32:      * Force the result of multiplication to be 64 bits even if both

  33:      * operands are 32 bits.

  34:      * Make sure to round up for half microseconds.

  35:      */

  36:     data->predicted_us = div_round64((uint64_t)data->next_timer_us *

  37:                      data->correction_factor[data->bucket],

  38:                      RESOLUTION * DECAY);

  39:  

  40:     get_typical_interval(data);

  41:  

  42:     /*

  43:      * Performance multiplier defines a minimum predicted idle

  44:      * duration / latency ratio. Adjust the latency limit if

  45:      * necessary.

  46:      */

  47:     interactivity_req = data->predicted_us / performance_multiplier(nr_iowaiters, cpu_load);

  48:     if (latency_req > interactivity_req)

  49:         latency_req = interactivity_req;

  50:  

  51:     /*

  52:      * We want to default to C1 (hlt), not to busy polling

  53:      * unless the timer is happening really really soon.

  54:      */

  55:     if (data->next_timer_us > 5 &&

  56:         !drv->states[CPUIDLE_DRIVER_STATE_START].disabled &&

  57:         dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0)

  58:         data->last_state_idx = CPUIDLE_DRIVER_STATE_START;

  59:  

  60:     /*

  61:      * Find the idle state with the lowest power while satisfying

  62:      * our constraints.

  63:      */

  64:     for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) {

  65:         struct cpuidle_state *s = &drv->states[i];

  66:         struct cpuidle_state_usage *su = &dev->states_usage[i];

  67:  

  68:         if (s->disabled || su->disable)

  69:             continue;

  70:         if (s->target_residency > data->predicted_us)

  71:             continue;

  72:         if (s->exit_latency > latency_req)

  73:             continue;

  74:  

  75:         data->last_state_idx = i;

  76:     }

  77:  

  78:     return data->last_state_idx;

  79: }