tree 599403c4442e99f8a63a0635e1712e4a564b50a2
parent 4b4f62c4672805466652a785070cc2ac8a398e16
author Paul Walmsley <paul@pwsan.com> 1292986880 -0700
committer Paul Walmsley <paul@pwsan.com> 1292986880 -0700

OMAP2+: powerdomains: move powerdomain static data to .c files

Static data should be declared in .c files, not .h files.  It should be
possible to #include .h files at any point without creating multiple
copies of the same data.

We converted the clock data to .c files some time ago.  This patch does
the same for the powerdomain data.

Signed-off-by: Paul Walmsley <paul@pwsan.com>
Cc: Rajendra Nayak <rnayak@ti.com>
Cc: Santosh Shilimkar <santosh.shilimkar@ti.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>
