linux-toradex.git/drivers/cpuidle/coupled.c, branch v4.10

cpuidle/coupled: Convert to hotplug state machine

2016-09-06T16:30:24+00:00

Install the callbacks via the state machine.

Signed-off-by: Sebastian Andrzej Siewior 
Cc: linux-pm@vger.kernel.org
Cc: Peter Zijlstra 
Cc: Daniel Lezcano 
Cc: "Rafael J. Wysocki" 
Cc: rt@linutronix.de
Link: http://lkml.kernel.org/r/20160824091444.brdr5zpbxjvh6n3f@linutronix.de
Signed-off-by: Thomas Gleixner

cpuidle: coupled: remove unused define cpuidle_coupled_lock

2016-01-27T22:08:46+00:00

This was found with the -RT patch enabled, but the fix should apply to
non-RT also.

Used multi_v7_defconfig+PREEMPT_RT_FULL=y and this caused a compilation
warning without this fix:
../drivers/cpuidle/coupled.c:122:21: warning: 'cpuidle_coupled_lock'
defined but not used [-Wunused-variable]

Signed-off-by: Anders Roxell 
Signed-off-by: Rafael J. Wysocki

cpuidle/coupled: Add sanity check for safe_state_index

2015-09-03T01:05:47+00:00

Since we are using cpuidle_driver::safe_state_index directly as the
target state index, it is better to add the sanity check at the point
of registering the driver.

Signed-off-by: Xunlei Pang 
Signed-off-by: Rafael J. Wysocki

cpuidle/coupled: Remove redundant 'dev' argument of cpuidle_state_is_coupled()

2015-08-28T13:14:54+00:00

For cpuidle_state_is_coupled(), 'dev' is not used, so remove it.

Signed-off-by: Xunlei Pang 
Signed-off-by: Rafael J. Wysocki

cpuidle/coupled: Remove cpuidle_device::safe_state_index

2015-08-28T13:14:54+00:00

cpuidle_device::safe_state_index need to be initialized before
use, it should be the same as cpuidle_driver::safe_state_index.

We tackled this issue by removing the safe_state_index from the
cpuidle_device structure and use the one in the cpuidle_driver
structure instead.

Suggested-by: Daniel Lezcano 
Signed-off-by: Xunlei Pang 
Signed-off-by: Rafael J. Wysocki

drivers: fix up obsolete cpu function usage.

2015-03-05T03:07:02+00:00

Thanks to spatch, plus manual removal of "&*".  Then a sweep for
for_each_cpu_mask => for_each_cpu.

Signed-off-by: Rusty Russell 
Acked-by: Rafael J. Wysocki 
Cc: Thomas Gleixner 
Cc: Herbert Xu 
Cc: Jason Cooper 
Cc: Chris Metcalf 
Cc: netdev@vger.kernel.org

arch: Mass conversion of smp_mb__*()

2014-04-18T12:20:48+00:00

Mostly scripted conversion of the smp_mb__* barriers.

Signed-off-by: Peter Zijlstra 
Acked-by: Paul E. McKenney 
Link: http://lkml.kernel.org/n/tip-55dhyhocezdw1dg7u19hmh1u@git.kernel.org
Cc: Linus Torvalds 
Cc: linux-arch@vger.kernel.org
Signed-off-by: Ingo Molnar

smp: Rename __smp_call_function_single() to smp_call_function_single_async()

2014-02-24T22:47:15+00:00

The name __smp_call_function_single() doesn't tell much about the
properties of this function, especially when compared to
smp_call_function_single().

The comments above the implementation are also misleading. The main
point of this function is actually not to be able to embed the csd
in an object. This is actually a requirement that result from the
purpose of this function which is to raise an IPI asynchronously.

As such it can be called with interrupts disabled. And this feature
comes at the cost of the caller who then needs to serialize the
IPIs on this csd.

Lets rename the function and enhance the comments so that they reflect
these properties.

Suggested-by: Christoph Hellwig 
Cc: Andrew Morton 
Cc: Christoph Hellwig 
Cc: Ingo Molnar 
Cc: Jan Kara 
Cc: Jens Axboe 
Signed-off-by: Frederic Weisbecker 
Signed-off-by: Jens Axboe

smp: Remove wait argument from __smp_call_function_single()

2014-02-24T22:47:09+00:00

The main point of calling __smp_call_function_single() is to send
an IPI in a pure asynchronous way. By embedding a csd in an object,
a caller can send the IPI without waiting for a previous one to complete
as is required by smp_call_function_single() for example. As such,
sending this kind of IPI can be safe even when irqs are disabled.

This flexibility comes at the expense of the caller who then needs to
synchronize the csd lifecycle by himself and make sure that IPIs on a
single csd are serialized.

This is how __smp_call_function_single() works when wait = 0 and this
usecase is relevant.

Now there don't seem to be any usecase with wait = 1 that can't be
covered by smp_call_function_single() instead, which is safer. Lets look
at the two possible scenario:

1) The user calls __smp_call_function_single(wait = 1) on a csd embedded
   in an object. It looks like a nice and convenient pattern at the first
   sight because we can then retrieve the object from the IPI handler easily.

   But actually it is a waste of memory space in the object since the csd
   can be allocated from the stack by smp_call_function_single(wait = 1)
   and the object can be passed an the IPI argument.

   Besides that, embedding the csd in an object is more error prone
   because the caller must take care of the serialization of the IPIs
   for this csd.

2) The user calls __smp_call_function_single(wait = 1) on a csd that
   is allocated on the stack. It's ok but smp_call_function_single()
   can do it as well and it already takes care of the allocation on the
   stack. Again it's more simple and less error prone.

Therefore, using the underscore prepend API version with wait = 1
is a bad pattern and a sign that the caller can do safer and more
simple.

There was a single user of that which has just been converted.
So lets remove this option to discourage further users.

Cc: Andrew Morton 
Cc: Christoph Hellwig 
Cc: Ingo Molnar 
Cc: Jan Kara 
Cc: Jens Axboe 
Signed-off-by: Frederic Weisbecker 
Signed-off-by: Jens Axboe

cpuidle: Fix comments in cpuidle core

2013-10-30T00:21:21+00:00

Some comments in cpuidle core files contain trivial mistakes.
This patch fixes them.

Signed-off-by: Viresh Kumar 
Signed-off-by: Rafael J. Wysocki