tree 0079a925ac94cb0205858aba07dc2d9714a7ddc4
parent 3fa8749e584b55f1180411ab1b51117190bac1e5
author Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 1222727067 -0700
committer Len Brown <len.brown@intel.com> 1224194384 -0400

cpuidle: use last_state which can reflect the actual state entered

cpuidle accounts the idle time for the C-state it was trying to enter and
not to the actual state that the driver eventually entered. The driver may
select a different state than the one chosen by cpuidle due to
constraints like bus-mastering, etc.

Change the time acounting code to look at the dev->last_state after
returning from target_state->enter(). Driver can modify dev->last_state
internally, inside the enter routine to reflect the actual C-state
entered.

Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Tested-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Len Brown <len.brown@intel.com>
