tree 0de10fe595631821b60bbc847ede377e370bc147
parent 74bea6b9881f4b32f6c0379e46d2f5e16fd34a07
author Rajendra Nayak <rnayak@ti.com> 1292986878 -0700
committer Paul Walmsley <paul@pwsan.com> 1292986878 -0700

OMAP: powerdomain: Infrastructure to put arch specific code

Put infrastructure in place, so arch specific func pointers
can be hooked up to the platform-independent part of the
framework.
This is in preparation of splitting the powerdomain framework into
platform-independent part (for all omaps) and platform-specific
parts.

Signed-off-by: Rajendra Nayak <rnayak@ti.com>
Signed-off-by: Paul Walmsley <paul@pwsan.com>
Cc: Benoit Cousson <b-cousson@ti.com>
Cc: Kevin Hilman <khilman@deeprootsystems.com>
Reviewed-by: Kevin Hilman <khilman@deeprootsystems.com>
Tested-by: Kevin Hilman <khilman@deeprootsystems.com>
Tested-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Tested-by: Rajendra Nayak <rnayak@ti.com>
