tree 4ae87d681a844997f94ff987d060b2c44dac30ed
parent 5d76b6f6c17572e662f5c99c2023adae92100855
author Len Brown <len.brown@intel.com> 1263960604 -0500
committer Len Brown <len.brown@intel.com> 1263966855 -0500

ACPI: allow C3 > 1000usec

Do for C3 what the previous patch did for C2.

The C2 patch was in response to a highly visible
and multiply reported C-state/turbo failure,
while this change has no bug report in-hand.

This will enable C3 in Linux on systems where BIOS
overstates C3 latency in _CST.  It will also enable
future systems which may actually have C3 > 1000usec.

Linux has always ignored ACPI BIOS C3 with exit latency > 1000 usec,
and the ACPI spec is clear that is correct FADT-supplied C3.

However, the ACPI spec explicitly states that _CST-supplied C-states
have no latency limits.

So move the 1000usec C3 test out of the code shared
by FADT and _CST code-paths, and into the FADT-specific path.

Signed-off-by: Len Brown <len.brown@intel.com>
