Commit 62214039 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'pm-cpuidle' 

* pm-cpuidle:
  cpuidle: Pass exit latency limit to cpuidle_use_deepest_state()
  cpuidle: Allow idle injection to apply exit latency limit
  cpuidle: Introduce cpuidle_driver_state_disabled() for driver quirks
  cpuidle: teo: Avoid code duplication in conditionals
  cpuidle: teo: Avoid using "early hits" incorrectly
  cpuidle: teo: Exclude cpuidle overhead from computations
  cpuidle: Use nanoseconds as the unit of time
  cpuidle: Consolidate disabled state checks
  ACPI: processor_idle: Skip dummy wait if kernel is in guest
  cpuidle: Do not unset the driver if it is there already
  cpuidle: teo: Fix "early hits" handling for disabled idle states
  cpuidle: teo: Consider hits and misses metrics of disabled states
  cpuidle: teo: Rename local variable in teo_select()
  cpuidle: teo: Ignore disabled idle states that are too deep
parents 05ff1ba4 5aa9ba63

arch/arm/mach-imx/cpuidle-imx6q.c

+2 −2
Original line number Diff line number Diff line
@@ -62,13 +62,13 @@ static struct cpuidle_driver imx6q_cpuidle_driver = { 
 */

void imx6q_cpuidle_fec_irqs_used(void)

{

	imx6q_cpuidle_driver.states[1].disabled = true;

	cpuidle_driver_state_disabled(&imx6q_cpuidle_driver, 1, true);

}

EXPORT_SYMBOL_GPL(imx6q_cpuidle_fec_irqs_used);



void imx6q_cpuidle_fec_irqs_unused(void)

{

	imx6q_cpuidle_driver.states[1].disabled = false;

	cpuidle_driver_state_disabled(&imx6q_cpuidle_driver, 1, false);

}

EXPORT_SYMBOL_GPL(imx6q_cpuidle_fec_irqs_unused);

arch/arm/mach-tegra/cpuidle-tegra20.c

+1 −1
Original line number Diff line number Diff line
@@ -203,7 +203,7 @@ void tegra20_cpuidle_pcie_irqs_in_use(void) 
{

	pr_info_once(

		"Disabling cpuidle LP2 state, since PCIe IRQs are in use\n");

	tegra_idle_driver.states[1].disabled = true;

	cpuidle_driver_state_disabled(&tegra_idle_driver, 1, true);

}



int __init tegra20_cpuidle_init(void)

drivers/acpi/processor_idle.c

+15 −6
Original line number Diff line number Diff line
@@ -642,6 +642,19 @@ static int acpi_idle_bm_check(void) 
	return bm_status;

}



static void wait_for_freeze(void)

{

#ifdef	CONFIG_X86

	/* No delay is needed if we are in guest */

	if (boot_cpu_has(X86_FEATURE_HYPERVISOR))

		return;

#endif

	/* Dummy wait op - must do something useless after P_LVL2 read

	   because chipsets cannot guarantee that STPCLK# signal

	   gets asserted in time to freeze execution properly. */

	inl(acpi_gbl_FADT.xpm_timer_block.address);

}



/**

 * acpi_idle_do_entry - enter idle state using the appropriate method

 * @cx: cstate data
@@ -658,10 +671,7 @@ static void __cpuidle acpi_idle_do_entry(struct acpi_processor_cx *cx) 
	} else {

		/* IO port based C-state */

		inb(cx->address);

		/* Dummy wait op - must do something useless after P_LVL2 read

		   because chipsets cannot guarantee that STPCLK# signal

		   gets asserted in time to freeze execution properly. */

		inl(acpi_gbl_FADT.xpm_timer_block.address);

		wait_for_freeze();

	}

}
@@ -682,8 +692,7 @@ static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 
			safe_halt();

		else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {

			inb(cx->address);

			/* See comment in acpi_idle_do_entry() */

			inl(acpi_gbl_FADT.xpm_timer_block.address);

			wait_for_freeze();

		} else

			return -ENODEV;

	}

drivers/cpuidle/cpuidle-powernv.c

+2 −5
Original line number Diff line number Diff line
@@ -56,13 +56,10 @@ static u64 get_snooze_timeout(struct cpuidle_device *dev, 
		return default_snooze_timeout;



	for (i = index + 1; i < drv->state_count; i++) {

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

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



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

		if (dev->states_usage[i].disable)

			continue;



		return s->target_residency * tb_ticks_per_usec;

		return drv->states[i].target_residency * tb_ticks_per_usec;

	}



	return default_snooze_timeout;

drivers/cpuidle/cpuidle.c

+37 −35
Original line number Diff line number Diff line
@@ -75,44 +75,45 @@ int cpuidle_play_dead(void) 


static int find_deepest_state(struct cpuidle_driver *drv,

			      struct cpuidle_device *dev,

			      unsigned int max_latency,

			      u64 max_latency_ns,

			      unsigned int forbidden_flags,

			      bool s2idle)

{

	unsigned int latency_req = 0;

	u64 latency_req = 0;

	int i, ret = 0;



	for (i = 1; i < drv->state_count; i++) {

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

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



		if (s->disabled || su->disable || s->exit_latency <= latency_req

		    || s->exit_latency > max_latency

		    || (s->flags & forbidden_flags)

		    || (s2idle && !s->enter_s2idle))

		if (dev->states_usage[i].disable ||

		    s->exit_latency_ns <= latency_req ||

		    s->exit_latency_ns > max_latency_ns ||

		    (s->flags & forbidden_flags) ||

		    (s2idle && !s->enter_s2idle))

			continue;



		latency_req = s->exit_latency;

		latency_req = s->exit_latency_ns;

		ret = i;

	}

	return ret;

}



/**

 * cpuidle_use_deepest_state - Set/clear governor override flag.

 * @enable: New value of the flag.

 * cpuidle_use_deepest_state - Set/unset governor override mode.

 * @latency_limit_ns: Idle state exit latency limit (or no override if 0).

 *

 * Set/unset the current CPU to use the deepest idle state (override governors

 * going forward if set).

 * If @latency_limit_ns is nonzero, set the current CPU to use the deepest idle

 * state with exit latency within @latency_limit_ns (override governors going

 * forward), or do not override governors if it is zero.

 */

void cpuidle_use_deepest_state(bool enable)

void cpuidle_use_deepest_state(u64 latency_limit_ns)

{

	struct cpuidle_device *dev;



	preempt_disable();

	dev = cpuidle_get_device();

	if (dev)

		dev->use_deepest_state = enable;

		dev->forced_idle_latency_limit_ns = latency_limit_ns;

	preempt_enable();

}
@@ -122,9 +123,10 @@ void cpuidle_use_deepest_state(bool enable) 
 * @dev: cpuidle device for the given CPU.

 */

int cpuidle_find_deepest_state(struct cpuidle_driver *drv,

			       struct cpuidle_device *dev)

			       struct cpuidle_device *dev,

			       u64 latency_limit_ns)

{

	return find_deepest_state(drv, dev, UINT_MAX, 0, false);

	return find_deepest_state(drv, dev, latency_limit_ns, 0, false);

}



#ifdef CONFIG_SUSPEND
@@ -180,7 +182,7 @@ int cpuidle_enter_s2idle(struct cpuidle_driver *drv, struct cpuidle_device *dev) 
	 * that interrupts won't be enabled when it exits and allows the tick to

	 * be frozen safely.

	 */

	index = find_deepest_state(drv, dev, UINT_MAX, 0, true);

	index = find_deepest_state(drv, dev, U64_MAX, 0, true);

	if (index > 0)

		enter_s2idle_proper(drv, dev, index);
@@ -209,7 +211,7 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, 
	 * CPU as a broadcast timer, this call may fail if it is not available.

	 */

	if (broadcast && tick_broadcast_enter()) {

		index = find_deepest_state(drv, dev, target_state->exit_latency,

		index = find_deepest_state(drv, dev, target_state->exit_latency_ns,

					   CPUIDLE_FLAG_TIMER_STOP, false);

		if (index < 0) {

			default_idle_call();
@@ -247,7 +249,7 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, 
		local_irq_enable();



	if (entered_state >= 0) {

		s64 diff, delay = drv->states[entered_state].exit_latency;

		s64 diff, delay = drv->states[entered_state].exit_latency_ns;

		int i;



		/*
@@ -255,18 +257,15 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, 
		 * This can be moved to within driver enter routine,

		 * but that results in multiple copies of same code.

		 */

		diff = ktime_us_delta(time_end, time_start);

		if (diff > INT_MAX)

			diff = INT_MAX;

		diff = ktime_sub(time_end, time_start);



		dev->last_residency = (int)diff;

		dev->states_usage[entered_state].time += dev->last_residency;

		dev->last_residency_ns = diff;

		dev->states_usage[entered_state].time_ns += diff;

		dev->states_usage[entered_state].usage++;



		if (diff < drv->states[entered_state].target_residency) {

		if (diff < drv->states[entered_state].target_residency_ns) {

			for (i = entered_state - 1; i >= 0; i--) {

				if (drv->states[i].disabled ||

				    dev->states_usage[i].disable)

				if (dev->states_usage[i].disable)

					continue;



				/* Shallower states are enabled, so update. */
@@ -275,22 +274,21 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, 
			}

		} else if (diff > delay) {

			for (i = entered_state + 1; i < drv->state_count; i++) {

				if (drv->states[i].disabled ||

				    dev->states_usage[i].disable)

				if (dev->states_usage[i].disable)

					continue;



				/*

				 * Update if a deeper state would have been a

				 * better match for the observed idle duration.

				 */

				if (diff - delay >= drv->states[i].target_residency)

				if (diff - delay >= drv->states[i].target_residency_ns)

					dev->states_usage[entered_state].below++;



				break;

			}

		}

	} else {

		dev->last_residency = 0;

		dev->last_residency_ns = 0;

	}



	return entered_state;
@@ -380,10 +378,10 @@ u64 cpuidle_poll_time(struct cpuidle_driver *drv, 


	limit_ns = TICK_NSEC;

	for (i = 1; i < drv->state_count; i++) {

		if (drv->states[i].disabled || dev->states_usage[i].disable)

		if (dev->states_usage[i].disable)

			continue;



		limit_ns = (u64)drv->states[i].target_residency * NSEC_PER_USEC;

		limit_ns = (u64)drv->states[i].target_residency_ns;

	}



	dev->poll_limit_ns = limit_ns;
@@ -554,7 +552,7 @@ static void __cpuidle_unregister_device(struct cpuidle_device *dev) 
static void __cpuidle_device_init(struct cpuidle_device *dev)

{

	memset(dev->states_usage, 0, sizeof(dev->states_usage));

	dev->last_residency = 0;

	dev->last_residency_ns = 0;

	dev->next_hrtimer = 0;

}
@@ -567,12 +565,16 @@ static void __cpuidle_device_init(struct cpuidle_device *dev) 
 */

static int __cpuidle_register_device(struct cpuidle_device *dev)

{

	int ret;

	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);

	int i, ret;



	if (!try_module_get(drv->owner))

		return -EINVAL;



	for (i = 0; i < drv->state_count; i++)

		if (drv->states[i].disabled)

			dev->states_usage[i].disable |= CPUIDLE_STATE_DISABLED_BY_DRIVER;



	per_cpu(cpuidle_devices, dev->cpu) = dev;

	list_add(&dev->device_list, &cpuidle_detected_devices);

CRA Git | Maintained and supported by SUSTech CRA and CCSE