tree 5814d6a95d8edb64b9e4d01e75dfeb15edd8d972
parent ff2516fbef20ed9edd9cc2fc8b8b48d5cb5a932f
author Rajendra Nayak <rnayak@ti.com> 1292986877 -0700
committer Paul Walmsley <paul@pwsan.com> 1292986877 -0700

OMAP: powerdomain: Move static allocations from powerdomains.h to a .c file

powerdomains.h header today has only static definitions.  Adding any
function declarations into it and including it in multiple source file
is expected to cause issues.  Hence move all the static definitions
from powerdomains.h file into powerdomains_data.c file.

Also, create a new powerdomain section of the mach-omap2/Makefile, and
rearrange the prcm-common part of the Makefile, now that the
powerdomain code is in its own Makefile section.

Signed-off-by: Rajendra Nayak <rnayak@ti.com>
[paul@pwsan.com: rearrange Makefile changes, tweaked commit message]
Signed-off-by: Paul Walmsley <paul@pwsan.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>
