Merge branches 'core-fixes-for-linus' and 'irq-fixes-for-linus' of git://git.kernel...
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 26 May 2011 19:19:11 +0000 (12:19 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 26 May 2011 19:19:11 +0000 (12:19 -0700)
* 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  seqlock: Get rid of SEQLOCK_UNLOCKED

* 'irq-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  irq: Remove smp_affinity_list when unregister irq proc

347 files changed:
Documentation/ABI/removed/o2cb [moved from Documentation/ABI/obsolete/o2cb with 65% similarity]
Documentation/ABI/testing/sysfs-kernel-mm-cleancache [new file with mode: 0644]
Documentation/feature-removal-schedule.txt
Documentation/filesystems/ext4.txt
Documentation/filesystems/ocfs2.txt
Documentation/filesystems/xfs.txt
Documentation/vm/cleancache.txt [new file with mode: 0644]
MAINTAINERS
arch/arm/configs/omap2plus_defconfig
arch/arm/mach-omap2/Kconfig
arch/arm/mach-omap2/Makefile
arch/arm/mach-omap2/board-2430sdp.c
arch/arm/mach-omap2/board-3430sdp.c
arch/arm/mach-omap2/board-4430sdp.c
arch/arm/mach-omap2/board-am3517crane.c
arch/arm/mach-omap2/board-am3517evm.c
arch/arm/mach-omap2/board-apollon.c
arch/arm/mach-omap2/board-cm-t35.c
arch/arm/mach-omap2/board-cm-t3517.c
arch/arm/mach-omap2/board-devkit8000.c
arch/arm/mach-omap2/board-igep0020.c
arch/arm/mach-omap2/board-igep0030.c [deleted file]
arch/arm/mach-omap2/board-ldp.c
arch/arm/mach-omap2/board-n8x0.c
arch/arm/mach-omap2/board-omap3beagle.c
arch/arm/mach-omap2/board-omap3evm.c
arch/arm/mach-omap2/board-omap3logic.c
arch/arm/mach-omap2/board-omap3pandora.c
arch/arm/mach-omap2/board-omap3stalker.c
arch/arm/mach-omap2/board-omap3touchbook.c
arch/arm/mach-omap2/board-omap4panda.c
arch/arm/mach-omap2/board-overo.c
arch/arm/mach-omap2/board-rm680.c
arch/arm/mach-omap2/board-rx51-peripherals.c
arch/arm/mach-omap2/board-rx51-video.c
arch/arm/mach-omap2/board-rx51.c
arch/arm/mach-omap2/board-zoom-debugboard.c
arch/arm/mach-omap2/board-zoom-display.c
arch/arm/mach-omap2/board-zoom-peripherals.c
arch/arm/mach-omap2/common-board-devices.c [new file with mode: 0644]
arch/arm/mach-omap2/common-board-devices.h [new file with mode: 0644]
arch/arm/mach-omap2/cpuidle34xx.c
arch/arm/mach-omap2/gpmc-smc91x.c
arch/arm/mach-omap2/gpmc-smsc911x.c
arch/arm/mach-omap2/omap_l3_noc.c
arch/arm/mach-omap2/omap_l3_smx.c
arch/arm/mach-omap2/omap_phy_internal.c
arch/arm/mach-omap2/pm.h
arch/arm/mach-omap2/pm34xx.c
arch/arm/mach-omap2/pm44xx.c
arch/arm/mach-omap2/smartreflex.c
arch/arm/mach-omap2/usb-musb.c
arch/arm/mach-omap2/usb-tusb6010.c
arch/arm/mach-omap2/voltage.c
arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
arch/arm/plat-omap/include/plat/uncompress.h
arch/arm/plat-omap/include/plat/usb.h
arch/ia64/kernel/time.c
arch/powerpc/Kconfig
arch/powerpc/boot/dts/canyonlands.dts
arch/powerpc/boot/dts/katmai.dts
arch/powerpc/boot/dts/kilauea.dts
arch/powerpc/boot/dts/redwood.dts
arch/powerpc/include/asm/ftrace.h
arch/powerpc/include/asm/hvcall.h
arch/powerpc/include/asm/smp.h
arch/powerpc/include/asm/syscall.h
arch/powerpc/include/asm/thread_info.h
arch/powerpc/kernel/Makefile
arch/powerpc/kernel/ftrace.c
arch/powerpc/kernel/irq.c
arch/powerpc/kernel/ptrace.c
arch/powerpc/kernel/smp.c
arch/powerpc/oprofile/op_model_power4.c
arch/powerpc/platforms/40x/Kconfig
arch/powerpc/platforms/44x/Kconfig
arch/powerpc/platforms/cell/interrupt.c
arch/powerpc/platforms/cell/interrupt.h
arch/powerpc/platforms/cell/smp.c
arch/powerpc/sysdev/Kconfig
arch/powerpc/sysdev/Makefile
arch/powerpc/sysdev/ppc4xx_msi.c [new file with mode: 0644]
arch/x86/include/asm/xen/hypercall.h
arch/x86/kernel/vsyscall_64.c
drivers/dma/timb_dma.c
drivers/gpio/Kconfig
drivers/gpio/Makefile
drivers/gpio/basic_mmio_gpio.c
drivers/gpio/gpiolib.c
drivers/gpio/janz-ttl.c
drivers/gpio/pca953x.c
drivers/gpio/rdc321x-gpio.c
drivers/gpio/timbgpio.c
drivers/i2c/busses/i2c-ocores.c
drivers/i2c/busses/i2c-xiic.c
drivers/infiniband/Kconfig
drivers/infiniband/core/Makefile
drivers/infiniband/core/cm.c
drivers/infiniband/core/cma.c
drivers/infiniband/core/device.c
drivers/infiniband/core/mad.c
drivers/infiniband/core/netlink.c [new file with mode: 0644]
drivers/infiniband/core/ucma.c
drivers/infiniband/core/user_mad.c
drivers/infiniband/core/uverbs_main.c
drivers/infiniband/hw/cxgb3/iwch_cm.c
drivers/infiniband/hw/cxgb3/iwch_provider.h
drivers/infiniband/hw/cxgb3/iwch_qp.c
drivers/infiniband/hw/cxgb4/iw_cxgb4.h
drivers/infiniband/hw/nes/nes.c
drivers/infiniband/hw/qib/Kconfig
drivers/infiniband/ulp/iser/iser_verbs.c
drivers/infiniband/ulp/srp/ib_srp.c
drivers/input/keyboard/Kconfig
drivers/input/keyboard/Makefile
drivers/input/keyboard/pmic8xxx-keypad.c [new file with mode: 0644]
drivers/input/misc/Kconfig
drivers/input/misc/Makefile
drivers/input/misc/pmic8xxx-pwrkey.c [new file with mode: 0644]
drivers/input/misc/twl4030-vibra.c
drivers/leds/Kconfig
drivers/leds/Makefile
drivers/leds/leds-88pm860x.c
drivers/leds/leds-asic3.c [new file with mode: 0644]
drivers/leds/leds-mc13783.c
drivers/media/radio/radio-timb.c
drivers/media/radio/radio-wl1273.c
drivers/media/video/timblogiw.c
drivers/mfd/88pm860x-core.c
drivers/mfd/Kconfig
drivers/mfd/Makefile
drivers/mfd/ab3100-core.c
drivers/mfd/ab3550-core.c
drivers/mfd/ab8500-core.c
drivers/mfd/ab8500-gpadc.c
drivers/mfd/asic3.c
drivers/mfd/davinci_voicecodec.c
drivers/mfd/htc-pasic3.c
drivers/mfd/janz-cmodio.c
drivers/mfd/max8925-core.c
drivers/mfd/mc13xxx-core.c
drivers/mfd/mfd-core.c
drivers/mfd/omap-usb-host.c
drivers/mfd/pm8921-core.c [new file with mode: 0644]
drivers/mfd/pm8xxx-irq.c [new file with mode: 0644]
drivers/mfd/rdc321x-southbridge.c
drivers/mfd/t7l66xb.c
drivers/mfd/tc6387xb.c
drivers/mfd/tc6393xb.c
drivers/mfd/timberdale.c
drivers/mfd/tps6105x.c
drivers/mfd/tps6586x.c
drivers/mfd/twl-core.c
drivers/mfd/twl4030-codec.c
drivers/mfd/twl4030-power.c
drivers/mfd/twl6030-irq.c
drivers/mfd/wl1273-core.c
drivers/mfd/wm831x-core.c
drivers/mfd/wm831x-irq.c
drivers/mfd/wm8400-core.c
drivers/mmc/host/tmio_mmc.c
drivers/mtd/nand/tmio_nand.c
drivers/net/can/janz-ican3.c
drivers/net/ks8842.c
drivers/power/max8925_power.c
drivers/regulator/88pm8607.c
drivers/regulator/ab3100.c
drivers/regulator/db8500-prcmu.c
drivers/regulator/max8925-regulator.c
drivers/regulator/mc13783-regulator.c
drivers/regulator/mc13892-regulator.c
drivers/regulator/tps6105x-regulator.c
drivers/rtc/Kconfig
drivers/rtc/Makefile
drivers/rtc/rtc-88pm860x.c [new file with mode: 0644]
drivers/spi/Kconfig
drivers/spi/amba-pl022.c
drivers/spi/dw_spi.c
drivers/spi/dw_spi.h
drivers/spi/spi.c
drivers/spi/spi_nuc900.c
drivers/spi/spi_s3c24xx.c
drivers/spi/spi_sh.c
drivers/spi/spi_tegra.c
drivers/spi/xilinx_spi.c
drivers/video/backlight/88pm860x_bl.c
drivers/video/omap/Makefile
drivers/video/omap/lcd_omap2evm.c [deleted file]
drivers/video/tmiofb.c
drivers/video/via/via-gpio.c
drivers/w1/masters/ds1wm.c
drivers/watchdog/rdc321x_wdt.c
drivers/xen/Makefile
drivers/xen/tmem.c [new file with mode: 0644]
fs/9p/vfs_inode.c
fs/Kconfig
fs/affs/namei.c
fs/afs/dir.c
fs/autofs4/root.c
fs/bfs/dir.c
fs/btrfs/extent_io.c
fs/btrfs/super.c
fs/buffer.c
fs/coda/dir.c
fs/configfs/dir.c
fs/ecryptfs/inode.c
fs/ext3/super.c
fs/ext4/Makefile
fs/ext4/balloc.c
fs/ext4/ext4.h
fs/ext4/ext4_jbd2.c
fs/ext4/ext4_jbd2.h
fs/ext4/extents.c
fs/ext4/file.c
fs/ext4/fsync.c
fs/ext4/inode.c
fs/ext4/mballoc.c
fs/ext4/mballoc.h
fs/ext4/migrate.c
fs/ext4/mmp.c [new file with mode: 0644]
fs/ext4/move_extent.c
fs/ext4/namei.c
fs/ext4/page-io.c
fs/ext4/super.c
fs/ext4/xattr.c
fs/fat/namei_msdos.c
fs/fat/namei_vfat.c
fs/fuse/dir.c
fs/hfs/dir.c
fs/hfsplus/dir.c
fs/hostfs/hostfs_kern.c
fs/hpfs/namei.c
fs/hugetlbfs/inode.c
fs/jbd2/commit.c
fs/jbd2/journal.c
fs/jbd2/transaction.c
fs/jffs2/dir.c
fs/jfs/namei.c
fs/logfs/dir.c
fs/minix/namei.c
fs/mpage.c
fs/namei.c
fs/namespace.c
fs/ncpfs/dir.c
fs/nilfs2/namei.c
fs/ocfs2/Makefile
fs/ocfs2/alloc.c
fs/ocfs2/alloc.h
fs/ocfs2/cluster/sys.c
fs/ocfs2/dlm/dlmcommon.h
fs/ocfs2/dlm/dlmdebug.c
fs/ocfs2/dlm/dlmdomain.c
fs/ocfs2/dlm/dlmmaster.c
fs/ocfs2/dlm/dlmrecovery.c
fs/ocfs2/dlmfs/dlmfs.c
fs/ocfs2/file.c
fs/ocfs2/ioctl.c
fs/ocfs2/move_extents.c [new file with mode: 0644]
fs/ocfs2/move_extents.h [new file with mode: 0644]
fs/ocfs2/ocfs2_ioctl.h
fs/ocfs2/ocfs2_trace.h
fs/ocfs2/refcounttree.c
fs/ocfs2/refcounttree.h
fs/ocfs2/super.c
fs/omfs/dir.c
fs/proc/task_mmu.c
fs/reiserfs/namei.c
fs/reiserfs/xattr.c
fs/super.c
fs/sysv/namei.c
fs/ubifs/dir.c
fs/udf/namei.c
fs/ufs/namei.c
fs/xfs/linux-2.6/xfs_discard.c
fs/xfs/linux-2.6/xfs_discard.h
fs/xfs/linux-2.6/xfs_super.c
fs/xfs/xfs_ag.h
fs/xfs/xfs_alloc.c
fs/xfs/xfs_alloc.h
fs/xfs/xfs_alloc_btree.c
fs/xfs/xfs_bmap.c
fs/xfs/xfs_bmap.h
fs/xfs/xfs_inode.c
fs/xfs/xfs_inode.h
fs/xfs/xfs_log_cil.c
fs/xfs/xfs_mount.h
fs/xfs/xfs_trans.c
include/linux/basic_mmio_gpio.h
include/linux/buffer_head.h
include/linux/cleancache.h [new file with mode: 0644]
include/linux/fs.h
include/linux/hugetlb.h
include/linux/hugetlb_inline.h
include/linux/i2c/twl.h
include/linux/input/pmic8xxx-keypad.h [new file with mode: 0644]
include/linux/input/pmic8xxx-pwrkey.h [new file with mode: 0644]
include/linux/jbd2.h
include/linux/mfd/88pm860x.h
include/linux/mfd/abx500.h
include/linux/mfd/asic3.h
include/linux/mfd/core.h
include/linux/mfd/pm8xxx/core.h [new file with mode: 0644]
include/linux/mfd/pm8xxx/irq.h [new file with mode: 0644]
include/linux/mfd/pm8xxx/pm8921.h [new file with mode: 0644]
include/linux/mfd/twl4030-codec.h
include/linux/mfd/wm831x/core.h
include/linux/mfd/wm831x/pdata.h
include/linux/mm.h
include/linux/mm_types.h
include/linux/netlink.h
include/linux/seqlock.h
include/linux/smp.h
include/linux/spi/spi.h
include/rdma/Kbuild
include/rdma/ib_user_cm.h
include/rdma/rdma_cm.h
include/rdma/rdma_netlink.h [new file with mode: 0644]
include/trace/events/gpio.h [new file with mode: 0644]
include/xen/interface/xen.h
ipc/shm.c
mm/Kconfig
mm/Makefile
mm/cleancache.c [new file with mode: 0644]
mm/filemap.c
mm/fremap.c
mm/hugetlb.c
mm/memory.c
mm/mlock.c
mm/mmap.c
mm/truncate.c
net/9p/trans_rdma.c
net/ipv4/inet_connection_sock.c
net/rds/ib.c
net/rds/ib_cm.c
net/rds/iw.c
net/rds/iw_cm.c
net/rds/rdma_transport.c
net/sunrpc/xprtrdma/svc_rdma_transport.c
net/sunrpc/xprtrdma/verbs.c
sound/soc/codecs/cq93vc.c
sound/soc/codecs/twl4030.c
sound/soc/codecs/wl1273.c
sound/soc/codecs/wm8400.c
sound/soc/davinci/davinci-vcif.c
sound/soc/omap/Kconfig
sound/soc/omap/Makefile
sound/soc/omap/omap2evm.c [deleted file]

similarity index 65%
rename from Documentation/ABI/obsolete/o2cb
rename to Documentation/ABI/removed/o2cb
index 9c49d8e..7f5daa4 100644 (file)
@@ -1,11 +1,10 @@
 What:          /sys/o2cb symlink
-Date:          Dec 2005
-KernelVersion: 2.6.16
+Date:          May 2011
+KernelVersion: 2.6.40
 Contact:       ocfs2-devel@oss.oracle.com
-Description:   This is a symlink: /sys/o2cb to /sys/fs/o2cb. The symlink will
-               be removed when new versions of ocfs2-tools which know to look
+Description:   This is a symlink: /sys/o2cb to /sys/fs/o2cb. The symlink is
+               removed when new versions of ocfs2-tools which know to look
                in /sys/fs/o2cb are sufficiently prevalent. Don't code new
                software to look here, it should try /sys/fs/o2cb instead.
-               See Documentation/ABI/stable/o2cb for more information on usage.
 Users:         ocfs2-tools. It's sufficient to mail proposed changes to
                ocfs2-devel@oss.oracle.com.
diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-cleancache b/Documentation/ABI/testing/sysfs-kernel-mm-cleancache
new file mode 100644 (file)
index 0000000..662ae64
--- /dev/null
@@ -0,0 +1,11 @@
+What:          /sys/kernel/mm/cleancache/
+Date:          April 2011
+Contact:       Dan Magenheimer <dan.magenheimer@oracle.com>
+Description:
+               /sys/kernel/mm/cleancache/ contains a number of files which
+               record a count of various cleancache operations
+               (sum across all filesystems):
+                       succ_gets
+                       failed_gets
+                       puts
+                       flushes
index 95788ad..ff31b1c 100644 (file)
@@ -262,16 +262,6 @@ Who:       Michael Buesch <mb@bu3sch.de>
 
 ---------------------------
 
-What:  /sys/o2cb symlink
-When:  January 2010
-Why:   /sys/fs/o2cb is the proper location for this information - /sys/o2cb
-       exists as a symlink for backwards compatibility for old versions of
-       ocfs2-tools. 2 years should be sufficient time to phase in new versions
-       which know to look in /sys/fs/o2cb.
-Who:   ocfs2-devel@oss.oracle.com
-
----------------------------
-
 What:  Ability for non root users to shm_get hugetlb pages based on mlock
        resource limits
 When:  2.6.31
index c79ec58..3ae9bc9 100644 (file)
@@ -226,10 +226,6 @@ acl                        Enables POSIX Access Control Lists support.
 noacl                  This option disables POSIX Access Control List
                        support.
 
-reservation
-
-noreservation
-
 bsddf          (*)     Make 'df' act like BSD.
 minixdf                        Make 'df' act like Minix.
 
index 9ed920a..7618a28 100644 (file)
@@ -46,9 +46,15 @@ errors=panic         Panic and halt the machine if an error occurs.
 intr           (*)     Allow signals to interrupt cluster operations.
 nointr                 Do not allow signals to interrupt cluster
                        operations.
+noatime                        Do not update access time.
+relatime(*)            Update atime if the previous atime is older than
+                       mtime or ctime
+strictatime            Always update atime, but the minimum update interval
+                       is specified by atime_quantum.
 atime_quantum=60(*)    OCFS2 will not update atime unless this number
                        of seconds has passed since the last update.
-                       Set to zero to always update atime.
+                       Set to zero to always update atime. This option need
+                       work with strictatime.
 data=ordered   (*)     All data are forced directly out to the main file
                        system prior to its metadata being committed to the
                        journal.
index 7bff3e4..3fc0c31 100644 (file)
@@ -39,6 +39,12 @@ When mounting an XFS filesystem, the following options are accepted.
        drive level write caching to be enabled, for devices that
        support write barriers.
 
+  discard
+       Issue command to let the block device reclaim space freed by the
+       filesystem.  This is useful for SSD devices, thinly provisioned
+       LUNs and virtual machine images, but may have a performance
+       impact.  This option is incompatible with the nodelaylog option.
+
   dmapi
        Enable the DMAPI (Data Management API) event callouts.
        Use with the "mtpt" option.
diff --git a/Documentation/vm/cleancache.txt b/Documentation/vm/cleancache.txt
new file mode 100644 (file)
index 0000000..36c367c
--- /dev/null
@@ -0,0 +1,278 @@
+MOTIVATION
+
+Cleancache is a new optional feature provided by the VFS layer that
+potentially dramatically increases page cache effectiveness for
+many workloads in many environments at a negligible cost.
+
+Cleancache can be thought of as a page-granularity victim cache for clean
+pages that the kernel's pageframe replacement algorithm (PFRA) would like
+to keep around, but can't since there isn't enough memory.  So when the
+PFRA "evicts" a page, it first attempts to use cleancache code to
+put the data contained in that page into "transcendent memory", memory
+that is not directly accessible or addressable by the kernel and is
+of unknown and possibly time-varying size.
+
+Later, when a cleancache-enabled filesystem wishes to access a page
+in a file on disk, it first checks cleancache to see if it already
+contains it; if it does, the page of data is copied into the kernel
+and a disk access is avoided.
+
+Transcendent memory "drivers" for cleancache are currently implemented
+in Xen (using hypervisor memory) and zcache (using in-kernel compressed
+memory) and other implementations are in development.
+
+FAQs are included below.
+
+IMPLEMENTATION OVERVIEW
+
+A cleancache "backend" that provides transcendent memory registers itself
+to the kernel's cleancache "frontend" by calling cleancache_register_ops,
+passing a pointer to a cleancache_ops structure with funcs set appropriately.
+Note that cleancache_register_ops returns the previous settings so that
+chaining can be performed if desired. The functions provided must conform to
+certain semantics as follows:
+
+Most important, cleancache is "ephemeral".  Pages which are copied into
+cleancache have an indefinite lifetime which is completely unknowable
+by the kernel and so may or may not still be in cleancache at any later time.
+Thus, as its name implies, cleancache is not suitable for dirty pages.
+Cleancache has complete discretion over what pages to preserve and what
+pages to discard and when.
+
+Mounting a cleancache-enabled filesystem should call "init_fs" to obtain a
+pool id which, if positive, must be saved in the filesystem's superblock;
+a negative return value indicates failure.  A "put_page" will copy a
+(presumably about-to-be-evicted) page into cleancache and associate it with
+the pool id, a file key, and a page index into the file.  (The combination
+of a pool id, a file key, and an index is sometimes called a "handle".)
+A "get_page" will copy the page, if found, from cleancache into kernel memory.
+A "flush_page" will ensure the page no longer is present in cleancache;
+a "flush_inode" will flush all pages associated with the specified file;
+and, when a filesystem is unmounted, a "flush_fs" will flush all pages in
+all files specified by the given pool id and also surrender the pool id.
+
+An "init_shared_fs", like init_fs, obtains a pool id but tells cleancache
+to treat the pool as shared using a 128-bit UUID as a key.  On systems
+that may run multiple kernels (such as hard partitioned or virtualized
+systems) that may share a clustered filesystem, and where cleancache
+may be shared among those kernels, calls to init_shared_fs that specify the
+same UUID will receive the same pool id, thus allowing the pages to
+be shared.  Note that any security requirements must be imposed outside
+of the kernel (e.g. by "tools" that control cleancache).  Or a
+cleancache implementation can simply disable shared_init by always
+returning a negative value.
+
+If a get_page is successful on a non-shared pool, the page is flushed (thus
+making cleancache an "exclusive" cache).  On a shared pool, the page
+is NOT flushed on a successful get_page so that it remains accessible to
+other sharers.  The kernel is responsible for ensuring coherency between
+cleancache (shared or not), the page cache, and the filesystem, using
+cleancache flush operations as required.
+
+Note that cleancache must enforce put-put-get coherency and get-get
+coherency.  For the former, if two puts are made to the same handle but
+with different data, say AAA by the first put and BBB by the second, a
+subsequent get can never return the stale data (AAA).  For get-get coherency,
+if a get for a given handle fails, subsequent gets for that handle will
+never succeed unless preceded by a successful put with that handle.
+
+Last, cleancache provides no SMP serialization guarantees; if two
+different Linux threads are simultaneously putting and flushing a page
+with the same handle, the results are indeterminate.  Callers must
+lock the page to ensure serial behavior.
+
+CLEANCACHE PERFORMANCE METRICS
+
+Cleancache monitoring is done by sysfs files in the
+/sys/kernel/mm/cleancache directory.  The effectiveness of cleancache
+can be measured (across all filesystems) with:
+
+succ_gets      - number of gets that were successful
+failed_gets    - number of gets that failed
+puts           - number of puts attempted (all "succeed")
+flushes                - number of flushes attempted
+
+A backend implementatation may provide additional metrics.
+
+FAQ
+
+1) Where's the value? (Andrew Morton)
+
+Cleancache provides a significant performance benefit to many workloads
+in many environments with negligible overhead by improving the
+effectiveness of the pagecache.  Clean pagecache pages are
+saved in transcendent memory (RAM that is otherwise not directly
+addressable to the kernel); fetching those pages later avoids "refaults"
+and thus disk reads.
+
+Cleancache (and its sister code "frontswap") provide interfaces for
+this transcendent memory (aka "tmem"), which conceptually lies between
+fast kernel-directly-addressable RAM and slower DMA/asynchronous devices.
+Disallowing direct kernel or userland reads/writes to tmem
+is ideal when data is transformed to a different form and size (such
+as with compression) or secretly moved (as might be useful for write-
+balancing for some RAM-like devices).  Evicted page-cache pages (and
+swap pages) are a great use for this kind of slower-than-RAM-but-much-
+faster-than-disk transcendent memory, and the cleancache (and frontswap)
+"page-object-oriented" specification provides a nice way to read and
+write -- and indirectly "name" -- the pages.
+
+In the virtual case, the whole point of virtualization is to statistically
+multiplex physical resources across the varying demands of multiple
+virtual machines.  This is really hard to do with RAM and efforts to
+do it well with no kernel change have essentially failed (except in some
+well-publicized special-case workloads).  Cleancache -- and frontswap --
+with a fairly small impact on the kernel, provide a huge amount
+of flexibility for more dynamic, flexible RAM multiplexing.
+Specifically, the Xen Transcendent Memory backend allows otherwise
+"fallow" hypervisor-owned RAM to not only be "time-shared" between multiple
+virtual machines, but the pages can be compressed and deduplicated to
+optimize RAM utilization.  And when guest OS's are induced to surrender
+underutilized RAM (e.g. with "self-ballooning"), page cache pages
+are the first to go, and cleancache allows those pages to be
+saved and reclaimed if overall host system memory conditions allow.
+
+And the identical interface used for cleancache can be used in
+physical systems as well.  The zcache driver acts as a memory-hungry
+device that stores pages of data in a compressed state.  And
+the proposed "RAMster" driver shares RAM across multiple physical
+systems.
+
+2) Why does cleancache have its sticky fingers so deep inside the
+   filesystems and VFS? (Andrew Morton and Christoph Hellwig)
+
+The core hooks for cleancache in VFS are in most cases a single line
+and the minimum set are placed precisely where needed to maintain
+coherency (via cleancache_flush operations) between cleancache,
+the page cache, and disk.  All hooks compile into nothingness if
+cleancache is config'ed off and turn into a function-pointer-
+compare-to-NULL if config'ed on but no backend claims the ops
+functions, or to a compare-struct-element-to-negative if a
+backend claims the ops functions but a filesystem doesn't enable
+cleancache.
+
+Some filesystems are built entirely on top of VFS and the hooks
+in VFS are sufficient, so don't require an "init_fs" hook; the
+initial implementation of cleancache didn't provide this hook.
+But for some filesystems (such as btrfs), the VFS hooks are
+incomplete and one or more hooks in fs-specific code are required.
+And for some other filesystems, such as tmpfs, cleancache may
+be counterproductive.  So it seemed prudent to require a filesystem
+to "opt in" to use cleancache, which requires adding a hook in
+each filesystem.  Not all filesystems are supported by cleancache
+only because they haven't been tested.  The existing set should
+be sufficient to validate the concept, the opt-in approach means
+that untested filesystems are not affected, and the hooks in the
+existing filesystems should make it very easy to add more
+filesystems in the future.
+
+The total impact of the hooks to existing fs and mm files is only
+about 40 lines added (not counting comments and blank lines).
+
+3) Why not make cleancache asynchronous and batched so it can
+   more easily interface with real devices with DMA instead
+   of copying each individual page? (Minchan Kim)
+
+The one-page-at-a-time copy semantics simplifies the implementation
+on both the frontend and backend and also allows the backend to
+do fancy things on-the-fly like page compression and
+page deduplication.  And since the data is "gone" (copied into/out
+of the pageframe) before the cleancache get/put call returns,
+a great deal of race conditions and potential coherency issues
+are avoided.  While the interface seems odd for a "real device"
+or for real kernel-addressable RAM, it makes perfect sense for
+transcendent memory.
+
+4) Why is non-shared cleancache "exclusive"?  And where is the
+   page "flushed" after a "get"? (Minchan Kim)
+
+The main reason is to free up space in transcendent memory and
+to avoid unnecessary cleancache_flush calls.  If you want inclusive,
+the page can be "put" immediately following the "get".  If
+put-after-get for inclusive becomes common, the interface could
+be easily extended to add a "get_no_flush" call.
+
+The flush is done by the cleancache backend implementation.
+
+5) What's the performance impact?
+
+Performance analysis has been presented at OLS'09 and LCA'10.
+Briefly, performance gains can be significant on most workloads,
+especially when memory pressure is high (e.g. when RAM is
+overcommitted in a virtual workload); and because the hooks are
+invoked primarily in place of or in addition to a disk read/write,
+overhead is negligible even in worst case workloads.  Basically
+cleancache replaces I/O with memory-copy-CPU-overhead; on older
+single-core systems with slow memory-copy speeds, cleancache
+has little value, but in newer multicore machines, especially
+consolidated/virtualized machines, it has great value.
+
+6) How do I add cleancache support for filesystem X? (Boaz Harrash)
+
+Filesystems that are well-behaved and conform to certain
+restrictions can utilize cleancache simply by making a call to
+cleancache_init_fs at mount time.  Unusual, misbehaving, or
+poorly layered filesystems must either add additional hooks
+and/or undergo extensive additional testing... or should just
+not enable the optional cleancache.
+
+Some points for a filesystem to consider:
+
+- The FS should be block-device-based (e.g. a ram-based FS such
+  as tmpfs should not enable cleancache)
+- To ensure coherency/correctness, the FS must ensure that all
+  file removal or truncation operations either go through VFS or
+  add hooks to do the equivalent cleancache "flush" operations
+- To ensure coherency/correctness, either inode numbers must
+  be unique across the lifetime of the on-disk file OR the
+  FS must provide an "encode_fh" function.
+- The FS must call the VFS superblock alloc and deactivate routines
+  or add hooks to do the equivalent cleancache calls done there.
+- To maximize performance, all pages fetched from the FS should
+  go through the do_mpag_readpage routine or the FS should add
+  hooks to do the equivalent (cf. btrfs)
+- Currently, the FS blocksize must be the same as PAGESIZE.  This
+  is not an architectural restriction, but no backends currently
+  support anything different.
+- A clustered FS should invoke the "shared_init_fs" cleancache
+  hook to get best performance for some backends.
+
+7) Why not use the KVA of the inode as the key? (Christoph Hellwig)
+
+If cleancache would use the inode virtual address instead of
+inode/filehandle, the pool id could be eliminated.  But, this
+won't work because cleancache retains pagecache data pages
+persistently even when the inode has been pruned from the
+inode unused list, and only flushes the data page if the file
+gets removed/truncated.  So if cleancache used the inode kva,
+there would be potential coherency issues if/when the inode
+kva is reused for a different file.  Alternately, if cleancache
+flushed the pages when the inode kva was freed, much of the value
+of cleancache would be lost because the cache of pages in cleanache
+is potentially much larger than the kernel pagecache and is most
+useful if the pages survive inode cache removal.
+
+8) Why is a global variable required?
+
+The cleancache_enabled flag is checked in all of the frequently-used
+cleancache hooks.  The alternative is a function call to check a static
+variable. Since cleancache is enabled dynamically at runtime, systems
+that don't enable cleancache would suffer thousands (possibly
+tens-of-thousands) of unnecessary function calls per second.  So the
+global variable allows cleancache to be enabled by default at compile
+time, but have insignificant performance impact when cleancache remains
+disabled at runtime.
+
+9) Does cleanache work with KVM?
+
+The memory model of KVM is sufficiently different that a cleancache
+backend may have less value for KVM.  This remains to be tested,
+especially in an overcommitted system.
+
+10) Does cleancache work in userspace?  It sounds useful for
+   memory hungry caches like web browsers.  (Jamie Lokier)
+
+No plans yet, though we agree it sounds useful, at least for
+apps that bypass the page cache (e.g. O_DIRECT).
+
+Last updated: Dan Magenheimer, April 13 2011
index 1ab17de..21a871c 100644 (file)
@@ -931,6 +931,8 @@ F:  drivers/mmc/host/msm_sdcc.h
 F:     drivers/tty/serial/msm_serial.h
 F:     drivers/tty/serial/msm_serial.c
 F:     drivers/platform/msm/
+F:     drivers/*/pm8???-*
+F:     include/linux/mfd/pm8xxx/
 T:     git git://codeaurora.org/quic/kernel/davidb/linux-msm.git
 S:     Maintained
 
@@ -3572,9 +3574,16 @@ M:       Andrew Morton <akpm@linux-foundation.org>
 M:     Jan Kara <jack@suse.cz>
 L:     linux-ext4@vger.kernel.org
 S:     Maintained
-F:     fs/jbd*/
-F:     include/linux/ext*jbd*.h
-F:     include/linux/jbd*.h
+F:     fs/jbd/
+F:     include/linux/ext3_jbd.h
+F:     include/linux/jbd.h
+
+JOURNALLING LAYER FOR BLOCK DEVICES (JBD2)
+M:     "Theodore Ts'o" <tytso@mit.edu>
+L:     linux-ext4@vger.kernel.org
+S:     Maintained
+F:     fs/jbd2/
+F:     include/linux/jbd2.h
 
 JSM Neo PCI based serial card
 M:     Breno Leitao <leitao@linux.vnet.ibm.com>
index 076db52..d5f00d7 100644 (file)
@@ -21,58 +21,22 @@ CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
 # CONFIG_BLK_DEV_BSG is not set
 CONFIG_ARCH_OMAP=y
-CONFIG_ARCH_OMAP2=y
-CONFIG_ARCH_OMAP3=y
-CONFIG_ARCH_OMAP4=y
 CONFIG_OMAP_RESET_CLOCKS=y
 CONFIG_OMAP_MUX_DEBUG=y
-CONFIG_OMAP_32K_TIMER=y
-CONFIG_MACH_OMAP_GENERIC=y
-CONFIG_ARCH_OMAP2420=y
-CONFIG_ARCH_OMAP2430=y
-CONFIG_ARCH_OMAP3430=y
-CONFIG_MACH_OMAP_H4=y
-CONFIG_MACH_OMAP_APOLLON=y
-CONFIG_MACH_OMAP_2430SDP=y
-CONFIG_MACH_OMAP3_BEAGLE=y
-CONFIG_MACH_DEVKIT8000=y
-CONFIG_MACH_OMAP_LDP=y
-CONFIG_MACH_OVERO=y
-CONFIG_MACH_OMAP3EVM=y
-CONFIG_MACH_OMAP3517EVM=y
-CONFIG_MACH_OMAP3_PANDORA=y
-CONFIG_MACH_OMAP3_TOUCHBOOK=y
-CONFIG_MACH_OMAP_3430SDP=y
-CONFIG_MACH_NOKIA_N8X0=y
-CONFIG_MACH_NOKIA_RX51=y
-CONFIG_MACH_OMAP_ZOOM2=y
-CONFIG_MACH_OMAP_ZOOM3=y
-CONFIG_MACH_CM_T35=y
-CONFIG_MACH_IGEP0020=y
-CONFIG_MACH_SBC3530=y
-CONFIG_MACH_OMAP_3630SDP=y
-CONFIG_MACH_OMAP_4430SDP=y
 CONFIG_ARM_THUMBEE=y
-CONFIG_ARM_L1_CACHE_SHIFT=5
 CONFIG_ARM_ERRATA_411920=y
 CONFIG_NO_HZ=y
 CONFIG_HIGH_RES_TIMERS=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=2
-# CONFIG_LOCAL_TIMERS is not set
-CONFIG_AEABI=y
 CONFIG_LEDS=y
 CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
 CONFIG_CMDLINE="root=/dev/mmcblk0p2 rootwait console=ttyO2,115200"
 CONFIG_KEXEC=y
 CONFIG_FPE_NWFPE=y
-CONFIG_VFP=y
-CONFIG_NEON=y
 CONFIG_BINFMT_MISC=y
-CONFIG_PM=y
 CONFIG_PM_DEBUG=y
-CONFIG_PM_RUNTIME=y
 CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
@@ -89,14 +53,6 @@ CONFIG_IP_PNP_RARP=y
 # CONFIG_IPV6 is not set
 CONFIG_NETFILTER=y
 CONFIG_BT=m
-CONFIG_BT_L2CAP=m
-CONFIG_BT_SCO=m
-CONFIG_BT_RFCOMM=y
-CONFIG_BT_RFCOMM_TTY=y
-CONFIG_BT_BNEP=m
-CONFIG_BT_BNEP_MC_FILTER=y
-CONFIG_BT_BNEP_PROTO_FILTER=y
-CONFIG_BT_HIDP=m
 CONFIG_BT_HCIUART=m
 CONFIG_BT_HCIUART_H4=y
 CONFIG_BT_HCIUART_BCSP=y
@@ -107,11 +63,9 @@ CONFIG_CFG80211=m
 CONFIG_MAC80211=m
 CONFIG_MAC80211_RC_PID=y
 CONFIG_MAC80211_RC_DEFAULT_PID=y
-CONFIG_MAC80211_LEDS=y
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
 CONFIG_CONNECTOR=y
 CONFIG_MTD=y
-CONFIG_MTD_CONCAT=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
@@ -127,7 +81,6 @@ CONFIG_MTD_UBI=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=16384
-CONFIG_EEPROM_LEGACY=y
 CONFIG_SCSI=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_SCSI_MULTI_LUN=y
@@ -158,19 +111,15 @@ CONFIG_TOUCHSCREEN_ADS7846=y
 CONFIG_INPUT_MISC=y
 CONFIG_INPUT_TWL4030_PWRBUTTON=y
 CONFIG_VT_HW_CONSOLE_BINDING=y
-CONFIG_SERIAL_8250=y
-CONFIG_SERIAL_8250_CONSOLE=y
+# CONFIG_LEGACY_PTYS is not set
 CONFIG_SERIAL_8250_NR_UARTS=32
 CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
 CONFIG_SERIAL_8250_DETECT_IRQ=y
 CONFIG_SERIAL_8250_RSA=y
-# CONFIG_LEGACY_PTYS is not set
 CONFIG_HW_RANDOM=y
-CONFIG_I2C=y
 CONFIG_I2C_CHARDEV=y
-CONFIG_I2C_OMAP=y
 CONFIG_SPI=y
 CONFIG_SPI_OMAP24XX=y
 CONFIG_DEBUG_GPIO=y
@@ -181,10 +130,6 @@ CONFIG_POWER_SUPPLY=y
 CONFIG_WATCHDOG=y
 CONFIG_OMAP_WATCHDOG=y
 CONFIG_TWL4030_WATCHDOG=y
-CONFIG_MENELAUS=y
-CONFIG_TWL4030_CORE=y
-CONFIG_TWL4030_POWER=y
-CONFIG_REGULATOR=y
 CONFIG_REGULATOR_TWL4030=y
 CONFIG_REGULATOR_TPS65023=y
 CONFIG_REGULATOR_TPS6507X=y
@@ -208,7 +153,6 @@ CONFIG_BACKLIGHT_LCD_SUPPORT=y
 CONFIG_LCD_CLASS_DEVICE=y
 CONFIG_LCD_PLATFORM=y
 CONFIG_DISPLAY_SUPPORT=y
-# CONFIG_VGA_CONSOLE is not set
 CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
 CONFIG_FONTS=y
@@ -217,25 +161,20 @@ CONFIG_FONT_8x16=y
 CONFIG_LOGO=y
 CONFIG_SOUND=m
 CONFIG_SND=m
-CONFIG_SND_MIXER_OSS=y
-CONFIG_SND_PCM_OSS=y
+CONFIG_SND_MIXER_OSS=m
+CONFIG_SND_PCM_OSS=m
 CONFIG_SND_VERBOSE_PRINTK=y
 CONFIG_SND_DEBUG=y
-CONFIG_SND_USB_AUDIO=y
-CONFIG_SND_SOC=y
-CONFIG_SND_OMAP_SOC=y
-CONFIG_SND_OMAP_SOC_OMAP3_PANDORA=y
+CONFIG_SND_USB_AUDIO=m
+CONFIG_SND_SOC=m
+CONFIG_SND_OMAP_SOC=m
+CONFIG_SND_OMAP_SOC_OMAP3_PANDORA=m
 CONFIG_USB=y
 CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_DEVICEFS=y
 CONFIG_USB_SUSPEND=y
-# CONFIG_USB_OTG_WHITELIST is not set
 CONFIG_USB_MON=y
-# CONFIG_USB_MUSB_HDRC is not set
-# CONFIG_USB_MUSB_OTG is not set
-# CONFIG_USB_GADGET_MUSB_HDRC is not set
-CONFIG_USB_MUSB_DEBUG=y
 CONFIG_USB_WDM=y
 CONFIG_USB_STORAGE=y
 CONFIG_USB_LIBUSUAL=y
@@ -250,18 +189,12 @@ CONFIG_MMC_UNSAFE_RESUME=y
 CONFIG_SDIO_UART=y
 CONFIG_MMC_OMAP=y
 CONFIG_MMC_OMAP_HS=y
-CONFIG_LEDS_CLASS=y
-CONFIG_LEDS_GPIO=y
-CONFIG_LEDS_TRIGGER_TIMER=y
-CONFIG_LEDS_TRIGGER_HEARTBEAT=y
-CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
 CONFIG_RTC_CLASS=y
 CONFIG_RTC_DRV_TWL92330=y
 CONFIG_RTC_DRV_TWL4030=y
 CONFIG_EXT2_FS=y
 CONFIG_EXT3_FS=y
 # CONFIG_EXT3_FS_XATTR is not set
-CONFIG_INOTIFY=y
 CONFIG_QUOTA=y
 CONFIG_QFMT_V2=y
 CONFIG_MSDOS_FS=y
@@ -285,12 +218,10 @@ CONFIG_NLS_CODEPAGE_437=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_PRINTK_TIME=y
 CONFIG_MAGIC_SYSRQ=y
-CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_SCHEDSTATS=y
 CONFIG_TIMER_STATS=y
 CONFIG_PROVE_LOCKING=y
-# CONFIG_LOCK_STAT is not set
 CONFIG_DEBUG_SPINLOCK_SLEEP=y
 # CONFIG_DEBUG_BUGVERBOSE is not set
 CONFIG_DEBUG_INFO=y
index b997a35..19d5891 100644 (file)
@@ -288,6 +288,7 @@ config MACH_IGEP0030
        depends on ARCH_OMAP3
        default y
        select OMAP_PACKAGE_CBB
+       select MACH_IGEP0020
 
 config MACH_SBC3530
        bool "OMAP3 SBC STALKER board"
index 66dfbcc..b148077 100644 (file)
@@ -229,8 +229,6 @@ obj-$(CONFIG_MACH_CM_T35)           += board-cm-t35.o \
 obj-$(CONFIG_MACH_CM_T3517)            += board-cm-t3517.o
 obj-$(CONFIG_MACH_IGEP0020)            += board-igep0020.o \
                                           hsmmc.o
-obj-$(CONFIG_MACH_IGEP0030)            += board-igep0030.o \
-                                          hsmmc.o
 obj-$(CONFIG_MACH_OMAP3_TOUCHBOOK)     += board-omap3touchbook.o \
                                           hsmmc.o
 obj-$(CONFIG_MACH_OMAP_4430SDP)                += board-4430sdp.o \
@@ -270,3 +268,5 @@ obj-$(CONFIG_ARCH_OMAP4)            += hwspinlock.o
 
 disp-$(CONFIG_OMAP2_DSS)               := display.o
 obj-y                                  += $(disp-m) $(disp-y)
+
+obj-y                                  += common-board-devices.o
index 1fa6bb8..d54969b 100644 (file)
@@ -41,6 +41,7 @@
 
 #include "mux.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define SDP2430_CS0_BASE       0x04000000
 #define SECONDARY_LCD_GPIO             147
@@ -180,15 +181,6 @@ static struct twl4030_platform_data sdp2430_twldata = {
        .vmmc1          = &sdp2430_vmmc1,
 };
 
-static struct i2c_board_info __initdata sdp2430_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_24XX_SYS_NIRQ,
-               .platform_data = &sdp2430_twldata,
-       },
-};
-
 static struct i2c_board_info __initdata sdp2430_i2c1_boardinfo[] = {
        {
                I2C_BOARD_INFO("isp1301_omap", 0x2D),
@@ -201,8 +193,7 @@ static int __init omap2430_i2c_init(void)
 {
        omap_register_i2c_bus(1, 100, sdp2430_i2c1_boardinfo,
                        ARRAY_SIZE(sdp2430_i2c1_boardinfo));
-       omap_register_i2c_bus(2, 2600, sdp2430_i2c_boardinfo,
-                       ARRAY_SIZE(sdp2430_i2c_boardinfo));
+       omap2_pmic_init("twl4030", &sdp2430_twldata);
        return 0;
 }
 
@@ -217,11 +208,6 @@ static struct omap2_hsmmc_info mmc[] __initdata = {
        {}      /* Terminator */
 };
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
 static struct omap_usb_config sdp2430_usb_config __initdata = {
        .otg            = 1,
 #ifdef  CONFIG_USB_GADGET_OMAP
@@ -240,8 +226,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 
 static void __init omap_2430sdp_init(void)
 {
-       int ret;
-
        omap2430_mux_init(board_mux, OMAP_PACKAGE_ZAC);
 
        omap_board_config = sdp2430_config;
@@ -255,14 +239,13 @@ static void __init omap_2430sdp_init(void)
        omap2_usbfs_init(&sdp2430_usb_config);
 
        omap_mux_init_signal("usb0hs_stp", OMAP_PULL_ENA | OMAP_PULL_UP);
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
 
        board_smc91x_init();
 
        /* Turn off secondary LCD backlight */
-       ret = gpio_request(SECONDARY_LCD_GPIO, "Secondary LCD backlight");
-       if (ret == 0)
-               gpio_direction_output(SECONDARY_LCD_GPIO, 0);
+       gpio_request_one(SECONDARY_LCD_GPIO, GPIOF_OUT_INIT_LOW,
+                        "Secondary LCD backlight");
 }
 
 static void __init omap_2430sdp_map_io(void)
index 23244cd..ae2963a 100644 (file)
@@ -19,7 +19,6 @@
 #include <linux/input.h>
 #include <linux/input/matrix_keypad.h>
 #include <linux/spi/spi.h>
-#include <linux/spi/ads7846.h>
 #include <linux/i2c/twl.h>
 #include <linux/regulator/machine.h>
 #include <linux/io.h>
@@ -48,6 +47,7 @@
 #include "hsmmc.h"
 #include "pm.h"
 #include "control.h"
+#include "common-board-devices.h"
 
 #define CONFIG_DISABLE_HFCLK 1
 
 
 #define TWL4030_MSECURE_GPIO 22
 
-/* FIXME: These values need to be updated based on more profiling on 3430sdp*/
-static struct cpuidle_params omap3_cpuidle_params_table[] = {
-       /* C1 */
-       {1, 2, 2, 5},
-       /* C2 */
-       {1, 10, 10, 30},
-       /* C3 */
-       {1, 50, 50, 300},
-       /* C4 */
-       {1, 1500, 1800, 4000},
-       /* C5 */
-       {1, 2500, 7500, 12000},
-       /* C6 */
-       {1, 3000, 8500, 15000},
-       /* C7 */
-       {1, 10000, 30000, 300000},
-};
-
 static uint32_t board_keymap[] = {
        KEY(0, 0, KEY_LEFT),
        KEY(0, 1, KEY_RIGHT),
@@ -123,63 +105,14 @@ static struct twl4030_keypad_data sdp3430_kp_data = {
        .rep            = 1,
 };
 
-static int ts_gpio;    /* Needed for ads7846_get_pendown_state */
-
-/**
- * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
- *
- * @return - void. If request gpio fails then Flag KERN_ERR.
- */
-static void ads7846_dev_init(void)
-{
-       if (gpio_request(ts_gpio, "ADS7846 pendown") < 0) {
-               printk(KERN_ERR "can't get ads746 pen down GPIO\n");
-               return;
-       }
-
-       gpio_direction_input(ts_gpio);
-       gpio_set_debounce(ts_gpio, 310);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(ts_gpio);
-}
-
-static struct ads7846_platform_data tsc2046_config __initdata = {
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-       .wakeup                         = true,
-};
-
-
-static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info sdp3430_spi_board_info[] __initdata = {
-       [0] = {
-               /*
-                * TSC2046 operates at a max freqency of 2MHz, so
-                * operate slightly below at 1.5MHz
-                */
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &tsc2046_mcspi_config,
-               .irq                    = 0,
-               .platform_data          = &tsc2046_config,
-       },
-};
-
-
 #define SDP3430_LCD_PANEL_BACKLIGHT_GPIO       8
 #define SDP3430_LCD_PANEL_ENABLE_GPIO          5
 
-static unsigned backlight_gpio;
-static unsigned enable_gpio;
+static struct gpio sdp3430_dss_gpios[] __initdata = {
+       {SDP3430_LCD_PANEL_ENABLE_GPIO,    GPIOF_OUT_INIT_LOW, "LCD reset"    },
+       {SDP3430_LCD_PANEL_BACKLIGHT_GPIO, GPIOF_OUT_INIT_LOW, "LCD Backlight"},
+};
+
 static int lcd_enabled;
 static int dvi_enabled;
 
@@ -187,29 +120,11 @@ static void __init sdp3430_display_init(void)
 {
        int r;
 
-       enable_gpio    = SDP3430_LCD_PANEL_ENABLE_GPIO;
-       backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
-
-       r = gpio_request(enable_gpio, "LCD reset");
-       if (r) {
-               printk(KERN_ERR "failed to get LCD reset GPIO\n");
-               goto err0;
-       }
-
-       r = gpio_request(backlight_gpio, "LCD Backlight");
-       if (r) {
-               printk(KERN_ERR "failed to get LCD backlight GPIO\n");
-               goto err1;
-       }
-
-       gpio_direction_output(enable_gpio, 0);
-       gpio_direction_output(backlight_gpio, 0);
+       r = gpio_request_array(sdp3430_dss_gpios,
+                              ARRAY_SIZE(sdp3430_dss_gpios));
+       if (r)
+               printk(KERN_ERR "failed to get LCD control GPIOs\n");
 
-       return;
-err1:
-       gpio_free(enable_gpio);
-err0:
-       return;
 }
 
 static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
@@ -219,8 +134,8 @@ static int sdp3430_panel_enable_lcd(struct omap_dss_device *dssdev)
                return -EINVAL;
        }
 
-       gpio_direction_output(enable_gpio, 1);
-       gpio_direction_output(backlight_gpio, 1);
+       gpio_direction_output(SDP3430_LCD_PANEL_ENABLE_GPIO, 1);
+       gpio_direction_output(SDP3430_LCD_PANEL_BACKLIGHT_GPIO, 1);
 
        lcd_enabled = 1;
 
@@ -231,8 +146,8 @@ static void sdp3430_panel_disable_lcd(struct omap_dss_device *dssdev)
 {
        lcd_enabled = 0;
 
-       gpio_direction_output(enable_gpio, 0);
-       gpio_direction_output(backlight_gpio, 0);
+       gpio_direction_output(SDP3430_LCD_PANEL_ENABLE_GPIO, 0);
+       gpio_direction_output(SDP3430_LCD_PANEL_BACKLIGHT_GPIO, 0);
 }
 
 static int sdp3430_panel_enable_dvi(struct omap_dss_device *dssdev)
@@ -360,12 +275,10 @@ static int sdp3430_twl_gpio_setup(struct device *dev,
        omap2_hsmmc_init(mmc);
 
        /* gpio + 7 is "sub_lcd_en_bkl" (output/PWM1) */
-       gpio_request(gpio + 7, "sub_lcd_en_bkl");
-       gpio_direction_output(gpio + 7, 0);
+       gpio_request_one(gpio + 7, GPIOF_OUT_INIT_LOW, "sub_lcd_en_bkl");
 
        /* gpio + 15 is "sub_lcd_nRST" (output) */
-       gpio_request(gpio + 15, "sub_lcd_nRST");
-       gpio_direction_output(gpio + 15, 0);
+       gpio_request_one(gpio + 15, GPIOF_OUT_INIT_LOW, "sub_lcd_nRST");
 
        return 0;
 }
@@ -580,20 +493,10 @@ static struct twl4030_platform_data sdp3430_twldata = {
        .vpll2          = &sdp3430_vpll2,
 };
 
-static struct i2c_board_info __initdata sdp3430_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &sdp3430_twldata,
-       },
-};
-
 static int __init omap3430_i2c_init(void)
 {
        /* i2c1 for PMIC only */
-       omap_register_i2c_bus(1, 2600, sdp3430_i2c_boardinfo,
-                       ARRAY_SIZE(sdp3430_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &sdp3430_twldata);
        /* i2c2 on camera connector (for sensor control) and optional isp1301 */
        omap_register_i2c_bus(2, 400, NULL, 0);
        /* i2c3 on display connector (for DVI, tfp410) */
@@ -872,30 +775,22 @@ static struct flash_partitions sdp_flash_partitions[] = {
        },
 };
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static void __init omap_3430sdp_init(void)
 {
+       int gpio_pendown;
+
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
        omap_board_config = sdp3430_config;
        omap_board_config_size = ARRAY_SIZE(sdp3430_config);
-       omap3_pm_init_cpuidle(omap3_cpuidle_params_table);
        omap3430_i2c_init();
        omap_display_init(&sdp3430_dss_data);
        if (omap_rev() > OMAP3430_REV_ES1_0)
-               ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV2;
+               gpio_pendown = SDP3430_TS_GPIO_IRQ_SDPV2;
        else
-               ts_gpio = SDP3430_TS_GPIO_IRQ_SDPV1;
-       sdp3430_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
-       spi_register_board_info(sdp3430_spi_board_info,
-                               ARRAY_SIZE(sdp3430_spi_board_info));
-       ads7846_dev_init();
+               gpio_pendown = SDP3430_TS_GPIO_IRQ_SDPV1;
+       omap_ads7846_init(1, gpio_pendown, 310, NULL);
        board_serial_init();
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        board_smc91x_init();
        board_flash_init(sdp_flash_partitions, chip_sel_3430, 0);
        sdp3430_display_init();
index 93edd7f..73fa90b 100644 (file)
@@ -42,6 +42,7 @@
 #include "hsmmc.h"
 #include "timer-gp.h"
 #include "control.h"
+#include "common-board-devices.h"
 
 #define ETH_KS8851_IRQ                 34
 #define ETH_KS8851_POWER_ON            48
@@ -251,58 +252,22 @@ static struct spi_board_info sdp4430_spi_board_info[] __initdata = {
        },
 };
 
+static struct gpio sdp4430_eth_gpios[] __initdata = {
+       { ETH_KS8851_POWER_ON,  GPIOF_OUT_INIT_HIGH,    "eth_power"     },
+       { ETH_KS8851_QUART,     GPIOF_OUT_INIT_HIGH,    "quart"         },
+       { ETH_KS8851_IRQ,       GPIOF_IN,               "eth_irq"       },
+};
+
 static int omap_ethernet_init(void)
 {
        int status;
 
        /* Request of GPIO lines */
+       status = gpio_request_array(sdp4430_eth_gpios,
+                                   ARRAY_SIZE(sdp4430_eth_gpios));
+       if (status)
+               pr_err("Cannot request ETH GPIOs\n");
 
-       status = gpio_request(ETH_KS8851_POWER_ON, "eth_power");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", ETH_KS8851_POWER_ON);
-               return status;
-       }
-
-       status = gpio_request(ETH_KS8851_QUART, "quart");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", ETH_KS8851_QUART);
-               goto error1;
-       }
-
-       status = gpio_request(ETH_KS8851_IRQ, "eth_irq");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", ETH_KS8851_IRQ);
-               goto error2;
-       }
-
-       /* Configuration of requested GPIO lines */
-
-       status = gpio_direction_output(ETH_KS8851_POWER_ON, 1);
-       if (status) {
-               pr_err("Cannot set output GPIO %d\n", ETH_KS8851_IRQ);
-               goto error3;
-       }
-
-       status = gpio_direction_output(ETH_KS8851_QUART, 1);
-       if (status) {
-               pr_err("Cannot set output GPIO %d\n", ETH_KS8851_QUART);
-               goto error3;
-       }
-
-       status = gpio_direction_input(ETH_KS8851_IRQ);
-       if (status) {
-               pr_err("Cannot set input GPIO %d\n", ETH_KS8851_IRQ);
-               goto error3;
-       }
-
-       return 0;
-
-error3:
-       gpio_free(ETH_KS8851_IRQ);
-error2:
-       gpio_free(ETH_KS8851_QUART);
-error1:
-       gpio_free(ETH_KS8851_POWER_ON);
        return status;
 }
 
@@ -575,14 +540,6 @@ static struct twl4030_platform_data sdp4430_twldata = {
        .usb            = &omap4_usbphy_data
 };
 
-static struct i2c_board_info __initdata sdp4430_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl6030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = OMAP44XX_IRQ_SYS_1N,
-               .platform_data = &sdp4430_twldata,
-       },
-};
 static struct i2c_board_info __initdata sdp4430_i2c_3_boardinfo[] = {
        {
                I2C_BOARD_INFO("tmp105", 0x48),
@@ -598,12 +555,7 @@ static struct i2c_board_info __initdata sdp4430_i2c_4_boardinfo[] = {
 };
 static int __init omap4_i2c_init(void)
 {
-       /*
-        * Phoenix Audio IC needs I2C1 to
-        * start with 400 KHz or less
-        */
-       omap_register_i2c_bus(1, 400, sdp4430_i2c_boardinfo,
-                       ARRAY_SIZE(sdp4430_i2c_boardinfo));
+       omap4_pmic_init("twl6030", &sdp4430_twldata);
        omap_register_i2c_bus(2, 400, NULL, 0);
        omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
                                ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
@@ -614,21 +566,13 @@ static int __init omap4_i2c_init(void)
 
 static void __init omap_sfh7741prox_init(void)
 {
-       int  error;
+       int error;
 
-       error = gpio_request(OMAP4_SFH7741_ENABLE_GPIO, "sfh7741");
-       if (error < 0) {
+       error = gpio_request_one(OMAP4_SFH7741_ENABLE_GPIO,
+                                GPIOF_OUT_INIT_LOW, "sfh7741");
+       if (error < 0)
                pr_err("%s:failed to request GPIO %d, error %d\n",
                        __func__, OMAP4_SFH7741_ENABLE_GPIO, error);
-               return;
-       }
-
-       error = gpio_direction_output(OMAP4_SFH7741_ENABLE_GPIO , 0);
-       if (error < 0) {
-               pr_err("%s: GPIO configuration failed: GPIO %d,error %d\n",
-                        __func__, OMAP4_SFH7741_ENABLE_GPIO, error);
-               gpio_free(OMAP4_SFH7741_ENABLE_GPIO);
-       }
 }
 
 static void sdp4430_hdmi_mux_init(void)
@@ -645,27 +589,19 @@ static void sdp4430_hdmi_mux_init(void)
                        OMAP_PIN_INPUT_PULLUP);
 }
 
+static struct gpio sdp4430_hdmi_gpios[] = {
+       { HDMI_GPIO_HPD,        GPIOF_OUT_INIT_HIGH,    "hdmi_gpio_hpd"   },
+       { HDMI_GPIO_LS_OE,      GPIOF_OUT_INIT_HIGH,    "hdmi_gpio_ls_oe" },
+};
+
 static int sdp4430_panel_enable_hdmi(struct omap_dss_device *dssdev)
 {
        int status;
 
-       status = gpio_request_one(HDMI_GPIO_HPD, GPIOF_OUT_INIT_HIGH,
-                                                       "hdmi_gpio_hpd");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", HDMI_GPIO_HPD);
-               return status;
-       }
-       status = gpio_request_one(HDMI_GPIO_LS_OE, GPIOF_OUT_INIT_HIGH,
-                                                       "hdmi_gpio_ls_oe");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", HDMI_GPIO_LS_OE);
-               goto error1;
-       }
-
-       return 0;
-
-error1:
-       gpio_free(HDMI_GPIO_HPD);
+       status = gpio_request_array(sdp4430_hdmi_gpios,
+                                   ARRAY_SIZE(sdp4430_hdmi_gpios));
+       if (status)
+               pr_err("%s: Cannot request HDMI GPIOs\n", __func__);
 
        return status;
 }
index a890d24..5e438a7 100644 (file)
@@ -89,19 +89,13 @@ static void __init am3517_crane_init(void)
                return;
        }
 
-       ret = gpio_request(GPIO_USB_POWER, "usb_ehci_enable");
+       ret = gpio_request_one(GPIO_USB_POWER, GPIOF_OUT_INIT_HIGH,
+                              "usb_ehci_enable");
        if (ret < 0) {
                pr_err("Can not request GPIO %d\n", GPIO_USB_POWER);
                return;
        }
 
-       ret = gpio_direction_output(GPIO_USB_POWER, 1);
-       if (ret < 0) {
-               gpio_free(GPIO_USB_POWER);
-               pr_err("Unable to initialize EHCI power\n");
-               return;
-       }
-
        usbhs_init(&usbhs_bdata);
 }
 
index ff8c59b..63af417 100644 (file)
@@ -174,19 +174,14 @@ static void __init am3517_evm_rtc_init(void)
        int r;
 
        omap_mux_init_gpio(GPIO_RTCS35390A_IRQ, OMAP_PIN_INPUT_PULLUP);
-       r = gpio_request(GPIO_RTCS35390A_IRQ, "rtcs35390a-irq");
+
+       r = gpio_request_one(GPIO_RTCS35390A_IRQ, GPIOF_IN, "rtcs35390a-irq");
        if (r < 0) {
                printk(KERN_WARNING "failed to request GPIO#%d\n",
                                GPIO_RTCS35390A_IRQ);
                return;
        }
-       r = gpio_direction_input(GPIO_RTCS35390A_IRQ);
-       if (r < 0) {
-               printk(KERN_WARNING "GPIO#%d cannot be configured as input\n",
-                               GPIO_RTCS35390A_IRQ);
-               gpio_free(GPIO_RTCS35390A_IRQ);
-               return;
-       }
+
        am3517evm_i2c1_boardinfo[0].irq = gpio_to_irq(GPIO_RTCS35390A_IRQ);
 }
 
@@ -242,6 +237,15 @@ static int dvi_enabled;
 
 #if defined(CONFIG_PANEL_SHARP_LQ043T1DG01) || \
                defined(CONFIG_PANEL_SHARP_LQ043T1DG01_MODULE)
+static struct gpio am3517_evm_dss_gpios[] __initdata = {
+       /* GPIO 182 = LCD Backlight Power */
+       { LCD_PANEL_BKLIGHT_PWR, GPIOF_OUT_INIT_HIGH, "lcd_backlight_pwr" },
+       /* GPIO 181 = LCD Panel PWM */
+       { LCD_PANEL_PWM,         GPIOF_OUT_INIT_HIGH, "lcd bl enable"     },
+       /* GPIO 176 = LCD Panel Power enable pin */
+       { LCD_PANEL_PWR,         GPIOF_OUT_INIT_HIGH, "dvi enable"        },
+};
+
 static void __init am3517_evm_display_init(void)
 {
        int r;
@@ -249,41 +253,15 @@ static void __init am3517_evm_display_init(void)
        omap_mux_init_gpio(LCD_PANEL_PWR, OMAP_PIN_INPUT_PULLUP);
        omap_mux_init_gpio(LCD_PANEL_BKLIGHT_PWR, OMAP_PIN_INPUT_PULLDOWN);
        omap_mux_init_gpio(LCD_PANEL_PWM, OMAP_PIN_INPUT_PULLDOWN);
-       /*
-        * Enable GPIO 182 = LCD Backlight Power
-        */
-       r = gpio_request(LCD_PANEL_BKLIGHT_PWR, "lcd_backlight_pwr");
+
+       r = gpio_request_array(am3517_evm_dss_gpios,
+                              ARRAY_SIZE(am3517_evm_dss_gpios));
        if (r) {
-               printk(KERN_ERR "failed to get lcd_backlight_pwr\n");
+               printk(KERN_ERR "failed to get DSS panel control GPIOs\n");
                return;
        }
-       gpio_direction_output(LCD_PANEL_BKLIGHT_PWR, 1);
-       /*
-        * Enable GPIO 181 = LCD Panel PWM
-        */
-       r = gpio_request(LCD_PANEL_PWM, "lcd_pwm");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_pwm\n");
-               goto err_1;
-       }
-       gpio_direction_output(LCD_PANEL_PWM, 1);
-       /*
-        * Enable GPIO 176 = LCD Panel Power enable pin
-        */
-       r = gpio_request(LCD_PANEL_PWR, "lcd_panel_pwr");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_pwr\n");
-               goto err_2;
-       }
-       gpio_direction_output(LCD_PANEL_PWR, 1);
 
        printk(KERN_INFO "Display initialized successfully\n");
-       return;
-
-err_2:
-       gpio_free(LCD_PANEL_PWM);
-err_1:
-       gpio_free(LCD_PANEL_BKLIGHT_PWR);
 }
 #else
 static void __init am3517_evm_display_init(void) {}
@@ -396,7 +374,7 @@ static struct omap_musb_board_data musb_board_data = {
        .power                  = 500,
        .set_phy_power          = am35x_musb_phy_power,
        .clear_irq              = am35x_musb_clear_irq,
-       .set_mode               = am35x_musb_set_mode,
+       .set_mode               = am35x_set_mode,
        .reset                  = am35x_musb_reset,
 };
 
index f4f8374..f3beb8e 100644 (file)
@@ -202,6 +202,7 @@ static inline void __init apollon_init_smc91x(void)
        unsigned int rate;
        struct clk *gpmc_fck;
        int eth_cs;
+       int err;
 
        gpmc_fck = clk_get(NULL, "gpmc_fck");   /* Always on ENABLE_ON_INIT */
        if (IS_ERR(gpmc_fck)) {
@@ -245,15 +246,13 @@ static inline void __init apollon_init_smc91x(void)
        apollon_smc91x_resources[0].end   = base + 0x30f;
        udelay(100);
 
-       omap_mux_init_gpio(74, 0);
-       if (gpio_request(APOLLON_ETHR_GPIO_IRQ, "SMC91x irq") < 0) {
+       omap_mux_init_gpio(APOLLON_ETHR_GPIO_IRQ, 0);
+       err = gpio_request_one(APOLLON_ETHR_GPIO_IRQ, GPIOF_IN, "SMC91x irq");
+       if (err) {
                printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
                        APOLLON_ETHR_GPIO_IRQ);
                gpmc_cs_free(APOLLON_ETH_CS);
-               goto out;
        }
-       gpio_direction_input(APOLLON_ETHR_GPIO_IRQ);
-
 out:
        clk_disable(gpmc_fck);
        clk_put(gpmc_fck);
@@ -280,20 +279,19 @@ static void __init omap_apollon_init_early(void)
        omap2_init_common_devices(NULL, NULL);
 }
 
+static struct gpio apollon_gpio_leds[] __initdata = {
+       { LED0_GPIO13, GPIOF_OUT_INIT_LOW, "LED0" }, /* LED0 - AA10 */
+       { LED1_GPIO14, GPIOF_OUT_INIT_LOW, "LED1" }, /* LED1 - AA6  */
+       { LED2_GPIO15, GPIOF_OUT_INIT_LOW, "LED2" }, /* LED2 - AA4  */
+};
+
 static void __init apollon_led_init(void)
 {
-       /* LED0 - AA10 */
        omap_mux_init_signal("vlynq_clk.gpio_13", 0);
-       gpio_request(LED0_GPIO13, "LED0");
-       gpio_direction_output(LED0_GPIO13, 0);
-       /* LED1  - AA6 */
        omap_mux_init_signal("vlynq_rx1.gpio_14", 0);
-       gpio_request(LED1_GPIO14, "LED1");
-       gpio_direction_output(LED1_GPIO14, 0);
-       /* LED2  - AA4 */
        omap_mux_init_signal("vlynq_rx0.gpio_15", 0);
-       gpio_request(LED2_GPIO15, "LED2");
-       gpio_direction_output(LED2_GPIO15, 0);
+
+       gpio_request_array(apollon_gpio_leds, ARRAY_SIZE(apollon_gpio_leds));
 }
 
 static void __init apollon_usb_init(void)
@@ -301,8 +299,7 @@ static void __init apollon_usb_init(void)
        /* USB device */
        /* DEVICE_SUSPEND */
        omap_mux_init_signal("mcbsp2_clkx.gpio_12", 0);
-       gpio_request(12, "USB suspend");
-       gpio_direction_output(12, 0);
+       gpio_request_one(12, GPIOF_OUT_INIT_LOW, "USB suspend");
        omap2_usbfs_init(&apollon_usb_config);
 }
 
index 9340f6a..c63115b 100644 (file)
@@ -54,6 +54,7 @@
 #include "mux.h"
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define CM_T35_GPIO_PENDOWN    57
 
 
 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
 #include <linux/smsc911x.h>
+#include <plat/gpmc-smsc911x.h>
 
-static struct smsc911x_platform_config cm_t35_smsc911x_config = {
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
-       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-};
-
-static struct resource cm_t35_smsc911x_resources[] = {
-       {
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .start  = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
-               .end    = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct platform_device cm_t35_smsc911x_device = {
-       .name           = "smsc911x",
+static struct omap_smsc911x_platform_data cm_t35_smsc911x_cfg = {
        .id             = 0,
-       .num_resources  = ARRAY_SIZE(cm_t35_smsc911x_resources),
-       .resource       = cm_t35_smsc911x_resources,
-       .dev            = {
-               .platform_data = &cm_t35_smsc911x_config,
-       },
-};
-
-static struct resource sb_t35_smsc911x_resources[] = {
-       {
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .start  = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
-               .end    = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
+       .cs             = CM_T35_SMSC911X_CS,
+       .gpio_irq       = CM_T35_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 };
 
-static struct platform_device sb_t35_smsc911x_device = {
-       .name           = "smsc911x",
+static struct omap_smsc911x_platform_data sb_t35_smsc911x_cfg = {
        .id             = 1,
-       .num_resources  = ARRAY_SIZE(sb_t35_smsc911x_resources),
-       .resource       = sb_t35_smsc911x_resources,
-       .dev            = {
-               .platform_data = &cm_t35_smsc911x_config,
-       },
+       .cs             = SB_T35_SMSC911X_CS,
+       .gpio_irq       = SB_T35_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 };
 
-static void __init cm_t35_init_smsc911x(struct platform_device *dev,
-                                       int cs, int irq_gpio)
-{
-       unsigned long cs_mem_base;
-
-       if (gpmc_cs_request(cs, SZ_16M, &cs_mem_base) < 0) {
-               pr_err("CM-T35: Failed request for GPMC mem for smsc911x\n");
-               return;
-       }
-
-       dev->resource[0].start = cs_mem_base + 0x0;
-       dev->resource[0].end   = cs_mem_base + 0xff;
-
-       if ((gpio_request(irq_gpio, "ETH IRQ") == 0) &&
-           (gpio_direction_input(irq_gpio) == 0)) {
-               gpio_export(irq_gpio, 0);
-       } else {
-               pr_err("CM-T35: could not obtain gpio for SMSC911X IRQ\n");
-               return;
-       }
-
-       platform_device_register(dev);
-}
-
 static void __init cm_t35_init_ethernet(void)
 {
-       cm_t35_init_smsc911x(&cm_t35_smsc911x_device,
-                            CM_T35_SMSC911X_CS, CM_T35_SMSC911X_GPIO);
-       cm_t35_init_smsc911x(&sb_t35_smsc911x_device,
-                            SB_T35_SMSC911X_CS, SB_T35_SMSC911X_GPIO);
+       gpmc_smsc911x_init(&cm_t35_smsc911x_cfg);
+       gpmc_smsc911x_init(&sb_t35_smsc911x_cfg);
 }
 #else
 static inline void __init cm_t35_init_ethernet(void) { return; }
@@ -235,69 +178,10 @@ static void __init cm_t35_init_nand(void)
 static inline void cm_t35_init_nand(void) {}
 #endif
 
-#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
-       defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
-#include <linux/spi/ads7846.h>
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(CM_T35_GPIO_PENDOWN);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 3,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-};
-
-static struct spi_board_info cm_t35_spi_board_info[] __initdata = {
-       {
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(CM_T35_GPIO_PENDOWN),
-               .platform_data          = &ads7846_config,
-       },
-};
-
-static void __init cm_t35_init_ads7846(void)
-{
-       if ((gpio_request(CM_T35_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
-           (gpio_direction_input(CM_T35_GPIO_PENDOWN) == 0)) {
-               gpio_export(CM_T35_GPIO_PENDOWN, 0);
-       } else {
-               pr_err("CM-T35: could not obtain gpio for ADS7846_PENDOWN\n");
-               return;
-       }
-
-       spi_register_board_info(cm_t35_spi_board_info,
-                               ARRAY_SIZE(cm_t35_spi_board_info));
-}
-#else
-static inline void cm_t35_init_ads7846(void) {}
-#endif
-
 #define CM_T35_LCD_EN_GPIO 157
 #define CM_T35_LCD_BL_GPIO 58
 #define CM_T35_DVI_EN_GPIO 54
 
-static int lcd_bl_gpio;
-static int lcd_en_gpio;
-static int dvi_en_gpio;
-
 static int lcd_enabled;
 static int dvi_enabled;
 
@@ -308,8 +192,8 @@ static int cm_t35_panel_enable_lcd(struct omap_dss_device *dssdev)
                return -EINVAL;
        }
 
-       gpio_set_value(lcd_en_gpio, 1);
-       gpio_set_value(lcd_bl_gpio, 1);
+       gpio_set_value(CM_T35_LCD_EN_GPIO, 1);
+       gpio_set_value(CM_T35_LCD_BL_GPIO, 1);
 
        lcd_enabled = 1;
 
@@ -320,8 +204,8 @@ static void cm_t35_panel_disable_lcd(struct omap_dss_device *dssdev)
 {
        lcd_enabled = 0;
 
-       gpio_set_value(lcd_bl_gpio, 0);
-       gpio_set_value(lcd_en_gpio, 0);
+       gpio_set_value(CM_T35_LCD_BL_GPIO, 0);
+       gpio_set_value(CM_T35_LCD_EN_GPIO, 0);
 }
 
 static int cm_t35_panel_enable_dvi(struct omap_dss_device *dssdev)
@@ -331,7 +215,7 @@ static int cm_t35_panel_enable_dvi(struct omap_dss_device *dssdev)
                return -EINVAL;
        }
 
-       gpio_set_value(dvi_en_gpio, 0);
+       gpio_set_value(CM_T35_DVI_EN_GPIO, 0);
        dvi_enabled = 1;
 
        return 0;
@@ -339,7 +223,7 @@ static int cm_t35_panel_enable_dvi(struct omap_dss_device *dssdev)
 
 static void cm_t35_panel_disable_dvi(struct omap_dss_device *dssdev)
 {
-       gpio_set_value(dvi_en_gpio, 1);
+       gpio_set_value(CM_T35_DVI_EN_GPIO, 1);
        dvi_enabled = 0;
 }
 
@@ -421,62 +305,38 @@ static struct spi_board_info cm_t35_lcd_spi_board_info[] __initdata = {
        },
 };
 
+static struct gpio cm_t35_dss_gpios[] __initdata = {
+       { CM_T35_LCD_EN_GPIO, GPIOF_OUT_INIT_LOW,  "lcd enable"    },
+       { CM_T35_LCD_BL_GPIO, GPIOF_OUT_INIT_LOW,  "lcd bl enable" },
+       { CM_T35_DVI_EN_GPIO, GPIOF_OUT_INIT_HIGH, "dvi enable"    },
+};
+
 static void __init cm_t35_init_display(void)
 {
        int err;
 
-       lcd_en_gpio = CM_T35_LCD_EN_GPIO;
-       lcd_bl_gpio = CM_T35_LCD_BL_GPIO;
-       dvi_en_gpio = CM_T35_DVI_EN_GPIO;
-
        spi_register_board_info(cm_t35_lcd_spi_board_info,
                                ARRAY_SIZE(cm_t35_lcd_spi_board_info));
 
-       err = gpio_request(lcd_en_gpio, "LCD RST");
-       if (err) {
-               pr_err("CM-T35: failed to get LCD reset GPIO\n");
-               goto out;
-       }
-
-       err = gpio_request(lcd_bl_gpio, "LCD BL");
+       err = gpio_request_array(cm_t35_dss_gpios,
+                                ARRAY_SIZE(cm_t35_dss_gpios));
        if (err) {
-               pr_err("CM-T35: failed to get LCD backlight control GPIO\n");
-               goto err_lcd_bl;
-       }
-
-       err = gpio_request(dvi_en_gpio, "DVI EN");
-       if (err) {
-               pr_err("CM-T35: failed to get DVI reset GPIO\n");
-               goto err_dvi_en;
+               pr_err("CM-T35: failed to request DSS control GPIOs\n");
+               return;
        }
 
-       gpio_export(lcd_en_gpio, 0);
-       gpio_export(lcd_bl_gpio, 0);
-       gpio_export(dvi_en_gpio, 0);
-       gpio_direction_output(lcd_en_gpio, 0);
-       gpio_direction_output(lcd_bl_gpio, 0);
-       gpio_direction_output(dvi_en_gpio, 1);
+       gpio_export(CM_T35_LCD_EN_GPIO, 0);
+       gpio_export(CM_T35_LCD_BL_GPIO, 0);
+       gpio_export(CM_T35_DVI_EN_GPIO, 0);
 
        msleep(50);
-       gpio_set_value(lcd_en_gpio, 1);
+       gpio_set_value(CM_T35_LCD_EN_GPIO, 1);
 
        err = omap_display_init(&cm_t35_dss_data);
        if (err) {
                pr_err("CM-T35: failed to register DSS device\n");
-               goto err_dev_reg;
+               gpio_free_array(cm_t35_dss_gpios, ARRAY_SIZE(cm_t35_dss_gpios));
        }
-
-       return;
-
-err_dev_reg:
-       gpio_free(dvi_en_gpio);
-err_dvi_en:
-       gpio_free(lcd_bl_gpio);
-err_lcd_bl:
-       gpio_free(lcd_en_gpio);
-out:
-
-       return;
 }
 
 static struct regulator_consumer_supply cm_t35_vmmc1_supply = {
@@ -609,10 +469,8 @@ static int cm_t35_twl_gpio_setup(struct device *dev, unsigned gpio,
 {
        int wlan_rst = gpio + 2;
 
-       if ((gpio_request(wlan_rst, "WLAN RST") == 0) &&
-           (gpio_direction_output(wlan_rst, 1) == 0)) {
+       if (gpio_request_one(wlan_rst, GPIOF_OUT_INIT_HIGH, "WLAN RST") == 0) {
                gpio_export(wlan_rst, 0);
-
                udelay(10);
                gpio_set_value(wlan_rst, 0);
                udelay(10);
@@ -653,19 +511,9 @@ static struct twl4030_platform_data cm_t35_twldata = {
        .vpll2          = &cm_t35_vpll2,
 };
 
-static struct i2c_board_info __initdata cm_t35_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("tps65930", 0x48),
-               .flags          = I2C_CLIENT_WAKE,
-               .irq            = INT_34XX_SYS_NIRQ,
-               .platform_data  = &cm_t35_twldata,
-       },
-};
-
 static void __init cm_t35_init_i2c(void)
 {
-       omap_register_i2c_bus(1, 2600, cm_t35_i2c_boardinfo,
-                             ARRAY_SIZE(cm_t35_i2c_boardinfo));
+       omap3_pmic_init("tps65930", &cm_t35_twldata);
 }
 
 static void __init cm_t35_init_early(void)
@@ -775,12 +623,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static struct omap_board_config_kernel cm_t35_config[] __initdata = {
 };
 
@@ -792,12 +634,12 @@ static void __init cm_t35_init(void)
        omap_serial_init();
        cm_t35_init_i2c();
        cm_t35_init_nand();
-       cm_t35_init_ads7846();
+       omap_ads7846_init(1, CM_T35_GPIO_PENDOWN, 0, NULL);
        cm_t35_init_ethernet();
        cm_t35_init_led();
        cm_t35_init_display();
 
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
 }
 
index a27e3ee..08f08e8 100644 (file)
@@ -148,14 +148,13 @@ static void __init cm_t3517_init_rtc(void)
 {
        int err;
 
-       err = gpio_request(RTC_CS_EN_GPIO, "rtc cs en");
+       err = gpio_request_one(RTC_CS_EN_GPIO, GPIOF_OUT_INIT_HIGH,
+                              "rtc cs en");
        if (err) {
                pr_err("CM-T3517: rtc cs en gpio request failed: %d\n", err);
                return;
        }
 
-       gpio_direction_output(RTC_CS_EN_GPIO, 1);
-
        platform_device_register(&cm_t3517_rtc_device);
 }
 #else
@@ -182,11 +181,11 @@ static int cm_t3517_init_usbh(void)
 {
        int err;
 
-       err = gpio_request(USB_HUB_RESET_GPIO, "usb hub rst");
+       err = gpio_request_one(USB_HUB_RESET_GPIO, GPIOF_OUT_INIT_LOW,
+                              "usb hub rst");
        if (err) {
                pr_err("CM-T3517: usb hub rst gpio request failed: %d\n", err);
        } else {
-               gpio_direction_output(USB_HUB_RESET_GPIO, 0);
                udelay(10);
                gpio_set_value(USB_HUB_RESET_GPIO, 1);
                msleep(1);
index 1d1b56a..cf520d7 100644 (file)
@@ -51,7 +51,6 @@
 #include <plat/mcspi.h>
 #include <linux/input/matrix_keypad.h>
 #include <linux/spi/spi.h>
-#include <linux/spi/ads7846.h>
 #include <linux/dm9000.h>
 #include <linux/interrupt.h>
 
@@ -60,6 +59,7 @@
 #include "mux.h"
 #include "hsmmc.h"
 #include "timer-gp.h"
+#include "common-board-devices.h"
 
 #define NAND_BLOCK_SIZE                SZ_128K
 
@@ -97,13 +97,6 @@ static struct mtd_partition devkit8000_nand_partitions[] = {
        },
 };
 
-static struct omap_nand_platform_data devkit8000_nand_data = {
-       .options        = NAND_BUSWIDTH_16,
-       .parts          = devkit8000_nand_partitions,
-       .nr_parts       = ARRAY_SIZE(devkit8000_nand_partitions),
-       .dma_channel    = -1,           /* disable DMA in OMAP NAND driver */
-};
-
 static struct omap2_hsmmc_info mmc[] = {
        {
                .mmc            = 1,
@@ -249,7 +242,7 @@ static int devkit8000_twl_gpio_setup(struct device *dev,
        /* TWL4030_GPIO_MAX + 0 is "LCD_PWREN" (out, active high) */
        devkit8000_lcd_device.reset_gpio = gpio + TWL4030_GPIO_MAX + 0;
        ret = gpio_request_one(devkit8000_lcd_device.reset_gpio,
-                       GPIOF_DIR_OUT | GPIOF_INIT_LOW, "LCD_PWREN");
+                              GPIOF_OUT_INIT_LOW, "LCD_PWREN");
        if (ret < 0) {
                devkit8000_lcd_device.reset_gpio = -EINVAL;
                printk(KERN_ERR "Failed to request GPIO for LCD_PWRN\n");
@@ -258,7 +251,7 @@ static int devkit8000_twl_gpio_setup(struct device *dev,
        /* gpio + 7 is "DVI_PD" (out, active low) */
        devkit8000_dvi_device.reset_gpio = gpio + 7;
        ret = gpio_request_one(devkit8000_dvi_device.reset_gpio,
-                       GPIOF_DIR_OUT | GPIOF_INIT_LOW, "DVI PowerDown");
+                              GPIOF_OUT_INIT_LOW, "DVI PowerDown");
        if (ret < 0) {
                devkit8000_dvi_device.reset_gpio = -EINVAL;
                printk(KERN_ERR "Failed to request GPIO for DVI PowerDown\n");
@@ -366,19 +359,9 @@ static struct twl4030_platform_data devkit8000_twldata = {
        .keypad         = &devkit8000_kp_data,
 };
 
-static struct i2c_board_info __initdata devkit8000_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("tps65930", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &devkit8000_twldata,
-       },
-};
-
 static int __init devkit8000_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, devkit8000_i2c_boardinfo,
-                       ARRAY_SIZE(devkit8000_i2c_boardinfo));
+       omap3_pmic_init("tps65930", &devkit8000_twldata);
        /* Bus 3 is attached to the DVI port where devices like the pico DLP
         * projector don't work reliably with 400kHz */
        omap_register_i2c_bus(3, 400, NULL, 0);
@@ -463,56 +446,6 @@ static void __init devkit8000_init_irq(void)
 #endif
 }
 
-static void __init devkit8000_ads7846_init(void)
-{
-       int gpio = OMAP3_DEVKIT_TS_GPIO;
-       int ret;
-
-       ret = gpio_request(gpio, "ads7846_pen_down");
-       if (ret < 0) {
-               printk(KERN_ERR "Failed to request GPIO %d for "
-                               "ads7846 pen down IRQ\n", gpio);
-               return;
-       }
-
-       gpio_direction_input(gpio);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(OMAP3_DEVKIT_TS_GPIO);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 5,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-       .settle_delay_usecs     = 150,
-};
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info devkit8000_spi_board_info[] __initdata = {
-       {
-               .modalias               = "ads7846",
-               .bus_num                = 2,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(OMAP3_DEVKIT_TS_GPIO),
-               .platform_data          = &ads7846_config,
-       }
-};
-
 #define OMAP_DM9000_BASE       0x2c000000
 
 static struct resource omap_dm9000_resources[] = {
@@ -550,14 +483,14 @@ static void __init omap_dm9000_init(void)
 {
        unsigned char *eth_addr = omap_dm9000_platdata.dev_addr;
        struct omap_die_id odi;
+       int ret;
 
-       if (gpio_request(OMAP_DM9000_GPIO_IRQ, "dm9000 irq") < 0) {
+       ret = gpio_request_one(OMAP_DM9000_GPIO_IRQ, GPIOF_IN, "dm9000 irq");
+       if (ret < 0) {
                printk(KERN_ERR "Failed to request GPIO%d for dm9000 IRQ\n",
                        OMAP_DM9000_GPIO_IRQ);
                return;
-               }
-
-       gpio_direction_input(OMAP_DM9000_GPIO_IRQ);
+       }
 
        /* init the mac address using DIE id */
        omap_get_die_id(&odi);
@@ -576,45 +509,6 @@ static struct platform_device *devkit8000_devices[] __initdata = {
        &omap_dm9000_dev,
 };
 
-static void __init devkit8000_flash_init(void)
-{
-       u8 cs = 0;
-       u8 nandcs = GPMC_CS_NUM + 1;
-
-       /* find out the chip-select on which NAND exists */
-       while (cs < GPMC_CS_NUM) {
-               u32 ret = 0;
-               ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
-               if ((ret & 0xC00) == 0x800) {
-                       printk(KERN_INFO "Found NAND on CS%d\n", cs);
-                       if (nandcs > GPMC_CS_NUM)
-                               nandcs = cs;
-               }
-               cs++;
-       }
-
-       if (nandcs > GPMC_CS_NUM) {
-               printk(KERN_INFO "NAND: Unable to find configuration "
-                                "in GPMC\n ");
-               return;
-       }
-
-       if (nandcs < GPMC_CS_NUM) {
-               devkit8000_nand_data.cs = nandcs;
-
-               printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
-               if (gpmc_nand_init(&devkit8000_nand_data) < 0)
-                       printk(KERN_ERR "Unable to register NAND device\n");
-       }
-}
-
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 
        .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
@@ -795,14 +689,13 @@ static void __init devkit8000_init(void)
                        ARRAY_SIZE(devkit8000_devices));
 
        omap_display_init(&devkit8000_dss_data);
-       spi_register_board_info(devkit8000_spi_board_info,
-       ARRAY_SIZE(devkit8000_spi_board_info));
 
-       devkit8000_ads7846_init();
+       omap_ads7846_init(2, OMAP3_DEVKIT_TS_GPIO, 0, NULL);
 
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
-       devkit8000_flash_init();
+       omap_nand_flash_init(NAND_BUSWIDTH_16, devkit8000_nand_partitions,
+                            ARRAY_SIZE(devkit8000_nand_partitions));
 
        /* Ensure SDRC pins are mux'd for self-refresh */
        omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
index 3da64d3..0c1bfca 100644 (file)
@@ -38,6 +38,7 @@
 #include "mux.h"
 #include "hsmmc.h"
 #include "sdram-numonyx-m65kxxxxam.h"
+#include "common-board-devices.h"
 
 #define IGEP2_SMSC911X_CS       5
 #define IGEP2_SMSC911X_GPIO     176
 #define IGEP2_RC_GPIO_WIFI_NRESET  139
 #define IGEP2_RC_GPIO_BT_NRESET    137
 
+#define IGEP3_GPIO_LED0_GREEN  54
+#define IGEP3_GPIO_LED0_RED    53
+#define IGEP3_GPIO_LED1_RED    16
+#define IGEP3_GPIO_USBH_NRESET  183
+
 /*
  * IGEP2 Hardware Revision Table
  *
@@ -68,6 +74,7 @@
 
 #define IGEP2_BOARD_HWREV_B    0
 #define IGEP2_BOARD_HWREV_C    1
+#define IGEP3_BOARD_HWREV      2
 
 static u8 hwrev;
 
@@ -75,24 +82,29 @@ static void __init igep2_get_revision(void)
 {
        u8 ret;
 
+       if (machine_is_igep0030()) {
+               hwrev = IGEP3_BOARD_HWREV;
+               return;
+       }
+
        omap_mux_init_gpio(IGEP2_GPIO_LED1_RED, OMAP_PIN_INPUT);
 
-       if ((gpio_request(IGEP2_GPIO_LED1_RED, "GPIO_HW0_REV") == 0) &&
-           (gpio_direction_input(IGEP2_GPIO_LED1_RED) == 0)) {
-               ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
-               if (ret == 0) {
-                       pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
-                       hwrev = IGEP2_BOARD_HWREV_C;
-               } else if (ret ==  1) {
-                       pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
-                       hwrev = IGEP2_BOARD_HWREV_B;
-               } else {
-                       pr_err("IGEP2: Unknown Hardware Revision\n");
-                       hwrev = -1;
-               }
-       } else {
+       if (gpio_request_one(IGEP2_GPIO_LED1_RED, GPIOF_IN, "GPIO_HW0_REV")) {
                pr_warning("IGEP2: Could not obtain gpio GPIO_HW0_REV\n");
                pr_err("IGEP2: Unknown Hardware Revision\n");
+               return;
+       }
+
+       ret = gpio_get_value(IGEP2_GPIO_LED1_RED);
+       if (ret == 0) {
+               pr_info("IGEP2: Hardware Revision C (B-NON compatible)\n");
+               hwrev = IGEP2_BOARD_HWREV_C;
+       } else if (ret ==  1) {
+               pr_info("IGEP2: Hardware Revision B/C (B compatible)\n");
+               hwrev = IGEP2_BOARD_HWREV_B;
+       } else {
+               pr_err("IGEP2: Unknown Hardware Revision\n");
+               hwrev = -1;
        }
 
        gpio_free(IGEP2_GPIO_LED1_RED);
@@ -111,7 +123,7 @@ static void __init igep2_get_revision(void)
  * So MTD regards it as 4KiB page size and 256KiB block size 64*(2*2048)
  */
 
-static struct mtd_partition igep2_onenand_partitions[] = {
+static struct mtd_partition igep_onenand_partitions[] = {
        {
                .name           = "X-Loader",
                .offset         = 0,
@@ -139,21 +151,21 @@ static struct mtd_partition igep2_onenand_partitions[] = {
        },
 };
 
-static struct omap_onenand_platform_data igep2_onenand_data = {
-       .parts = igep2_onenand_partitions,
-       .nr_parts = ARRAY_SIZE(igep2_onenand_partitions),
+static struct omap_onenand_platform_data igep_onenand_data = {
+       .parts = igep_onenand_partitions,
+       .nr_parts = ARRAY_SIZE(igep_onenand_partitions),
        .dma_channel    = -1,   /* disable DMA in OMAP OneNAND driver */
 };
 
-static struct platform_device igep2_onenand_device = {
+static struct platform_device igep_onenand_device = {
        .name           = "omap2-onenand",
        .id             = -1,
        .dev = {
-               .platform_data = &igep2_onenand_data,
+               .platform_data = &igep_onenand_data,
        },
 };
 
-static void __init igep2_flash_init(void)
+static void __init igep_flash_init(void)
 {
        u8 cs = 0;
        u8 onenandcs = GPMC_CS_NUM + 1;
@@ -165,7 +177,7 @@ static void __init igep2_flash_init(void)
                /* Check if NAND/oneNAND is configured */
                if ((ret & 0xC00) == 0x800)
                        /* NAND found */
-                       pr_err("IGEP2: Unsupported NAND found\n");
+                       pr_err("IGEP: Unsupported NAND found\n");
                else {
                        ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
                        if ((ret & 0x3F) == (ONENAND_MAP >> 24))
@@ -175,85 +187,46 @@ static void __init igep2_flash_init(void)
        }
 
        if (onenandcs > GPMC_CS_NUM) {
-               pr_err("IGEP2: Unable to find configuration in GPMC\n");
+               pr_err("IGEP: Unable to find configuration in GPMC\n");
                return;
        }
 
-       igep2_onenand_data.cs = onenandcs;
+       igep_onenand_data.cs = onenandcs;
 
-       if (platform_device_register(&igep2_onenand_device) < 0)
-               pr_err("IGEP2: Unable to register OneNAND device\n");
+       if (platform_device_register(&igep_onenand_device) < 0)
+               pr_err("IGEP: Unable to register OneNAND device\n");
 }
 
 #else
-static void __init igep2_flash_init(void) {}
+static void __init igep_flash_init(void) {}
 #endif
 
 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
 
 #include <linux/smsc911x.h>
+#include <plat/gpmc-smsc911x.h>
 
-static struct smsc911x_platform_config igep2_smsc911x_config = {
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
-       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS  ,
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-};
-
-static struct resource igep2_smsc911x_resources[] = {
-       {
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .start  = OMAP_GPIO_IRQ(IGEP2_SMSC911X_GPIO),
-               .end    = OMAP_GPIO_IRQ(IGEP2_SMSC911X_GPIO),
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct platform_device igep2_smsc911x_device = {
-       .name           = "smsc911x",
-       .id             = 0,
-       .num_resources  = ARRAY_SIZE(igep2_smsc911x_resources),
-       .resource       = igep2_smsc911x_resources,
-       .dev            = {
-               .platform_data = &igep2_smsc911x_config,
-       },
+static struct omap_smsc911x_platform_data smsc911x_cfg = {
+       .cs             = IGEP2_SMSC911X_CS,
+       .gpio_irq       = IGEP2_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 };
 
 static inline void __init igep2_init_smsc911x(void)
 {
-       unsigned long cs_mem_base;
-
-       if (gpmc_cs_request(IGEP2_SMSC911X_CS, SZ_16M, &cs_mem_base) < 0) {
-               pr_err("IGEP v2: Failed request for GPMC mem for smsc911x\n");
-               gpmc_cs_free(IGEP2_SMSC911X_CS);
-               return;
-       }
-
-       igep2_smsc911x_resources[0].start = cs_mem_base + 0x0;
-       igep2_smsc911x_resources[0].end   = cs_mem_base + 0xff;
-
-       if ((gpio_request(IGEP2_SMSC911X_GPIO, "SMSC911X IRQ") == 0) &&
-           (gpio_direction_input(IGEP2_SMSC911X_GPIO) == 0)) {
-               gpio_export(IGEP2_SMSC911X_GPIO, 0);
-       } else {
-               pr_err("IGEP v2: Could not obtain gpio for for SMSC911X IRQ\n");
-               return;
-       }
-
-       platform_device_register(&igep2_smsc911x_device);
+       gpmc_smsc911x_init(&smsc911x_cfg);
 }
 
 #else
 static inline void __init igep2_init_smsc911x(void) { }
 #endif
 
-static struct regulator_consumer_supply igep2_vmmc1_supply =
+static struct regulator_consumer_supply igep_vmmc1_supply =
        REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0");
 
 /* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
-static struct regulator_init_data igep2_vmmc1 = {
+static struct regulator_init_data igep_vmmc1 = {
        .constraints = {
                .min_uV                 = 1850000,
                .max_uV                 = 3150000,
@@ -264,13 +237,13 @@ static struct regulator_init_data igep2_vmmc1 = {
                                        | REGULATOR_CHANGE_STATUS,
        },
        .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep2_vmmc1_supply,
+       .consumer_supplies      = &igep_vmmc1_supply,
 };
 
-static struct regulator_consumer_supply igep2_vio_supply =
+static struct regulator_consumer_supply igep_vio_supply =
        REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");
 
-static struct regulator_init_data igep2_vio = {
+static struct regulator_init_data igep_vio = {
        .constraints = {
                .min_uV                 = 1800000,
                .max_uV                 = 1800000,
@@ -282,34 +255,34 @@ static struct regulator_init_data igep2_vio = {
                                        | REGULATOR_CHANGE_STATUS,
        },
        .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep2_vio_supply,
+       .consumer_supplies      = &igep_vio_supply,
 };
 
-static struct regulator_consumer_supply igep2_vmmc2_supply =
+static struct regulator_consumer_supply igep_vmmc2_supply =
        REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");
 
-static struct regulator_init_data igep2_vmmc2 = {
+static struct regulator_init_data igep_vmmc2 = {
        .constraints            = {
                .valid_modes_mask       = REGULATOR_MODE_NORMAL,
                .always_on              = 1,
        },
        .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep2_vmmc2_supply,
+       .consumer_supplies      = &igep_vmmc2_supply,
 };
 
-static struct fixed_voltage_config igep2_vwlan = {
+static struct fixed_voltage_config igep_vwlan = {
        .supply_name            = "vwlan",
        .microvolts             = 3300000,
        .gpio                   = -EINVAL,
        .enabled_at_boot        = 1,
-       .init_data              = &igep2_vmmc2,
+       .init_data              = &igep_vmmc2,
 };
 
-static struct platform_device igep2_vwlan_device = {
+static struct platform_device igep_vwlan_device = {
        .name           = "reg-fixed-voltage",
        .id             = 0,
        .dev = {
-               .platform_data  = &igep2_vwlan,
+               .platform_data  = &igep_vwlan,
        },
 };
 
@@ -334,20 +307,17 @@ static struct omap2_hsmmc_info mmc[] = {
 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
 #include <linux/leds.h>
 
-static struct gpio_led igep2_gpio_leds[] = {
+static struct gpio_led igep_gpio_leds[] = {
        [0] = {
                .name                   = "gpio-led:red:d0",
-               .gpio                   = IGEP2_GPIO_LED0_RED,
                .default_trigger        = "default-off"
        },
        [1] = {
                .name                   = "gpio-led:green:d0",
-               .gpio                   = IGEP2_GPIO_LED0_GREEN,
                .default_trigger        = "default-off",
        },
        [2] = {
                .name                   = "gpio-led:red:d1",
-               .gpio                   = IGEP2_GPIO_LED1_RED,
                .default_trigger        = "default-off",
        },
        [3] = {
@@ -358,94 +328,119 @@ static struct gpio_led igep2_gpio_leds[] = {
        },
 };
 
-static struct gpio_led_platform_data igep2_led_pdata = {
-       .leds           = igep2_gpio_leds,
-       .num_leds       = ARRAY_SIZE(igep2_gpio_leds),
+static struct gpio_led_platform_data igep_led_pdata = {
+       .leds           = igep_gpio_leds,
+       .num_leds       = ARRAY_SIZE(igep_gpio_leds),
 };
 
-static struct platform_device igep2_led_device = {
+static struct platform_device igep_led_device = {
         .name   = "leds-gpio",
         .id     = -1,
         .dev    = {
-                .platform_data  =  &igep2_led_pdata,
+                .platform_data  =  &igep_led_pdata,
        },
 };
 
-static void __init igep2_leds_init(void)
+static void __init igep_leds_init(void)
 {
-       platform_device_register(&igep2_led_device);
+       if (machine_is_igep0020()) {
+               igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
+               igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
+               igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
+       } else {
+               igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
+               igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
+               igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
+       }
+
+       platform_device_register(&igep_led_device);
 }
 
 #else
-static inline void igep2_leds_init(void)
+static struct gpio igep_gpio_leds[] __initdata = {
+       { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d0"   },
+       { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:green:d0" },
+       { -EINVAL,      GPIOF_OUT_INIT_LOW, "gpio-led:red:d1"   },
+};
+
+static inline void igep_leds_init(void)
 {
-       if ((gpio_request(IGEP2_GPIO_LED0_RED, "gpio-led:red:d0") == 0) &&
-           (gpio_direction_output(IGEP2_GPIO_LED0_RED, 0) == 0))
-               gpio_export(IGEP2_GPIO_LED0_RED, 0);
-       else
-               pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_RED\n");
+       int i;
 
-       if ((gpio_request(IGEP2_GPIO_LED0_GREEN, "gpio-led:green:d0") == 0) &&
-           (gpio_direction_output(IGEP2_GPIO_LED0_GREEN, 0) == 0))
-               gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
-       else
-               pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_GREEN\n");
+       if (machine_is_igep0020()) {
+               igep_gpio_leds[0].gpio = IGEP2_GPIO_LED0_RED;
+               igep_gpio_leds[1].gpio = IGEP2_GPIO_LED0_GREEN;
+               igep_gpio_leds[2].gpio = IGEP2_GPIO_LED1_RED;
+       } else {
+               igep_gpio_leds[0].gpio = IGEP3_GPIO_LED0_RED;
+               igep_gpio_leds[1].gpio = IGEP3_GPIO_LED0_GREEN;
+               igep_gpio_leds[2].gpio = IGEP3_GPIO_LED1_RED;
+       }
 
-       if ((gpio_request(IGEP2_GPIO_LED1_RED, "gpio-led:red:d1") == 0) &&
-           (gpio_direction_output(IGEP2_GPIO_LED1_RED, 0) == 0))
-               gpio_export(IGEP2_GPIO_LED1_RED, 0);
-       else
-               pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_RED\n");
+       if (gpio_request_array(igep_gpio_leds, ARRAY_SIZE(igep_gpio_leds))) {
+               pr_warning("IGEP v2: Could not obtain leds gpios\n");
+               return;
+       }
 
+       for (i = 0; i < ARRAY_SIZE(igep_gpio_leds); i++)
+               gpio_export(igep_gpio_leds[i].gpio, 0);
 }
 #endif
 
-static int igep2_twl_gpio_setup(struct device *dev,
+static struct gpio igep2_twl_gpios[] = {
+       { -EINVAL, GPIOF_IN,            "GPIO_EHCI_NOC"  },
+       { -EINVAL, GPIOF_OUT_INIT_LOW,  "GPIO_USBH_CPEN" },
+};
+
+static int igep_twl_gpio_setup(struct device *dev,
                unsigned gpio, unsigned ngpio)
 {
+       int ret;
+
        /* gpio + 0 is "mmc0_cd" (input/IRQ) */
        mmc[0].gpio_cd = gpio + 0;
        omap2_hsmmc_init(mmc);
 
-       /*
-        * REVISIT: need ehci-omap hooks for external VBUS
-        * power switch and overcurrent detect
-        */
-       if ((gpio_request(gpio + 1, "GPIO_EHCI_NOC") < 0) ||
-           (gpio_direction_input(gpio + 1) < 0))
-               pr_err("IGEP2: Could not obtain gpio for EHCI NOC");
-
-       /*
-        * TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN
-        * (out, active low)
-        */
-       if ((gpio_request(gpio + TWL4030_GPIO_MAX, "GPIO_USBH_CPEN") < 0) ||
-           (gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0) < 0))
-               pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
-
        /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
 #if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
-       if ((gpio_request(gpio+TWL4030_GPIO_MAX+1, "gpio-led:green:d1") == 0)
-           && (gpio_direction_output(gpio + TWL4030_GPIO_MAX + 1, 1) == 0))
+       ret = gpio_request_one(gpio + TWL4030_GPIO_MAX + 1, GPIOF_OUT_INIT_HIGH,
+                              "gpio-led:green:d1");
+       if (ret == 0)
                gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
        else
-               pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_GREEN\n");
+               pr_warning("IGEP: Could not obtain gpio GPIO_LED1_GREEN\n");
 #else
-       igep2_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
+       igep_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
 #endif
 
+       if (machine_is_igep0030())
+               return 0;
+
+       /*
+        * REVISIT: need ehci-omap hooks for external VBUS
+        * power switch and overcurrent detect
+        */
+       igep2_twl_gpios[0].gpio = gpio + 1;
+
+       /* TWL4030_GPIO_MAX + 0 == ledA, GPIO_USBH_CPEN (out, active low) */
+       igep2_twl_gpios[1].gpio = gpio + TWL4030_GPIO_MAX;
+
+       ret = gpio_request_array(igep2_twl_gpios, ARRAY_SIZE(igep2_twl_gpios));
+       if (ret < 0)
+               pr_err("IGEP2: Could not obtain gpio for USBH_CPEN");
+
        return 0;
 };
 
-static struct twl4030_gpio_platform_data igep2_twl4030_gpio_pdata = {
+static struct twl4030_gpio_platform_data igep_twl4030_gpio_pdata = {
        .gpio_base      = OMAP_MAX_GPIO_LINES,
        .irq_base       = TWL4030_GPIO_IRQ_BASE,
        .irq_end        = TWL4030_GPIO_IRQ_END,
        .use_leds       = true,
-       .setup          = igep2_twl_gpio_setup,
+       .setup          = igep_twl_gpio_setup,
 };
 
-static struct twl4030_usb_data igep2_usb_data = {
+static struct twl4030_usb_data igep_usb_data = {
        .usb_mode       = T2_USB_MODE_ULPI,
 };
 
@@ -507,16 +502,17 @@ static struct regulator_init_data igep2_vpll2 = {
 
 static void __init igep2_display_init(void)
 {
-       if (gpio_request(IGEP2_GPIO_DVI_PUP, "GPIO_DVI_PUP") &&
-           gpio_direction_output(IGEP2_GPIO_DVI_PUP, 1))
+       int err = gpio_request_one(IGEP2_GPIO_DVI_PUP, GPIOF_OUT_INIT_HIGH,
+                                  "GPIO_DVI_PUP");
+       if (err)
                pr_err("IGEP v2: Could not obtain gpio GPIO_DVI_PUP\n");
 }
 
-static struct platform_device *igep2_devices[] __initdata = {
-       &igep2_vwlan_device,
+static struct platform_device *igep_devices[] __initdata = {
+       &igep_vwlan_device,
 };
 
-static void __init igep2_init_early(void)
+static void __init igep_init_early(void)
 {
        omap2_init_common_infrastructure();
        omap2_init_common_devices(m65kxxxxam_sdrc_params,
@@ -561,27 +557,15 @@ static struct twl4030_keypad_data igep2_keypad_pdata = {
        .rep            = 1,
 };
 
-static struct twl4030_platform_data igep2_twldata = {
+static struct twl4030_platform_data igep_twldata = {
        .irq_base       = TWL4030_IRQ_BASE,
        .irq_end        = TWL4030_IRQ_END,
 
        /* platform_data for children goes here */
-       .usb            = &igep2_usb_data,
-       .codec          = &igep2_codec_data,
-       .gpio           = &igep2_twl4030_gpio_pdata,
-       .keypad         = &igep2_keypad_pdata,
-       .vmmc1          = &igep2_vmmc1,
-       .vpll2          = &igep2_vpll2,
-       .vio            = &igep2_vio,
-};
-
-static struct i2c_board_info __initdata igep2_i2c1_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags          = I2C_CLIENT_WAKE,
-               .irq            = INT_34XX_SYS_NIRQ,
-               .platform_data  = &igep2_twldata,
-       },
+       .usb            = &igep_usb_data,
+       .gpio           = &igep_twl4030_gpio_pdata,
+       .vmmc1          = &igep_vmmc1,
+       .vio            = &igep_vio,
 };
 
 static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
@@ -590,32 +574,29 @@ static struct i2c_board_info __initdata igep2_i2c3_boardinfo[] = {
        },
 };
 
-static void __init igep2_i2c_init(void)
+static void __init igep_i2c_init(void)
 {
        int ret;
 
-       ret = omap_register_i2c_bus(1, 2600, igep2_i2c1_boardinfo,
-               ARRAY_SIZE(igep2_i2c1_boardinfo));
-       if (ret)
-               pr_warning("IGEP2: Could not register I2C1 bus (%d)\n", ret);
+       if (machine_is_igep0020()) {
+               /*
+                * Bus 3 is attached to the DVI port where devices like the
+                * pico DLP projector don't work reliably with 400kHz
+                */
+               ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
+                                           ARRAY_SIZE(igep2_i2c3_boardinfo));
+               if (ret)
+                       pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
+
+               igep_twldata.codec      = &igep2_codec_data;
+               igep_twldata.keypad     = &igep2_keypad_pdata;
+               igep_twldata.vpll2      = &igep2_vpll2;
+       }
 
-       /*
-        * Bus 3 is attached to the DVI port where devices like the pico DLP
-        * projector don't work reliably with 400kHz
-        */
-       ret = omap_register_i2c_bus(3, 100, igep2_i2c3_boardinfo,
-               ARRAY_SIZE(igep2_i2c3_boardinfo));
-       if (ret)
-               pr_warning("IGEP2: Could not register I2C3 bus (%d)\n", ret);
+       omap3_pmic_init("twl4030", &igep_twldata);
 }
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
-static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
+static const struct usbhs_omap_board_data igep2_usbhs_bdata __initconst = {
        .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
        .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
        .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
@@ -626,6 +607,17 @@ static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
        .reset_gpio_port[2] = -EINVAL,
 };
 
+static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
+       .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
+       .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
+       .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
+
+       .phy_reset = true,
+       .reset_gpio_port[0] = -EINVAL,
+       .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
+       .reset_gpio_port[2] = -EINVAL,
+};
+
 #ifdef CONFIG_OMAP_MUX
 static struct omap_board_mux board_mux[] __initdata = {
        { .reg_offset = OMAP_MUX_TERMINATOR },
@@ -633,82 +625,95 @@ static struct omap_board_mux board_mux[] __initdata = {
 #endif
 
 #if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
+static struct gpio igep_wlan_bt_gpios[] __initdata = {
+       { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NPD"    },
+       { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_WIFI_NRESET" },
+       { -EINVAL, GPIOF_OUT_INIT_HIGH, "GPIO_BT_NRESET"   },
+};
 
-static void __init igep2_wlan_bt_init(void)
+static void __init igep_wlan_bt_init(void)
 {
-       unsigned npd, wreset, btreset;
+       int err;
 
        /* GPIO's for WLAN-BT combo depends on hardware revision */
        if (hwrev == IGEP2_BOARD_HWREV_B) {
-               npd = IGEP2_RB_GPIO_WIFI_NPD;
-               wreset = IGEP2_RB_GPIO_WIFI_NRESET;
-               btreset = IGEP2_RB_GPIO_BT_NRESET;
-       } else if (hwrev == IGEP2_BOARD_HWREV_C) {
-               npd = IGEP2_RC_GPIO_WIFI_NPD;
-               wreset = IGEP2_RC_GPIO_WIFI_NRESET;
-               btreset = IGEP2_RC_GPIO_BT_NRESET;
+               igep_wlan_bt_gpios[0].gpio = IGEP2_RB_GPIO_WIFI_NPD;
+               igep_wlan_bt_gpios[1].gpio = IGEP2_RB_GPIO_WIFI_NRESET;
+               igep_wlan_bt_gpios[2].gpio = IGEP2_RB_GPIO_BT_NRESET;
+       } else if (hwrev == IGEP2_BOARD_HWREV_C || machine_is_igep0030()) {
+               igep_wlan_bt_gpios[0].gpio = IGEP2_RC_GPIO_WIFI_NPD;
+               igep_wlan_bt_gpios[1].gpio = IGEP2_RC_GPIO_WIFI_NRESET;
+               igep_wlan_bt_gpios[2].gpio = IGEP2_RC_GPIO_BT_NRESET;
        } else
                return;
 
-       /* Set GPIO's for  WLAN-BT combo module */
-       if ((gpio_request(npd, "GPIO_WIFI_NPD") == 0) &&
-           (gpio_direction_output(npd, 1) == 0)) {
-               gpio_export(npd, 0);
-       } else
-               pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NPD\n");
-
-       if ((gpio_request(wreset, "GPIO_WIFI_NRESET") == 0) &&
-           (gpio_direction_output(wreset, 1) == 0)) {
-               gpio_export(wreset, 0);
-               gpio_set_value(wreset, 0);
-               udelay(10);
-               gpio_set_value(wreset, 1);
-       } else
-               pr_warning("IGEP2: Could not obtain gpio GPIO_WIFI_NRESET\n");
+       err = gpio_request_array(igep_wlan_bt_gpios,
+                                ARRAY_SIZE(igep_wlan_bt_gpios));
+       if (err) {
+               pr_warning("IGEP2: Could not obtain WIFI/BT gpios\n");
+               return;
+       }
+
+       gpio_export(igep_wlan_bt_gpios[0].gpio, 0);
+       gpio_export(igep_wlan_bt_gpios[1].gpio, 0);
+       gpio_export(igep_wlan_bt_gpios[2].gpio, 0);
+
+       gpio_set_value(igep_wlan_bt_gpios[1].gpio, 0);
+       udelay(10);
+       gpio_set_value(igep_wlan_bt_gpios[1].gpio, 1);
 
-       if ((gpio_request(btreset, "GPIO_BT_NRESET") == 0) &&
-           (gpio_direction_output(btreset, 1) == 0)) {
-               gpio_export(btreset, 0);
-       } else
-               pr_warning("IGEP2: Could not obtain gpio GPIO_BT_NRESET\n");
 }
 #else
-static inline void __init igep2_wlan_bt_init(void) { }
+static inline void __init igep_wlan_bt_init(void) { }
 #endif
 
-static void __init igep2_init(void)
+static void __init igep_init(void)
 {
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
 
        /* Get IGEP2 hardware revision */
        igep2_get_revision();
        /* Register I2C busses and drivers */
-       igep2_i2c_init();
-       platform_add_devices(igep2_devices, ARRAY_SIZE(igep2_devices));
-       omap_display_init(&igep2_dss_data);
+       igep_i2c_init();
+       platform_add_devices(igep_devices, ARRAY_SIZE(igep_devices));
        omap_serial_init();
-       usb_musb_init(&musb_board_data);
-       usbhs_init(&usbhs_bdata);
+       usb_musb_init(NULL);
 
-       igep2_flash_init();
-       igep2_leds_init();
-       igep2_display_init();
-       igep2_init_smsc911x();
+       igep_flash_init();
+       igep_leds_init();
 
        /*
         * WLAN-BT combo module from MuRata which has a Marvell WLAN
         * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
         */
-       igep2_wlan_bt_init();
+       igep_wlan_bt_init();
 
+       if (machine_is_igep0020()) {
+               omap_display_init(&igep2_dss_data);
+               igep2_display_init();
+               igep2_init_smsc911x();
+               usbhs_init(&igep2_usbhs_bdata);
+       } else {
+               usbhs_init(&igep3_usbhs_bdata);
+       }
 }
 
 MACHINE_START(IGEP0020, "IGEP v2 board")
        .boot_params    = 0x80000100,
        .reserve        = omap_reserve,
        .map_io         = omap3_map_io,
-       .init_early     = igep2_init_early,
+       .init_early     = igep_init_early,
+       .init_irq       = omap_init_irq,
+       .init_machine   = igep_init,
+       .timer          = &omap_timer,
+MACHINE_END
+
+MACHINE_START(IGEP0030, "IGEP OMAP3 module")
+       .boot_params    = 0x80000100,
+       .reserve        = omap_reserve,
+       .map_io         = omap3_map_io,
+       .init_early     = igep_init_early,
        .init_irq       = omap_init_irq,
-       .init_machine   = igep2_init,
+       .init_machine   = igep_init,
        .timer          = &omap_timer,
 MACHINE_END
diff --git a/arch/arm/mach-omap2/board-igep0030.c b/arch/arm/mach-omap2/board-igep0030.c
deleted file mode 100644 (file)
index 2cf86c3..0000000
+++ /dev/null
@@ -1,458 +0,0 @@
-/*
- * Copyright (C) 2010 - ISEE 2007 SL
- *
- * Modified from mach-omap2/board-generic.c
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/clk.h>
-#include <linux/io.h>
-#include <linux/gpio.h>
-#include <linux/interrupt.h>
-
-#include <linux/regulator/machine.h>
-#include <linux/regulator/fixed.h>
-#include <linux/i2c/twl.h>
-#include <linux/mmc/host.h>
-
-#include <asm/mach-types.h>
-#include <asm/mach/arch.h>
-
-#include <plat/board.h>
-#include <plat/common.h>
-#include <plat/gpmc.h>
-#include <plat/usb.h>
-#include <plat/onenand.h>
-
-#include "mux.h"
-#include "hsmmc.h"
-#include "sdram-numonyx-m65kxxxxam.h"
-
-#define IGEP3_GPIO_LED0_GREEN  54
-#define IGEP3_GPIO_LED0_RED    53
-#define IGEP3_GPIO_LED1_RED    16
-
-#define IGEP3_GPIO_WIFI_NPD    138
-#define IGEP3_GPIO_WIFI_NRESET 139
-#define IGEP3_GPIO_BT_NRESET   137
-
-#define IGEP3_GPIO_USBH_NRESET  183
-
-
-#if defined(CONFIG_MTD_ONENAND_OMAP2) || \
-       defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
-
-#define ONENAND_MAP             0x20000000
-
-/*
- * x2 Flash built-in COMBO POP MEMORY
- * Since the device is equipped with two DataRAMs, and two-plane NAND
- * Flash memory array, these two component enables simultaneous program
- * of 4KiB. Plane1 has only even blocks such as block0, block2, block4
- * while Plane2 has only odd blocks such as block1, block3, block5.
- * So MTD regards it as 4KiB page size and 256KiB block size 64*(2*2048)
- */
-
-static struct mtd_partition igep3_onenand_partitions[] = {
-       {
-               .name           = "X-Loader",
-               .offset         = 0,
-               .size           = 2 * (64*(2*2048))
-       },
-       {
-               .name           = "U-Boot",
-               .offset         = MTDPART_OFS_APPEND,
-               .size           = 6 * (64*(2*2048)),
-       },
-       {
-               .name           = "Environment",
-               .offset         = MTDPART_OFS_APPEND,
-               .size           = 2 * (64*(2*2048)),
-       },
-       {
-               .name           = "Kernel",
-               .offset         = MTDPART_OFS_APPEND,
-               .size           = 12 * (64*(2*2048)),
-       },
-       {
-               .name           = "File System",
-               .offset         = MTDPART_OFS_APPEND,
-               .size           = MTDPART_SIZ_FULL,
-       },
-};
-
-static struct omap_onenand_platform_data igep3_onenand_pdata = {
-       .parts = igep3_onenand_partitions,
-       .nr_parts = ARRAY_SIZE(igep3_onenand_partitions),
-       .onenand_setup = NULL,
-       .dma_channel    = -1,   /* disable DMA in OMAP OneNAND driver */
-};
-
-static struct platform_device igep3_onenand_device = {
-       .name           = "omap2-onenand",
-       .id             = -1,
-       .dev = {
-               .platform_data = &igep3_onenand_pdata,
-       },
-};
-
-static void __init igep3_flash_init(void)
-{
-       u8 cs = 0;
-       u8 onenandcs = GPMC_CS_NUM + 1;
-
-       for (cs = 0; cs < GPMC_CS_NUM; cs++) {
-               u32 ret;
-               ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
-               /* Check if NAND/oneNAND is configured */
-               if ((ret & 0xC00) == 0x800)
-                       /* NAND found */
-                       pr_err("IGEP3: Unsupported NAND found\n");
-               else {
-                       ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
-
-                       if ((ret & 0x3F) == (ONENAND_MAP >> 24))
-                               /* OneNAND found */
-                               onenandcs = cs;
-               }
-       }
-
-       if (onenandcs > GPMC_CS_NUM) {
-               pr_err("IGEP3: Unable to find configuration in GPMC\n");
-               return;
-       }
-
-       igep3_onenand_pdata.cs = onenandcs;
-
-       if (platform_device_register(&igep3_onenand_device) < 0)
-               pr_err("IGEP3: Unable to register OneNAND device\n");
-}
-
-#else
-static void __init igep3_flash_init(void) {}
-#endif
-
-static struct regulator_consumer_supply igep3_vmmc1_supply =
-       REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0");
-
-/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
-static struct regulator_init_data igep3_vmmc1 = {
-       .constraints = {
-               .min_uV                 = 1850000,
-               .max_uV                 = 3150000,
-               .valid_modes_mask       = REGULATOR_MODE_NORMAL
-                                       | REGULATOR_MODE_STANDBY,
-               .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
-                                       | REGULATOR_CHANGE_MODE
-                                       | REGULATOR_CHANGE_STATUS,
-       },
-       .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep3_vmmc1_supply,
-};
-
-static struct regulator_consumer_supply igep3_vio_supply =
-       REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.1");
-
-static struct regulator_init_data igep3_vio = {
-       .constraints = {
-               .min_uV                 = 1800000,
-               .max_uV                 = 1800000,
-               .apply_uV               = 1,
-               .valid_modes_mask       = REGULATOR_MODE_NORMAL
-                                       | REGULATOR_MODE_STANDBY,
-               .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
-                                       | REGULATOR_CHANGE_MODE
-                                       | REGULATOR_CHANGE_STATUS,
-       },
-       .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep3_vio_supply,
-};
-
-static struct regulator_consumer_supply igep3_vmmc2_supply =
-       REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1");
-
-static struct regulator_init_data igep3_vmmc2 = {
-       .constraints    = {
-               .valid_modes_mask       = REGULATOR_MODE_NORMAL,
-               .always_on              = 1,
-       },
-       .num_consumer_supplies  = 1,
-       .consumer_supplies      = &igep3_vmmc2_supply,
-};
-
-static struct fixed_voltage_config igep3_vwlan = {
-       .supply_name            = "vwlan",
-       .microvolts             = 3300000,
-       .gpio                   = -EINVAL,
-       .enabled_at_boot        = 1,
-       .init_data              = &igep3_vmmc2,
-};
-
-static struct platform_device igep3_vwlan_device = {
-       .name   = "reg-fixed-voltage",
-       .id     = 0,
-       .dev    = {
-               .platform_data = &igep3_vwlan,
-       },
-};
-
-static struct omap2_hsmmc_info mmc[] = {
-       [0] = {
-               .mmc            = 1,
-               .caps           = MMC_CAP_4_BIT_DATA,
-               .gpio_cd        = -EINVAL,
-               .gpio_wp        = -EINVAL,
-       },
-#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
-       [1] = {
-               .mmc            = 2,
-               .caps           = MMC_CAP_4_BIT_DATA,
-               .gpio_cd        = -EINVAL,
-               .gpio_wp        = -EINVAL,
-       },
-#endif
-       {}      /* Terminator */
-};
-
-#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
-#include <linux/leds.h>
-
-static struct gpio_led igep3_gpio_leds[] = {
-       [0] = {
-               .name                   = "gpio-led:red:d0",
-               .gpio                   = IGEP3_GPIO_LED0_RED,
-               .default_trigger        = "default-off"
-       },
-       [1] = {
-               .name                   = "gpio-led:green:d0",
-               .gpio                   = IGEP3_GPIO_LED0_GREEN,
-               .default_trigger        = "default-off",
-       },
-       [2] = {
-               .name                   = "gpio-led:red:d1",
-               .gpio                   = IGEP3_GPIO_LED1_RED,
-               .default_trigger        = "default-off",
-       },
-       [3] = {
-               .name                   = "gpio-led:green:d1",
-               .default_trigger        = "heartbeat",
-               .gpio                   = -EINVAL, /* gets replaced */
-       },
-};
-
-static struct gpio_led_platform_data igep3_led_pdata = {
-       .leds           = igep3_gpio_leds,
-       .num_leds       = ARRAY_SIZE(igep3_gpio_leds),
-};
-
-static struct platform_device igep3_led_device = {
-        .name   = "leds-gpio",
-        .id     = -1,
-        .dev    = {
-                .platform_data = &igep3_led_pdata,
-       },
-};
-
-static void __init igep3_leds_init(void)
-{
-       platform_device_register(&igep3_led_device);
-}
-
-#else
-static inline void igep3_leds_init(void)
-{
-       if ((gpio_request(IGEP3_GPIO_LED0_RED, "gpio-led:red:d0") == 0) &&
-           (gpio_direction_output(IGEP3_GPIO_LED0_RED, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_LED0_RED, 0);
-               gpio_set_value(IGEP3_GPIO_LED0_RED, 1);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_LED0_RED\n");
-
-       if ((gpio_request(IGEP3_GPIO_LED0_GREEN, "gpio-led:green:d0") == 0) &&
-           (gpio_direction_output(IGEP3_GPIO_LED0_GREEN, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_LED0_GREEN, 0);
-               gpio_set_value(IGEP3_GPIO_LED0_GREEN, 1);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_LED0_GREEN\n");
-
-       if ((gpio_request(IGEP3_GPIO_LED1_RED, "gpio-led:red:d1") == 0) &&
-               (gpio_direction_output(IGEP3_GPIO_LED1_RED, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_LED1_RED, 0);
-               gpio_set_value(IGEP3_GPIO_LED1_RED, 1);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_LED1_RED\n");
-}
-#endif
-
-static int igep3_twl4030_gpio_setup(struct device *dev,
-               unsigned gpio, unsigned ngpio)
-{
-       /* gpio + 0 is "mmc0_cd" (input/IRQ) */
-       mmc[0].gpio_cd = gpio + 0;
-       omap2_hsmmc_init(mmc);
-
-       /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
-#if !defined(CONFIG_LEDS_GPIO) && !defined(CONFIG_LEDS_GPIO_MODULE)
-       if ((gpio_request(gpio+TWL4030_GPIO_MAX+1, "gpio-led:green:d1") == 0)
-           && (gpio_direction_output(gpio + TWL4030_GPIO_MAX + 1, 1) == 0)) {
-               gpio_export(gpio + TWL4030_GPIO_MAX + 1, 0);
-               gpio_set_value(gpio + TWL4030_GPIO_MAX + 1, 0);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_LED1_GREEN\n");
-#else
-       igep3_gpio_leds[3].gpio = gpio + TWL4030_GPIO_MAX + 1;
-#endif
-
-       return 0;
-};
-
-static struct twl4030_gpio_platform_data igep3_twl4030_gpio_pdata = {
-       .gpio_base      = OMAP_MAX_GPIO_LINES,
-       .irq_base       = TWL4030_GPIO_IRQ_BASE,
-       .irq_end        = TWL4030_GPIO_IRQ_END,
-       .use_leds       = true,
-       .setup          = igep3_twl4030_gpio_setup,
-};
-
-static struct twl4030_usb_data igep3_twl4030_usb_data = {
-       .usb_mode       = T2_USB_MODE_ULPI,
-};
-
-static struct platform_device *igep3_devices[] __initdata = {
-       &igep3_vwlan_device,
-};
-
-static void __init igep3_init_early(void)
-{
-       omap2_init_common_infrastructure();
-       omap2_init_common_devices(m65kxxxxam_sdrc_params,
-                                 m65kxxxxam_sdrc_params);
-}
-
-static struct twl4030_platform_data igep3_twl4030_pdata = {
-       .irq_base       = TWL4030_IRQ_BASE,
-       .irq_end        = TWL4030_IRQ_END,
-
-       /* platform_data for children goes here */
-       .usb            = &igep3_twl4030_usb_data,
-       .gpio           = &igep3_twl4030_gpio_pdata,
-       .vmmc1          = &igep3_vmmc1,
-       .vio            = &igep3_vio,
-};
-
-static struct i2c_board_info __initdata igep3_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags          = I2C_CLIENT_WAKE,
-               .irq            = INT_34XX_SYS_NIRQ,
-               .platform_data  = &igep3_twl4030_pdata,
-       },
-};
-
-static int __init igep3_i2c_init(void)
-{
-       omap_register_i2c_bus(1, 2600, igep3_i2c_boardinfo,
-                       ARRAY_SIZE(igep3_i2c_boardinfo));
-
-       return 0;
-}
-
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type = MUSB_INTERFACE_ULPI,
-       .mode           = MUSB_OTG,
-       .power          = 100,
-};
-
-#if defined(CONFIG_LIBERTAS_SDIO) || defined(CONFIG_LIBERTAS_SDIO_MODULE)
-
-static void __init igep3_wifi_bt_init(void)
-{
-       /* Configure MUX values for W-LAN + Bluetooth GPIO's */
-       omap_mux_init_gpio(IGEP3_GPIO_WIFI_NPD, OMAP_PIN_OUTPUT);
-       omap_mux_init_gpio(IGEP3_GPIO_WIFI_NRESET, OMAP_PIN_OUTPUT);
-       omap_mux_init_gpio(IGEP3_GPIO_BT_NRESET, OMAP_PIN_OUTPUT);
-
-       /* Set GPIO's for  W-LAN + Bluetooth combo module */
-       if ((gpio_request(IGEP3_GPIO_WIFI_NPD, "GPIO_WIFI_NPD") == 0) &&
-           (gpio_direction_output(IGEP3_GPIO_WIFI_NPD, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_WIFI_NPD, 0);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_WIFI_NPD\n");
-
-       if ((gpio_request(IGEP3_GPIO_WIFI_NRESET, "GPIO_WIFI_NRESET") == 0) &&
-           (gpio_direction_output(IGEP3_GPIO_WIFI_NRESET, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_WIFI_NRESET, 0);
-               gpio_set_value(IGEP3_GPIO_WIFI_NRESET, 0);
-               udelay(10);
-               gpio_set_value(IGEP3_GPIO_WIFI_NRESET, 1);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_WIFI_NRESET\n");
-
-       if ((gpio_request(IGEP3_GPIO_BT_NRESET, "GPIO_BT_NRESET") == 0) &&
-           (gpio_direction_output(IGEP3_GPIO_BT_NRESET, 1) == 0)) {
-               gpio_export(IGEP3_GPIO_BT_NRESET, 0);
-       } else
-               pr_warning("IGEP3: Could not obtain gpio GPIO_BT_NRESET\n");
-}
-#else
-void __init igep3_wifi_bt_init(void) {}
-#endif
-
-static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
-       .port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED,
-       .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
-       .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
-
-       .phy_reset = true,
-       .reset_gpio_port[0] = -EINVAL,
-       .reset_gpio_port[1] = IGEP3_GPIO_USBH_NRESET,
-       .reset_gpio_port[2] = -EINVAL,
-};
-
-#ifdef CONFIG_OMAP_MUX
-static struct omap_board_mux board_mux[] __initdata = {
-       OMAP3_MUX(I2C2_SDA, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
-       { .reg_offset = OMAP_MUX_TERMINATOR },
-};
-#endif
-
-static void __init igep3_init(void)
-{
-       omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
-
-       /* Register I2C busses and drivers */
-       igep3_i2c_init();
-       platform_add_devices(igep3_devices, ARRAY_SIZE(igep3_devices));
-       omap_serial_init();
-       usb_musb_init(&musb_board_data);
-       usbhs_init(&usbhs_bdata);
-
-       igep3_flash_init();
-       igep3_leds_init();
-
-       /*
-        * WLAN-BT combo module from MuRata which has a Marvell WLAN
-        * (88W8686) + CSR Bluetooth chipset. Uses SDIO interface.
-        */
-       igep3_wifi_bt_init();
-
-}
-
-MACHINE_START(IGEP0030, "IGEP OMAP3 module")
-       .boot_params    = 0x80000100,
-       .reserve        = omap_reserve,
-       .map_io         = omap3_map_io,
-       .init_early     = igep3_init_early,
-       .init_irq       = omap_init_irq,
-       .init_machine   = igep3_init,
-       .timer          = &omap_timer,
-MACHINE_END
index e2ba779..f7d6038 100644 (file)
@@ -22,7 +22,6 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/spi/spi.h>
-#include <linux/spi/ads7846.h>
 #include <linux/regulator/machine.h>
 #include <linux/i2c/twl.h>
 #include <linux/io.h>
 
 #include <asm/delay.h>
 #include <plat/usb.h>
+#include <plat/gpmc-smsc911x.h>
 
 #include "board-flash.h"
 #include "mux.h"
 #include "hsmmc.h"
 #include "control.h"
+#include "common-board-devices.h"
 
 #define LDP_SMSC911X_CS                1
 #define LDP_SMSC911X_GPIO      152
 #define DEBUG_BASE             0x08000000
 #define LDP_ETHR_START         DEBUG_BASE
 
-static struct resource ldp_smsc911x_resources[] = {
-       [0] = {
-               .start  = LDP_ETHR_START,
-               .end    = LDP_ETHR_START + SZ_4K,
-               .flags  = IORESOURCE_MEM,
-       },
-       [1] = {
-               .start  = 0,
-               .end    = 0,
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct smsc911x_platform_config ldp_smsc911x_config = {
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
-       .flags          = SMSC911X_USE_32BIT,
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-};
-
-static struct platform_device ldp_smsc911x_device = {
-       .name           = "smsc911x",
-       .id             = -1,
-       .num_resources  = ARRAY_SIZE(ldp_smsc911x_resources),
-       .resource       = ldp_smsc911x_resources,
-       .dev            = {
-               .platform_data = &ldp_smsc911x_config,
-       },
-};
-
 static uint32_t board_keymap[] = {
        KEY(0, 0, KEY_1),
        KEY(1, 0, KEY_2),
@@ -197,82 +168,16 @@ static struct platform_device ldp_gpio_keys_device = {
        },
 };
 
-static int ts_gpio;
-
-/**
- * @brief ads7846_dev_init : Requests & sets GPIO line for pen-irq
- *
- * @return - void. If request gpio fails then Flag KERN_ERR.
- */
-static void ads7846_dev_init(void)
-{
-       if (gpio_request(ts_gpio, "ads7846 irq") < 0) {
-               printk(KERN_ERR "can't get ads746 pen down GPIO\n");
-               return;
-       }
-
-       gpio_direction_input(ts_gpio);
-       gpio_set_debounce(ts_gpio, 310);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(ts_gpio);
-}
-
-static struct ads7846_platform_data tsc2046_config __initdata = {
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-};
-
-static struct omap2_mcspi_device_config tsc2046_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info ldp_spi_board_info[] __initdata = {
-       [0] = {
-               /*
-                * TSC2046 operates at a max freqency of 2MHz, so
-                * operate slightly below at 1.5MHz
-                */
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &tsc2046_mcspi_config,
-               .irq                    = 0,
-               .platform_data          = &tsc2046_config,
-       },
+static struct omap_smsc911x_platform_data smsc911x_cfg = {
+       .cs             = LDP_SMSC911X_CS,
+       .gpio_irq       = LDP_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT,
 };
 
 static inline void __init ldp_init_smsc911x(void)
 {
-       int eth_cs;
-       unsigned long cs_mem_base;
-       int eth_gpio = 0;
-
-       eth_cs = LDP_SMSC911X_CS;
-
-       if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
-               printk(KERN_ERR "Failed to request GPMC mem for smsc911x\n");
-               return;
-       }
-
-       ldp_smsc911x_resources[0].start = cs_mem_base + 0x0;
-       ldp_smsc911x_resources[0].end   = cs_mem_base + 0xff;
-       udelay(100);
-
-       eth_gpio = LDP_SMSC911X_GPIO;
-
-       ldp_smsc911x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
-
-       if (gpio_request(eth_gpio, "smsc911x irq") < 0) {
-               printk(KERN_ERR "Failed to request GPIO%d for smsc911x IRQ\n",
-                               eth_gpio);
-               return;
-       }
-       gpio_direction_input(eth_gpio);
+       gpmc_smsc911x_init(&smsc911x_cfg);
 }
 
 static struct platform_device ldp_lcd_device = {
@@ -360,19 +265,9 @@ static struct twl4030_platform_data ldp_twldata = {
        .keypad         = &ldp_kp_twl4030_data,
 };
 
-static struct i2c_board_info __initdata ldp_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &ldp_twldata,
-       },
-};
-
 static int __init omap_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, ldp_i2c_boardinfo,
-                       ARRAY_SIZE(ldp_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &ldp_twldata);
        omap_register_i2c_bus(2, 400, NULL, 0);
        omap_register_i2c_bus(3, 400, NULL, 0);
        return 0;
@@ -389,7 +284,6 @@ static struct omap2_hsmmc_info mmc[] __initdata = {
 };
 
 static struct platform_device *ldp_devices[] __initdata = {
-       &ldp_smsc911x_device,
        &ldp_lcd_device,
        &ldp_gpio_keys_device,
 };
@@ -400,12 +294,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static struct mtd_partition ldp_nand_partitions[] = {
        /* All the partition sizes are listed in terms of NAND block size */
        {
@@ -446,13 +334,9 @@ static void __init omap_ldp_init(void)
        ldp_init_smsc911x();
        omap_i2c_init();
        platform_add_devices(ldp_devices, ARRAY_SIZE(ldp_devices));
-       ts_gpio = 54;
-       ldp_spi_board_info[0].irq = gpio_to_irq(ts_gpio);
-       spi_register_board_info(ldp_spi_board_info,
-                               ARRAY_SIZE(ldp_spi_board_info));
-       ads7846_dev_init();
+       omap_ads7846_init(1, 54, 310, NULL);
        omap_serial_init();
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        board_nand_init(ldp_nand_partitions,
                ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
 
index e710cd9..8d74318 100644 (file)
@@ -106,14 +106,13 @@ static void __init n8x0_usb_init(void)
        static char     announce[] __initdata = KERN_INFO "TUSB 6010\n";
 
        /* PM companion chip power control pin */
-       ret = gpio_request(TUSB6010_GPIO_ENABLE, "TUSB6010 enable");
+       ret = gpio_request_one(TUSB6010_GPIO_ENABLE, GPIOF_OUT_INIT_LOW,
+                              "TUSB6010 enable");
        if (ret != 0) {
                printk(KERN_ERR "Could not get TUSB power GPIO%i\n",
                       TUSB6010_GPIO_ENABLE);
                return;
        }
-       gpio_direction_output(TUSB6010_GPIO_ENABLE, 0);
-
        tusb_set_power(0);
 
        ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2,
@@ -494,8 +493,12 @@ static struct omap_mmc_platform_data mmc1_data = {
 
 static struct omap_mmc_platform_data *mmc_data[OMAP24XX_NR_MMC];
 
-static void __init n8x0_mmc_init(void)
+static struct gpio n810_emmc_gpios[] __initdata = {
+       { N810_EMMC_VSD_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vddf" },
+       { N810_EMMC_VIO_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vdd"  },
+};
 
+static void __init n8x0_mmc_init(void)
 {
        int err;
 
@@ -512,27 +515,18 @@ static void __init n8x0_mmc_init(void)
                mmc1_data.slots[1].ban_openended = 1;
        }
 
-       err = gpio_request(N8X0_SLOT_SWITCH_GPIO, "MMC slot switch");
+       err = gpio_request_one(N8X0_SLOT_SWITCH_GPIO, GPIOF_OUT_INIT_LOW,
+                              "MMC slot switch");
        if (err)
                return;
 
-       gpio_direction_output(N8X0_SLOT_SWITCH_GPIO, 0);
-
        if (machine_is_nokia_n810()) {
-               err = gpio_request(N810_EMMC_VSD_GPIO, "MMC slot 2 Vddf");
-               if (err) {
-                       gpio_free(N8X0_SLOT_SWITCH_GPIO);
-                       return;
-               }
-               gpio_direction_output(N810_EMMC_VSD_GPIO, 0);
-
-               err = gpio_request(N810_EMMC_VIO_GPIO, "MMC slot 2 Vdd");
+               err = gpio_request_array(n810_emmc_gpios,
+                                        ARRAY_SIZE(n810_emmc_gpios));
                if (err) {
                        gpio_free(N8X0_SLOT_SWITCH_GPIO);
-                       gpio_free(N810_EMMC_VSD_GPIO);
                        return;
                }
-               gpio_direction_output(N810_EMMC_VIO_GPIO, 0);
        }
 
        mmc_data[0] = &mmc1_data;
index 97750d4..be71426 100644 (file)
@@ -52,6 +52,7 @@
 #include "hsmmc.h"
 #include "timer-gp.h"
 #include "pm.h"
+#include "common-board-devices.h"
 
 #define NAND_BLOCK_SIZE                SZ_128K
 
@@ -79,6 +80,12 @@ static u8 omap3_beagle_get_rev(void)
        return omap3_beagle_version;
 }
 
+static struct gpio omap3_beagle_rev_gpios[] __initdata = {
+       { 171, GPIOF_IN, "rev_id_0"    },
+       { 172, GPIOF_IN, "rev_id_1" },
+       { 173, GPIOF_IN, "rev_id_2"    },
+};
+
 static void __init omap3_beagle_init_rev(void)
 {
        int ret;
@@ -88,21 +95,13 @@ static void __init omap3_beagle_init_rev(void)
        omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
        omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);
 
-       ret = gpio_request(171, "rev_id_0");
-       if (ret < 0)
-               goto fail0;
-
-       ret = gpio_request(172, "rev_id_1");
-       if (ret < 0)
-               goto fail1;
-
-       ret = gpio_request(173, "rev_id_2");
-       if (ret < 0)
-               goto fail2;
-
-       gpio_direction_input(171);
-       gpio_direction_input(172);
-       gpio_direction_input(173);
+       ret = gpio_request_array(omap3_beagle_rev_gpios,
+                                ARRAY_SIZE(omap3_beagle_rev_gpios));
+       if (ret < 0) {
+               printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
+               omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
+               return;
+       }
 
        beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
                        | (gpio_get_value(173) << 2);
@@ -128,18 +127,6 @@ static void __init omap3_beagle_init_rev(void)
                printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
                omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
        }
-
-       return;
-
-fail2:
-       gpio_free(172);
-fail1:
-       gpio_free(171);
-fail0:
-       printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
-       omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
-
-       return;
 }
 
 static struct mtd_partition omap3beagle_nand_partitions[] = {
@@ -173,15 +160,6 @@ static struct mtd_partition omap3beagle_nand_partitions[] = {
        },
 };
 
-static struct omap_nand_platform_data omap3beagle_nand_data = {
-       .options        = NAND_BUSWIDTH_16,
-       .parts          = omap3beagle_nand_partitions,
-       .nr_parts       = ARRAY_SIZE(omap3beagle_nand_partitions),
-       .dma_channel    = -1,           /* disable DMA in OMAP NAND driver */
-       .nand_setup     = NULL,
-       .dev_ready      = NULL,
-};
-
 /* DSS */
 
 static int beagle_enable_dvi(struct omap_dss_device *dssdev)
@@ -243,13 +221,10 @@ static void __init beagle_display_init(void)
 {
        int r;
 
-       r = gpio_request(beagle_dvi_device.reset_gpio, "DVI reset");
-       if (r < 0) {
+       r = gpio_request_one(beagle_dvi_device.reset_gpio, GPIOF_OUT_INIT_LOW,
+                            "DVI reset");
+       if (r < 0)
                printk(KERN_ERR "Unable to get DVI reset GPIO\n");
-               return;
-       }
-
-       gpio_direction_output(beagle_dvi_device.reset_gpio, 0);
 }
 
 #include "sdram-micron-mt46h32m32lf-6.h"
@@ -276,7 +251,7 @@ static struct gpio_led gpio_leds[];
 static int beagle_twl_gpio_setup(struct device *dev,
                unsigned gpio, unsigned ngpio)
 {
-       int r;
+       int r, usb_pwr_level;
 
        if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
                mmc[0].gpio_wp = -EINVAL;
@@ -295,66 +270,46 @@ static int beagle_twl_gpio_setup(struct device *dev,
        beagle_vmmc1_supply.dev = mmc[0].dev;
        beagle_vsim_supply.dev = mmc[0].dev;
 
-       /* REVISIT: need ehci-omap hooks for external VBUS
-        * power switch and overcurrent detect
-        */
-       if (omap3_beagle_get_rev() != OMAP3BEAGLE_BOARD_XM) {
-               r = gpio_request(gpio + 1, "EHCI_nOC");
-               if (!r) {
-                       r = gpio_direction_input(gpio + 1);
-                       if (r)
-                               gpio_free(gpio + 1);
-               }
-               if (r)
-                       pr_err("%s: unable to configure EHCI_nOC\n", __func__);
-       }
-
        /*
         * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
         * high / others active low)
-        */
-       gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
-       if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
-               gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1);
-       else
-               gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
-
-       /* DVI reset GPIO is different between beagle revisions */
-       if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM)
-               beagle_dvi_device.reset_gpio = 129;
-       else
-               beagle_dvi_device.reset_gpio = 170;
-
-       /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
-       gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
-
-       /*
-        * gpio + 1 on Xm controls the TFP410's enable line (active low)
-        * gpio + 2 control varies depending on the board rev as follows:
-        * P7/P8 revisions(prototype): Camera EN
-        * A2+ revisions (production): LDO (supplies DVI, serial, led blocks)
+        * DVI reset GPIO is different between beagle revisions
         */
        if (omap3_beagle_get_rev() == OMAP3BEAGLE_BOARD_XM) {
-               r = gpio_request(gpio + 1, "nDVI_PWR_EN");
-               if (!r) {
-                       r = gpio_direction_output(gpio + 1, 0);
-                       if (r)
-                               gpio_free(gpio + 1);
-               }
+               usb_pwr_level = GPIOF_OUT_INIT_HIGH;
+               beagle_dvi_device.reset_gpio = 129;
+               /*
+                * gpio + 1 on Xm controls the TFP410's enable line (active low)
+                * gpio + 2 control varies depending on the board rev as below:
+                * P7/P8 revisions(prototype): Camera EN
+                * A2+ revisions (production): LDO (DVI, serial, led blocks)
+                */
+               r = gpio_request_one(gpio + 1, GPIOF_OUT_INIT_LOW,
+                                    "nDVI_PWR_EN");
                if (r)
                        pr_err("%s: unable to configure nDVI_PWR_EN\n",
                                __func__);
-               r = gpio_request(gpio + 2, "DVI_LDO_EN");
-               if (!r) {
-                       r = gpio_direction_output(gpio + 2, 1);
-                       if (r)
-                               gpio_free(gpio + 2);
-               }
+               r = gpio_request_one(gpio + 2, GPIOF_OUT_INIT_HIGH,
+                                    "DVI_LDO_EN");
                if (r)
                        pr_err("%s: unable to configure DVI_LDO_EN\n",
                                __func__);
+       } else {
+               usb_pwr_level = GPIOF_OUT_INIT_LOW;
+               beagle_dvi_device.reset_gpio = 170;
+               /*
+                * REVISIT: need ehci-omap hooks for external VBUS
+                * power switch and overcurrent detect
+                */
+               if (gpio_request_one(gpio + 1, GPIOF_IN, "EHCI_nOC"))
+                       pr_err("%s: unable to configure EHCI_nOC\n", __func__);
        }
 
+       gpio_request_one(gpio + TWL4030_GPIO_MAX, usb_pwr_level, "nEN_USB_PWR");
+
+       /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
+       gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
+
        return 0;
 }
 
@@ -453,15 +408,6 @@ static struct twl4030_platform_data beagle_twldata = {
        .vpll2          = &beagle_vpll2,
 };
 
-static struct i2c_board_info __initdata beagle_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &beagle_twldata,
-       },
-};
-
 static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
        {
                I2C_BOARD_INFO("eeprom", 0x50),
@@ -470,8 +416,7 @@ static struct i2c_board_info __initdata beagle_i2c_eeprom[] = {
 
 static int __init omap3_beagle_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, beagle_i2c_boardinfo,
-                       ARRAY_SIZE(beagle_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &beagle_twldata);
        /* Bus 3 is attached to the DVI port where devices like the pico DLP
         * projector don't work reliably with 400kHz */
        omap_register_i2c_bus(3, 100, beagle_i2c_eeprom, ARRAY_SIZE(beagle_i2c_eeprom));
@@ -551,39 +496,6 @@ static struct platform_device *omap3_beagle_devices[] __initdata = {
        &keys_gpio,
 };
 
-static void __init omap3beagle_flash_init(void)
-{
-       u8 cs = 0;
-       u8 nandcs = GPMC_CS_NUM + 1;
-
-       /* find out the chip-select on which NAND exists */
-       while (cs < GPMC_CS_NUM) {
-               u32 ret = 0;
-               ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
-               if ((ret & 0xC00) == 0x800) {
-                       printk(KERN_INFO "Found NAND on CS%d\n", cs);
-                       if (nandcs > GPMC_CS_NUM)
-                               nandcs = cs;
-               }
-               cs++;
-       }
-
-       if (nandcs > GPMC_CS_NUM) {
-               printk(KERN_INFO "NAND: Unable to find configuration "
-                                "in GPMC\n ");
-               return;
-       }
-
-       if (nandcs < GPMC_CS_NUM) {
-               omap3beagle_nand_data.cs = nandcs;
-
-               printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
-               if (gpmc_nand_init(&omap3beagle_nand_data) < 0)
-                       printk(KERN_ERR "Unable to register NAND device\n");
-       }
-}
-
 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 
        .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
@@ -602,12 +514,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static void __init beagle_opp_init(void)
 {
        int r = 0;
@@ -665,13 +571,13 @@ static void __init omap3_beagle_init(void)
        omap_serial_init();
 
        omap_mux_init_gpio(170, OMAP_PIN_INPUT);
-       gpio_request(170, "DVI_nPD");
        /* REVISIT leave DVI powered down until it's needed ... */
-       gpio_direction_output(170, true);
+       gpio_request_one(170, GPIOF_OUT_INIT_HIGH, "DVI_nPD");
 
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
-       omap3beagle_flash_init();
+       omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
+                            ARRAY_SIZE(omap3beagle_nand_partitions));
 
        /* Ensure SDRC pins are mux'd for self-refresh */
        omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
index 7f94ccc..b4d4346 100644 (file)
@@ -50,6 +50,7 @@
 #include "mux.h"
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define OMAP3_EVM_TS_GPIO      175
 #define OMAP3_EVM_EHCI_VBUS    22
@@ -101,49 +102,20 @@ static void __init omap3_evm_get_revision(void)
 }
 
 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
-static struct resource omap3evm_smsc911x_resources[] = {
-       [0] =   {
-               .start  = OMAP3EVM_ETHR_START,
-               .end    = (OMAP3EVM_ETHR_START + OMAP3EVM_ETHR_SIZE - 1),
-               .flags  = IORESOURCE_MEM,
-       },
-       [1] =   {
-               .start  = OMAP_GPIO_IRQ(OMAP3EVM_ETHR_GPIO_IRQ),
-               .end    = OMAP_GPIO_IRQ(OMAP3EVM_ETHR_GPIO_IRQ),
-               .flags  = (IORESOURCE_IRQ | IRQF_TRIGGER_LOW),
-       },
-};
+#include <plat/gpmc-smsc911x.h>
 
-static struct smsc911x_platform_config smsc911x_config = {
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
-       .flags          = (SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS),
-};
-
-static struct platform_device omap3evm_smsc911x_device = {
-       .name           = "smsc911x",
-       .id             = -1,
-       .num_resources  = ARRAY_SIZE(omap3evm_smsc911x_resources),
-       .resource       = &omap3evm_smsc911x_resources[0],
-       .dev            = {
-               .platform_data = &smsc911x_config,
-       },
+static struct omap_smsc911x_platform_data smsc911x_cfg = {
+       .cs             = OMAP3EVM_SMSC911X_CS,
+       .gpio_irq       = OMAP3EVM_ETHR_GPIO_IRQ,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
 };
 
 static inline void __init omap3evm_init_smsc911x(void)
 {
-       int eth_cs, eth_rst;
        struct clk *l3ck;
        unsigned int rate;
 
-       if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
-               eth_rst = OMAP3EVM_GEN1_ETHR_GPIO_RST;
-       else
-               eth_rst = OMAP3EVM_GEN2_ETHR_GPIO_RST;
-
-       eth_cs = OMAP3EVM_SMSC911X_CS;
-
        l3ck = clk_get(NULL, "l3_ck");
        if (IS_ERR(l3ck))
                rate = 100000000;
@@ -152,33 +124,13 @@ static inline void __init omap3evm_init_smsc911x(void)
 
        /* Configure ethernet controller reset gpio */
        if (cpu_is_omap3430()) {
-               if (gpio_request(eth_rst, "SMSC911x gpio") < 0) {
-                       pr_err(KERN_ERR "Failed to request %d for smsc911x\n",
-                                       eth_rst);
-                       return;
-               }
-
-               if (gpio_direction_output(eth_rst, 1) < 0) {
-                       pr_err(KERN_ERR "Failed to set direction of %d for" \
-                                       " smsc911x\n", eth_rst);
-                       return;
-               }
-               /* reset pulse to ethernet controller*/
-               usleep_range(150, 220);
-               gpio_set_value(eth_rst, 0);
-               usleep_range(150, 220);
-               gpio_set_value(eth_rst, 1);
-               usleep_range(1, 2);
-       }
-
-       if (gpio_request(OMAP3EVM_ETHR_GPIO_IRQ, "SMSC911x irq") < 0) {
-               printk(KERN_ERR "Failed to request GPIO%d for smsc911x IRQ\n",
-                       OMAP3EVM_ETHR_GPIO_IRQ);
-               return;
+               if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
+                       smsc911x_cfg.gpio_reset = OMAP3EVM_GEN1_ETHR_GPIO_RST;
+               else
+                       smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
        }
 
-       gpio_direction_input(OMAP3EVM_ETHR_GPIO_IRQ);
-       platform_device_register(&omap3evm_smsc911x_device);
+       gpmc_smsc911x_init(&smsc911x_cfg);
 }
 
 #else
@@ -197,6 +149,15 @@ static inline void __init omap3evm_init_smsc911x(void) { return; }
 #define OMAP3EVM_LCD_PANEL_BKLIGHT_GPIO        210
 #define OMAP3EVM_DVI_PANEL_EN_GPIO     199
 
+static struct gpio omap3_evm_dss_gpios[] __initdata = {
+       { OMAP3EVM_LCD_PANEL_RESB,  GPIOF_OUT_INIT_HIGH, "lcd_panel_resb"  },
+       { OMAP3EVM_LCD_PANEL_INI,   GPIOF_OUT_INIT_HIGH, "lcd_panel_ini"   },
+       { OMAP3EVM_LCD_PANEL_QVGA,  GPIOF_OUT_INIT_LOW,  "lcd_panel_qvga"  },
+       { OMAP3EVM_LCD_PANEL_LR,    GPIOF_OUT_INIT_HIGH, "lcd_panel_lr"    },
+       { OMAP3EVM_LCD_PANEL_UD,    GPIOF_OUT_INIT_HIGH, "lcd_panel_ud"    },
+       { OMAP3EVM_LCD_PANEL_ENVDD, GPIOF_OUT_INIT_LOW,  "lcd_panel_envdd" },
+};
+
 static int lcd_enabled;
 static int dvi_enabled;
 
@@ -204,61 +165,10 @@ static void __init omap3_evm_display_init(void)
 {
        int r;
 
-       r = gpio_request(OMAP3EVM_LCD_PANEL_RESB, "lcd_panel_resb");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_resb\n");
-               return;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_RESB, 1);
-
-       r = gpio_request(OMAP3EVM_LCD_PANEL_INI, "lcd_panel_ini");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_ini\n");
-               goto err_1;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_INI, 1);
-
-       r = gpio_request(OMAP3EVM_LCD_PANEL_QVGA, "lcd_panel_qvga");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_qvga\n");
-               goto err_2;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_QVGA, 0);
-
-       r = gpio_request(OMAP3EVM_LCD_PANEL_LR, "lcd_panel_lr");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_lr\n");
-               goto err_3;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_LR, 1);
-
-       r = gpio_request(OMAP3EVM_LCD_PANEL_UD, "lcd_panel_ud");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_ud\n");
-               goto err_4;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_UD, 1);
-
-       r = gpio_request(OMAP3EVM_LCD_PANEL_ENVDD, "lcd_panel_envdd");
-       if (r) {
-               printk(KERN_ERR "failed to get lcd_panel_envdd\n");
-               goto err_5;
-       }
-       gpio_direction_output(OMAP3EVM_LCD_PANEL_ENVDD, 0);
-
-       return;
-
-err_5:
-       gpio_free(OMAP3EVM_LCD_PANEL_UD);
-err_4:
-       gpio_free(OMAP3EVM_LCD_PANEL_LR);
-err_3:
-       gpio_free(OMAP3EVM_LCD_PANEL_QVGA);
-err_2:
-       gpio_free(OMAP3EVM_LCD_PANEL_INI);
-err_1:
-       gpio_free(OMAP3EVM_LCD_PANEL_RESB);
-
+       r = gpio_request_array(omap3_evm_dss_gpios,
+                              ARRAY_SIZE(omap3_evm_dss_gpios));
+       if (r)
+               printk(KERN_ERR "failed to get lcd_panel_* gpios\n");
 }
 
 static int omap3_evm_enable_lcd(struct omap_dss_device *dssdev)
@@ -448,7 +358,7 @@ static struct platform_device leds_gpio = {
 static int omap3evm_twl_gpio_setup(struct device *dev,
                unsigned gpio, unsigned ngpio)
 {
-       int r;
+       int r, lcd_bl_en;
 
        /* gpio + 0 is "mmc0_cd" (input/IRQ) */
        omap_mux_init_gpio(63, OMAP_PIN_INPUT);
@@ -465,16 +375,14 @@ static int omap3evm_twl_gpio_setup(struct device *dev,
         */
 
        /* TWL4030_GPIO_MAX + 0 == ledA, LCD Backlight control */
-       r = gpio_request(gpio + TWL4030_GPIO_MAX, "EN_LCD_BKL");
-       if (!r)
-               r = gpio_direction_output(gpio + TWL4030_GPIO_MAX,
-                       (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) ? 1 : 0);
+       lcd_bl_en = get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2 ?
+               GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
+       r = gpio_request_one(gpio + TWL4030_GPIO_MAX, lcd_bl_en, "EN_LCD_BKL");
        if (r)
                printk(KERN_ERR "failed to get/set lcd_bkl gpio\n");
 
        /* gpio + 7 == DVI Enable */
-       gpio_request(gpio + 7, "EN_DVI");
-       gpio_direction_output(gpio + 7, 0);
+       gpio_request_one(gpio + 7, GPIOF_OUT_INIT_LOW, "EN_DVI");
 
        /* TWL4030_GPIO_MAX + 1 == ledB (out, active low LED) */
        gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
@@ -652,78 +560,18 @@ static struct twl4030_platform_data omap3evm_twldata = {
        .vdac           = &omap3_evm_vdac,
        .vpll2          = &omap3_evm_vpll2,
        .vio            = &omap3evm_vio,
-};
-
-static struct i2c_board_info __initdata omap3evm_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &omap3evm_twldata,
-       },
+       .vmmc1          = &omap3evm_vmmc1,
+       .vsim           = &omap3evm_vsim,
 };
 
 static int __init omap3_evm_i2c_init(void)
 {
-       /*
-        * REVISIT: These entries can be set in omap3evm_twl_data
-        * after a merge with MFD tree
-        */
-       omap3evm_twldata.vmmc1 = &omap3evm_vmmc1;
-       omap3evm_twldata.vsim = &omap3evm_vsim;
-
-       omap_register_i2c_bus(1, 2600, omap3evm_i2c_boardinfo,
-                       ARRAY_SIZE(omap3evm_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &omap3evm_twldata);
        omap_register_i2c_bus(2, 400, NULL, 0);
        omap_register_i2c_bus(3, 400, NULL, 0);
        return 0;
 }
 
-static void ads7846_dev_init(void)
-{
-       if (gpio_request(OMAP3_EVM_TS_GPIO, "ADS7846 pendown") < 0)
-               printk(KERN_ERR "can't get ads7846 pen down GPIO\n");
-
-       gpio_direction_input(OMAP3_EVM_TS_GPIO);
-       gpio_set_debounce(OMAP3_EVM_TS_GPIO, 310);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(OMAP3_EVM_TS_GPIO);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 3,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-       .settle_delay_usecs     = 150,
-       .wakeup                         = true,
-};
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info omap3evm_spi_board_info[] = {
-       [0] = {
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(OMAP3_EVM_TS_GPIO),
-               .platform_data          = &ads7846_config,
-       },
-};
-
 static struct omap_board_config_kernel omap3_evm_config[] __initdata = {
 };
 
@@ -825,6 +673,11 @@ static struct omap_musb_board_data musb_board_data = {
        .power                  = 100,
 };
 
+static struct gpio omap3_evm_ehci_gpios[] __initdata = {
+       { OMAP3_EVM_EHCI_VBUS,   GPIOF_OUT_INIT_HIGH,  "enable EHCI VBUS" },
+       { OMAP3_EVM_EHCI_SELECT, GPIOF_OUT_INIT_LOW,   "select EHCI port" },
+};
+
 static void __init omap3_evm_init(void)
 {
        omap3_evm_get_revision();
@@ -841,9 +694,6 @@ static void __init omap3_evm_init(void)
 
        omap_display_init(&omap3_evm_dss_data);
 
-       spi_register_board_info(omap3evm_spi_board_info,
-                               ARRAY_SIZE(omap3evm_spi_board_info));
-
        omap_serial_init();
 
        /* OMAP3EVM uses ISP1504 phy and so register nop transceiver */
@@ -851,16 +701,12 @@ static void __init omap3_evm_init(void)
 
        if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
                /* enable EHCI VBUS using GPIO22 */
-               omap_mux_init_gpio(22, OMAP_PIN_INPUT_PULLUP);
-               gpio_request(OMAP3_EVM_EHCI_VBUS, "enable EHCI VBUS");
-               gpio_direction_output(OMAP3_EVM_EHCI_VBUS, 0);
-               gpio_set_value(OMAP3_EVM_EHCI_VBUS, 1);
-
+               omap_mux_init_gpio(OMAP3_EVM_EHCI_VBUS, OMAP_PIN_INPUT_PULLUP);
                /* Select EHCI port on main board */
-               omap_mux_init_gpio(61, OMAP_PIN_INPUT_PULLUP);
-               gpio_request(OMAP3_EVM_EHCI_SELECT, "select EHCI port");
-               gpio_direction_output(OMAP3_EVM_EHCI_SELECT, 0);
-               gpio_set_value(OMAP3_EVM_EHCI_SELECT, 0);
+               omap_mux_init_gpio(OMAP3_EVM_EHCI_SELECT,
+                                  OMAP_PIN_INPUT_PULLUP);
+               gpio_request_array(omap3_evm_ehci_gpios,
+                                  ARRAY_SIZE(omap3_evm_ehci_gpios));
 
                /* setup EHCI phy reset config */
                omap_mux_init_gpio(21, OMAP_PIN_INPUT_PULLUP);
@@ -876,7 +722,7 @@ static void __init omap3_evm_init(void)
        }
        usb_musb_init(&musb_board_data);
        usbhs_init(&usbhs_bdata);
-       ads7846_dev_init();
+       omap_ads7846_init(1, OMAP3_EVM_TS_GPIO, 310, NULL);
        omap3evm_init_smsc911x();
        omap3_evm_display_init();
 
index b726943..60d9be4 100644 (file)
@@ -37,6 +37,7 @@
 #include "hsmmc.h"
 #include "timer-gp.h"
 #include "control.h"
+#include "common-board-devices.h"
 
 #include <plat/mux.h>
 #include <plat/board.h>
@@ -93,19 +94,9 @@ static struct twl4030_platform_data omap3logic_twldata = {
        .vmmc1          = &omap3logic_vmmc1,
 };
 
-static struct i2c_board_info __initdata omap3logic_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &omap3logic_twldata,
-       },
-};
-
 static int __init omap3logic_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, omap3logic_i2c_boardinfo,
-                               ARRAY_SIZE(omap3logic_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &omap3logic_twldata);
        return 0;
 }
 
@@ -147,7 +138,6 @@ static struct omap_smsc911x_platform_data __initdata board_smsc911x_data = {
        .cs             = OMAP3LOGIC_SMSC911X_CS,
        .gpio_irq       = -EINVAL,
        .gpio_reset     = -EINVAL,
-       .flags          = IORESOURCE_IRQ_LOWLEVEL,
 };
 
 /* TODO/FIXME (comment by Peter Barada, LogicPD):
index 1db1549..1d10736 100644 (file)
@@ -22,7 +22,6 @@
 #include <linux/platform_device.h>
 
 #include <linux/spi/spi.h>
-#include <linux/spi/ads7846.h>
 #include <linux/regulator/machine.h>
 #include <linux/i2c/twl.h>
 #include <linux/wl12xx.h>
@@ -52,6 +51,7 @@
 #include "mux.h"
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define PANDORA_WIFI_IRQ_GPIO          21
 #define PANDORA_WIFI_NRESET_GPIO       23
@@ -305,24 +305,13 @@ static int omap3pandora_twl_gpio_setup(struct device *dev,
 
        /* gpio + 13 drives 32kHz buffer for wifi module */
        gpio_32khz = gpio + 13;
-       ret = gpio_request(gpio_32khz, "wifi 32kHz");
+       ret = gpio_request_one(gpio_32khz, GPIOF_OUT_INIT_HIGH, "wifi 32kHz");
        if (ret < 0) {
                pr_err("Cannot get GPIO line %d, ret=%d\n", gpio_32khz, ret);
-               goto fail;
-       }
-
-       ret = gpio_direction_output(gpio_32khz, 1);
-       if (ret < 0) {
-               pr_err("Cannot set GPIO line %d, ret=%d\n", gpio_32khz, ret);
-               goto fail_direction;
+               return -ENODEV;
        }
 
        return 0;
-
-fail_direction:
-       gpio_free(gpio_32khz);
-fail:
-       return -ENODEV;
 }
 
 static struct twl4030_gpio_platform_data omap3pandora_gpio_data = {
@@ -544,15 +533,6 @@ static struct twl4030_platform_data omap3pandora_twldata = {
        .bci            = &pandora_bci_data,
 };
 
-static struct i2c_board_info __initdata omap3pandora_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("tps65950", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &omap3pandora_twldata,
-       },
-};
-
 static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
        {
                I2C_BOARD_INFO("bq27500", 0x55),
@@ -562,61 +542,15 @@ static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
 
 static int __init omap3pandora_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, omap3pandora_i2c_boardinfo,
-                       ARRAY_SIZE(omap3pandora_i2c_boardinfo));
+       omap3_pmic_init("tps65950", &omap3pandora_twldata);
        /* i2c2 pins are not connected */
        omap_register_i2c_bus(3, 100, omap3pandora_i2c3_boardinfo,
                        ARRAY_SIZE(omap3pandora_i2c3_boardinfo));
        return 0;
 }
 
-static void __init omap3pandora_ads7846_init(void)
-{
-       int gpio = OMAP3_PANDORA_TS_GPIO;
-       int ret;
-
-       ret = gpio_request(gpio, "ads7846_pen_down");
-       if (ret < 0) {
-               printk(KERN_ERR "Failed to request GPIO %d for "
-                               "ads7846 pen down IRQ\n", gpio);
-               return;
-       }
-
-       gpio_direction_input(gpio);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(OMAP3_PANDORA_TS_GPIO);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 3,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-};
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
 static struct spi_board_info omap3pandora_spi_board_info[] __initdata = {
        {
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(OMAP3_PANDORA_TS_GPIO),
-               .platform_data          = &ads7846_config,
-       }, {
                .modalias               = "tpo_td043mtea1_panel_spi",
                .bus_num                = 1,
                .chip_select            = 1,
@@ -639,14 +573,10 @@ static void __init pandora_wl1251_init(void)
 
        memset(&pandora_wl1251_pdata, 0, sizeof(pandora_wl1251_pdata));
 
-       ret = gpio_request(PANDORA_WIFI_IRQ_GPIO, "wl1251 irq");
+       ret = gpio_request_one(PANDORA_WIFI_IRQ_GPIO, GPIOF_IN, "wl1251 irq");
        if (ret < 0)
                goto fail;
 
-       ret = gpio_direction_input(PANDORA_WIFI_IRQ_GPIO);
-       if (ret < 0)
-               goto fail_irq;
-
        pandora_wl1251_pdata.irq = gpio_to_irq(PANDORA_WIFI_IRQ_GPIO);
        if (pandora_wl1251_pdata.irq < 0)
                goto fail_irq;
@@ -688,12 +618,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static void __init omap3pandora_init(void)
 {
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
@@ -705,9 +629,9 @@ static void __init omap3pandora_init(void)
        omap_serial_init();
        spi_register_board_info(omap3pandora_spi_board_info,
                        ARRAY_SIZE(omap3pandora_spi_board_info));
-       omap3pandora_ads7846_init();
+       omap_ads7846_init(1, OMAP3_PANDORA_TS_GPIO, 0, NULL);
        usbhs_init(&usbhs_bdata);
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        gpmc_nand_init(&pandora_nand_data);
 
        /* Ensure SDRC pins are mux'd for self-refresh */
index a72c90a..0c108a2 100644 (file)
@@ -45,7 +45,6 @@
 #include <plat/mcspi.h>
 #include <linux/input/matrix_keypad.h>
 #include <linux/spi/spi.h>
-#include <linux/spi/ads7846.h>
 #include <linux/interrupt.h>
 #include <linux/smsc911x.h>
 #include <linux/i2c/at24.h>
 #include "mux.h"
 #include "hsmmc.h"
 #include "timer-gp.h"
+#include "common-board-devices.h"
 
 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
+#include <plat/gpmc-smsc911x.h>
+
 #define OMAP3STALKER_ETHR_START        0x2c000000
 #define OMAP3STALKER_ETHR_SIZE 1024
 #define OMAP3STALKER_ETHR_GPIO_IRQ     19
 #define OMAP3STALKER_SMC911X_CS        5
 
-static struct resource omap3stalker_smsc911x_resources[] = {
-       [0] = {
-              .start   = OMAP3STALKER_ETHR_START,
-              .end     =
-              (OMAP3STALKER_ETHR_START + OMAP3STALKER_ETHR_SIZE - 1),
-              .flags   = IORESOURCE_MEM,
-       },
-       [1] = {
-              .start   = OMAP_GPIO_IRQ(OMAP3STALKER_ETHR_GPIO_IRQ),
-              .end     = OMAP_GPIO_IRQ(OMAP3STALKER_ETHR_GPIO_IRQ),
-              .flags   = (IORESOURCE_IRQ | IRQF_TRIGGER_LOW),
-       },
-};
-
-static struct smsc911x_platform_config smsc911x_config = {
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
+static struct omap_smsc911x_platform_data smsc911x_cfg = {
+       .cs             = OMAP3STALKER_SMC911X_CS,
+       .gpio_irq       = OMAP3STALKER_ETHR_GPIO_IRQ,
+       .gpio_reset     = -EINVAL,
        .flags          = (SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS),
 };
 
-static struct platform_device omap3stalker_smsc911x_device = {
-       .name           = "smsc911x",
-       .id             = -1,
-       .num_resources  = ARRAY_SIZE(omap3stalker_smsc911x_resources),
-       .resource       = &omap3stalker_smsc911x_resources[0],
-       .dev            = {
-               .platform_data  = &smsc911x_config,
-       },
-};
-
 static inline void __init omap3stalker_init_eth(void)
 {
-       int eth_cs;
        struct clk *l3ck;
        unsigned int rate;
 
-       eth_cs = OMAP3STALKER_SMC911X_CS;
-
        l3ck = clk_get(NULL, "l3_ck");
        if (IS_ERR(l3ck))
                rate = 100000000;
@@ -107,16 +82,7 @@ static inline void __init omap3stalker_init_eth(void)
                rate = clk_get_rate(l3ck);
 
        omap_mux_init_gpio(19, OMAP_PIN_INPUT_PULLUP);
-       if (gpio_request(OMAP3STALKER_ETHR_GPIO_IRQ, "SMC911x irq") < 0) {
-               printk(KERN_ERR
-                      "Failed to request GPIO%d for smc911x IRQ\n",
-                      OMAP3STALKER_ETHR_GPIO_IRQ);
-               return;
-       }
-
-       gpio_direction_input(OMAP3STALKER_ETHR_GPIO_IRQ);
-
-       platform_device_register(&omap3stalker_smsc911x_device);
+       gpmc_smsc911x_init(&smsc911x_cfg);
 }
 
 #else
@@ -365,12 +331,11 @@ omap3stalker_twl_gpio_setup(struct device *dev,
         */
 
        /* TWL4030_GPIO_MAX + 0 == ledA, LCD Backlight control */
-       gpio_request(gpio + TWL4030_GPIO_MAX, "EN_LCD_BKL");
-       gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
+       gpio_request_one(gpio + TWL4030_GPIO_MAX, GPIOF_OUT_INIT_LOW,
+                        "EN_LCD_BKL");
 
        /* gpio + 7 == DVI Enable */
-       gpio_request(gpio + 7, "EN_DVI");
-       gpio_direction_output(gpio + 7, 0);
+       gpio_request_one(gpio + 7, GPIOF_OUT_INIT_LOW, "EN_DVI");
 
        /* TWL4030_GPIO_MAX + 1 == ledB (out, mmc0) */
        gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
@@ -489,15 +454,8 @@ static struct twl4030_platform_data omap3stalker_twldata = {
        .codec          = &omap3stalker_codec_data,
        .vdac           = &omap3_stalker_vdac,
        .vpll2          = &omap3_stalker_vpll2,
-};
-
-static struct i2c_board_info __initdata omap3stalker_i2c_boardinfo[] = {
-       {
-        I2C_BOARD_INFO("twl4030", 0x48),
-        .flags         = I2C_CLIENT_WAKE,
-        .irq           = INT_34XX_SYS_NIRQ,
-        .platform_data = &omap3stalker_twldata,
-        },
+       .vmmc1          = &omap3stalker_vmmc1,
+       .vsim           = &omap3stalker_vsim,
 };
 
 static struct at24_platform_data fram_info = {
@@ -516,15 +474,7 @@ static struct i2c_board_info __initdata omap3stalker_i2c_boardinfo3[] = {
 
 static int __init omap3_stalker_i2c_init(void)
 {
-       /*
-        * REVISIT: These entries can be set in omap3evm_twl_data
-        * after a merge with MFD tree
-        */
-       omap3stalker_twldata.vmmc1 = &omap3stalker_vmmc1;
-       omap3stalker_twldata.vsim = &omap3stalker_vsim;
-
-       omap_register_i2c_bus(1, 2600, omap3stalker_i2c_boardinfo,
-                             ARRAY_SIZE(omap3stalker_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &omap3stalker_twldata);
        omap_register_i2c_bus(2, 400, NULL, 0);
        omap_register_i2c_bus(3, 400, omap3stalker_i2c_boardinfo3,
                              ARRAY_SIZE(omap3stalker_i2c_boardinfo3));
@@ -532,49 +482,6 @@ static int __init omap3_stalker_i2c_init(void)
 }
 
 #define OMAP3_STALKER_TS_GPIO  175
-static void ads7846_dev_init(void)
-{
-       if (gpio_request(OMAP3_STALKER_TS_GPIO, "ADS7846 pendown") < 0)
-               printk(KERN_ERR "can't get ads7846 pen down GPIO\n");
-
-       gpio_direction_input(OMAP3_STALKER_TS_GPIO);
-       gpio_set_debounce(OMAP3_STALKER_TS_GPIO, 310);
-}
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(OMAP3_STALKER_TS_GPIO);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 3,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-       .settle_delay_usecs     = 150,
-};
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode             = 0,
-       .single_channel         = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info omap3stalker_spi_board_info[] = {
-       [0] = {
-              .modalias        = "ads7846",
-              .bus_num         = 1,
-              .chip_select     = 0,
-              .max_speed_hz    = 1500000,
-              .controller_data = &ads7846_mcspi_config,
-              .irq             = OMAP_GPIO_IRQ(OMAP3_STALKER_TS_GPIO),
-              .platform_data   = &ads7846_config,
-       },
-};
 
 static struct omap_board_config_kernel omap3_stalker_config[] __initdata = {
 };
@@ -618,12 +525,6 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type = MUSB_INTERFACE_ULPI,
-       .mode           = MUSB_OTG,
-       .power          = 100,
-};
-
 static void __init omap3_stalker_init(void)
 {
        omap3_mux_init(board_mux, OMAP_PACKAGE_CUS);
@@ -636,13 +537,11 @@ static void __init omap3_stalker_init(void)
                             ARRAY_SIZE(omap3_stalker_devices));
 
        omap_display_init(&omap3_stalker_dss_data);
-       spi_register_board_info(omap3stalker_spi_board_info,
-                               ARRAY_SIZE(omap3stalker_spi_board_info));
 
        omap_serial_init();
-       usb_musb_init(&musb_board_data);
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
-       ads7846_dev_init();
+       omap_ads7846_init(1, OMAP3_STALKER_TS_GPIO, 310, NULL);
 
        omap_mux_init_gpio(21, OMAP_PIN_OUTPUT);
        omap_mux_init_gpio(18, OMAP_PIN_INPUT_PULLUP);
index 127cb17..82872d7 100644 (file)
@@ -52,6 +52,7 @@
 #include "mux.h"
 #include "hsmmc.h"
 #include "timer-gp.h"
+#include "common-board-devices.h"
 
 #include <asm/setup.h>
 
@@ -95,15 +96,6 @@ static struct mtd_partition omap3touchbook_nand_partitions[] = {
        },
 };
 
-static struct omap_nand_platform_data omap3touchbook_nand_data = {
-       .options        = NAND_BUSWIDTH_16,
-       .parts          = omap3touchbook_nand_partitions,
-       .nr_parts       = ARRAY_SIZE(omap3touchbook_nand_partitions),
-       .dma_channel    = -1,           /* disable DMA in OMAP NAND driver */
-       .nand_setup     = NULL,
-       .dev_ready      = NULL,
-};
-
 #include "sdram-micron-mt46h32m32lf-6.h"
 
 static struct omap2_hsmmc_info mmc[] = {
@@ -154,13 +146,11 @@ static int touchbook_twl_gpio_setup(struct device *dev,
        /* REVISIT: need ehci-omap hooks for external VBUS
         * power switch and overcurrent detect
         */
-
-       gpio_request(gpio + 1, "EHCI_nOC");
-       gpio_direction_input(gpio + 1);
+       gpio_request_one(gpio + 1, GPIOF_IN, "EHCI_nOC");
 
        /* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, active low) */
-       gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
-       gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
+       gpio_request_one(gpio + TWL4030_GPIO_MAX, GPIOF_OUT_INIT_LOW,
+                        "nEN_USB_PWR");
 
        /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
        gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
@@ -273,15 +263,6 @@ static struct twl4030_platform_data touchbook_twldata = {
        .vpll2          = &touchbook_vpll2,
 };
 
-static struct i2c_board_info __initdata touchbook_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl4030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &touchbook_twldata,
-       },
-};
-
 static struct i2c_board_info __initdata touchBook_i2c_boardinfo[] = {
        {
                I2C_BOARD_INFO("bq27200", 0x55),
@@ -291,8 +272,7 @@ static struct i2c_board_info __initdata touchBook_i2c_boardinfo[] = {
 static int __init omap3_touchbook_i2c_init(void)
 {
        /* Standard TouchBook bus */
-       omap_register_i2c_bus(1, 2600, touchbook_i2c_boardinfo,
-                       ARRAY_SIZE(touchbook_i2c_boardinfo));
+       omap3_pmic_init("twl4030", &touchbook_twldata);
 
        /* Additional TouchBook bus */
        omap_register_i2c_bus(3, 100, touchBook_i2c_boardinfo,
@@ -301,19 +281,7 @@ static int __init omap3_touchbook_i2c_init(void)
        return 0;
 }
 
-static void __init omap3_ads7846_init(void)
-{
-       if (gpio_request(OMAP3_TS_GPIO, "ads7846_pen_down")) {
-               printk(KERN_ERR "Failed to request GPIO %d for "
-                               "ads7846 pen down IRQ\n", OMAP3_TS_GPIO);
-               return;
-       }
-
-       gpio_direction_input(OMAP3_TS_GPIO);
-       gpio_set_debounce(OMAP3_TS_GPIO, 310);
-}
-
-static struct ads7846_platform_data ads7846_config = {
+static struct ads7846_platform_data ads7846_pdata = {
        .x_min                  = 100,
        .y_min                  = 265,
        .x_max                  = 3950,
@@ -327,23 +295,6 @@ static struct ads7846_platform_data ads7846_config = {
        .keep_vref_on           = 1,
 };
 
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static struct spi_board_info omap3_ads7846_spi_board_info[] __initdata = {
-       {
-               .modalias               = "ads7846",
-               .bus_num                = 4,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(OMAP3_TS_GPIO),
-               .platform_data          = &ads7846_config,
-       }
-};
-
 static struct gpio_led gpio_leds[] = {
        {
                .name                   = "touchbook::usr0",
@@ -434,39 +385,6 @@ static struct platform_device *omap3_touchbook_devices[] __initdata = {
        &keys_gpio,
 };
 
-static void __init omap3touchbook_flash_init(void)
-{
-       u8 cs = 0;
-       u8 nandcs = GPMC_CS_NUM + 1;
-
-       /* find out the chip-select on which NAND exists */
-       while (cs < GPMC_CS_NUM) {
-               u32 ret = 0;
-               ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
-               if ((ret & 0xC00) == 0x800) {
-                       printk(KERN_INFO "Found NAND on CS%d\n", cs);
-                       if (nandcs > GPMC_CS_NUM)
-                               nandcs = cs;
-               }
-               cs++;
-       }
-
-       if (nandcs > GPMC_CS_NUM) {
-               printk(KERN_INFO "NAND: Unable to find configuration "
-                                "in GPMC\n ");
-               return;
-       }
-
-       if (nandcs < GPMC_CS_NUM) {
-               omap3touchbook_nand_data.cs = nandcs;
-
-               printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
-               if (gpmc_nand_init(&omap3touchbook_nand_data) < 0)
-                       printk(KERN_ERR "Unable to register NAND device\n");
-       }
-}
-
 static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 
        .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
@@ -481,15 +399,10 @@ static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
 
 static void omap3_touchbook_poweroff(void)
 {
-       int r;
+       int pwr_off = TB_KILL_POWER_GPIO;
 
-       r = gpio_request(TB_KILL_POWER_GPIO, "DVI reset");
-       if (r < 0) {
+       if (gpio_request_one(pwr_off, GPIOF_OUT_INIT_LOW, "DVI reset") < 0)
                printk(KERN_ERR "Unable to get kill power GPIO\n");
-               return;
-       }
-
-       gpio_direction_output(TB_KILL_POWER_GPIO, 0);
 }
 
 static int __init early_touchbook_revision(char *p)
@@ -501,12 +414,6 @@ static int __init early_touchbook_revision(char *p)
 }
 early_param("tbr", early_touchbook_revision);
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
-};
-
 static void __init omap3_touchbook_init(void)
 {
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
@@ -521,17 +428,15 @@ static void __init omap3_touchbook_init(void)
        omap_serial_init();
 
        omap_mux_init_gpio(170, OMAP_PIN_INPUT);
-       gpio_request(176, "DVI_nPD");
        /* REVISIT leave DVI powered down until it's needed ... */
-       gpio_direction_output(176, true);
+       gpio_request_one(176, GPIOF_OUT_INIT_HIGH, "DVI_nPD");
 
        /* Touchscreen and accelerometer */
-       spi_register_board_info(omap3_ads7846_spi_board_info,
-                               ARRAY_SIZE(omap3_ads7846_spi_board_info));
-       omap3_ads7846_init();
-       usb_musb_init(&musb_board_data);
+       omap_ads7846_init(4, OMAP3_TS_GPIO, 310, &ads7846_pdata);
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
-       omap3touchbook_flash_init();
+       omap_nand_flash_init(NAND_BUSWIDTH_16, omap3touchbook_nand_partitions,
+                            ARRAY_SIZE(omap3touchbook_nand_partitions));
 
        /* Ensure SDRC pins are mux'd for self-refresh */
        omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
index e4973ac..90485fc 100644 (file)
@@ -46,6 +46,7 @@
 #include "hsmmc.h"
 #include "control.h"
 #include "mux.h"
+#include "common-board-devices.h"
 
 #define GPIO_HUB_POWER         1
 #define GPIO_HUB_NRESET                62
@@ -111,6 +112,11 @@ static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
        .reset_gpio_port[2]  = -EINVAL
 };
 
+static struct gpio panda_ehci_gpios[] __initdata = {
+       { GPIO_HUB_POWER,       GPIOF_OUT_INIT_LOW,  "hub_power"  },
+       { GPIO_HUB_NRESET,      GPIOF_OUT_INIT_LOW,  "hub_nreset" },
+};
+
 static void __init omap4_ehci_init(void)
 {
        int ret;
@@ -120,44 +126,27 @@ static void __init omap4_ehci_init(void)
        phy_ref_clk = clk_get(NULL, "auxclk3_ck");
        if (IS_ERR(phy_ref_clk)) {
                pr_err("Cannot request auxclk3\n");
-               goto error1;
+               return;
        }
        clk_set_rate(phy_ref_clk, 19200000);
        clk_enable(phy_ref_clk);
 
-       /* disable the power to the usb hub prior to init */
-       ret = gpio_request(GPIO_HUB_POWER, "hub_power");
+       /* disable the power to the usb hub prior to init and reset phy+hub */
+       ret = gpio_request_array(panda_ehci_gpios,
+                                ARRAY_SIZE(panda_ehci_gpios));
        if (ret) {
-               pr_err("Cannot request GPIO %d\n", GPIO_HUB_POWER);
-               goto error1;
+               pr_err("Unable to initialize EHCI power/reset\n");
+               return;
        }
-       gpio_export(GPIO_HUB_POWER, 0);
-       gpio_direction_output(GPIO_HUB_POWER, 0);
-       gpio_set_value(GPIO_HUB_POWER, 0);
 
-       /* reset phy+hub */
-       ret = gpio_request(GPIO_HUB_NRESET, "hub_nreset");
-       if (ret) {
-               pr_err("Cannot request GPIO %d\n", GPIO_HUB_NRESET);
-               goto error2;
-       }
+       gpio_export(GPIO_HUB_POWER, 0);
        gpio_export(GPIO_HUB_NRESET, 0);
-       gpio_direction_output(GPIO_HUB_NRESET, 0);
-       gpio_set_value(GPIO_HUB_NRESET, 0);
        gpio_set_value(GPIO_HUB_NRESET, 1);
 
        usbhs_init(&usbhs_bdata);
 
        /* enable power to hub */
        gpio_set_value(GPIO_HUB_POWER, 1);
-       return;
-
-error2:
-       gpio_free(GPIO_HUB_POWER);
-error1:
-       pr_err("Unable to initialize EHCI power/reset\n");
-       return;
-
 }
 
 static struct omap_musb_board_data musb_board_data = {
@@ -408,15 +397,6 @@ static struct twl4030_platform_data omap4_panda_twldata = {
        .usb            = &omap4_usbphy_data,
 };
 
-static struct i2c_board_info __initdata omap4_panda_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("twl6030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = OMAP44XX_IRQ_SYS_1N,
-               .platform_data = &omap4_panda_twldata,
-       },
-};
-
 /*
  * Display monitor features are burnt in their EEPROM as EDID data. The EEPROM
  * is connected as I2C slave device, and can be accessed at address 0x50
@@ -429,12 +409,7 @@ static struct i2c_board_info __initdata panda_i2c_eeprom[] = {
 
 static int __init omap4_panda_i2c_init(void)
 {
-       /*
-        * Phoenix Audio IC needs I2C1 to
-        * start with 400 KHz or less
-        */
-       omap_register_i2c_bus(1, 400, omap4_panda_i2c_boardinfo,
-                       ARRAY_SIZE(omap4_panda_i2c_boardinfo));
+       omap4_pmic_init("twl6030", &omap4_panda_twldata);
        omap_register_i2c_bus(2, 400, NULL, 0);
        /*
         * Bus 3 is attached to the DVI port where devices like the pico DLP
@@ -651,27 +626,19 @@ static void omap4_panda_hdmi_mux_init(void)
                        OMAP_PIN_INPUT_PULLUP);
 }
 
+static struct gpio panda_hdmi_gpios[] = {
+       { HDMI_GPIO_HPD,        GPIOF_OUT_INIT_HIGH, "hdmi_gpio_hpd"   },
+       { HDMI_GPIO_LS_OE,      GPIOF_OUT_INIT_HIGH, "hdmi_gpio_ls_oe" },
+};
+
 static int omap4_panda_panel_enable_hdmi(struct omap_dss_device *dssdev)
 {
        int status;
 
-       status = gpio_request_one(HDMI_GPIO_HPD, GPIOF_OUT_INIT_HIGH,
-                                                       "hdmi_gpio_hpd");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", HDMI_GPIO_HPD);
-               return status;
-       }
-       status = gpio_request_one(HDMI_GPIO_LS_OE, GPIOF_OUT_INIT_HIGH,
-                                                       "hdmi_gpio_ls_oe");
-       if (status) {
-               pr_err("Cannot request GPIO %d\n", HDMI_GPIO_LS_OE);
-               goto error1;
-       }
-
-       return 0;
-
-error1:
-       gpio_free(HDMI_GPIO_HPD);
+       status = gpio_request_array(panda_hdmi_gpios,
+                                   ARRAY_SIZE(panda_hdmi_gpios));
+       if (status)
+               pr_err("Cannot request HDMI GPIOs\n");
 
        return status;
 }
index 9d192ff..1555918 100644 (file)
@@ -56,6 +56,7 @@
 #include "mux.h"
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define OVERO_GPIO_BT_XGATE    15
 #define OVERO_GPIO_W2W_NRESET  16
 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
        defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
 
-#include <linux/spi/ads7846.h>
-
-static struct omap2_mcspi_device_config ads7846_mcspi_config = {
-       .turbo_mode     = 0,
-       .single_channel = 1,    /* 0: slave, 1: master */
-};
-
-static int ads7846_get_pendown_state(void)
-{
-       return !gpio_get_value(OVERO_GPIO_PENDOWN);
-}
-
-static struct ads7846_platform_data ads7846_config = {
-       .x_max                  = 0x0fff,
-       .y_max                  = 0x0fff,
-       .x_plate_ohms           = 180,
-       .pressure_max           = 255,
-       .debounce_max           = 10,
-       .debounce_tol           = 3,
-       .debounce_rep           = 1,
-       .get_pendown_state      = ads7846_get_pendown_state,
-       .keep_vref_on           = 1,
-};
-
 /* fixed regulator for ads7846 */
 static struct regulator_consumer_supply ads7846_supply =
        REGULATOR_SUPPLY("vcc", "spi1.0");
@@ -128,14 +105,7 @@ static struct platform_device vads7846_device = {
 
 static void __init overo_ads7846_init(void)
 {
-       if ((gpio_request(OVERO_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
-           (gpio_direction_input(OVERO_GPIO_PENDOWN) == 0)) {
-               gpio_export(OVERO_GPIO_PENDOWN, 0);
-       } else {
-               printk(KERN_ERR "could not obtain gpio for ADS7846_PENDOWN\n");
-               return;
-       }
-
+       omap_ads7846_init(1, OVERO_GPIO_PENDOWN, 0, NULL);
        platform_device_register(&vads7846_device);
 }
 
@@ -146,106 +116,28 @@ static inline void __init overo_ads7846_init(void) { return; }
 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
 
 #include <linux/smsc911x.h>
+#include <plat/gpmc-smsc911x.h>
 
-static struct resource overo_smsc911x_resources[] = {
-       {
-               .name   = "smsc911x-memory",
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct resource overo_smsc911x2_resources[] = {
-       {
-               .name   = "smsc911x2-memory",
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct smsc911x_platform_config overo_smsc911x_config = {
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
-       .flags          = SMSC911X_USE_32BIT ,
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-};
-
-static struct platform_device overo_smsc911x_device = {
-       .name           = "smsc911x",
+static struct omap_smsc911x_platform_data smsc911x_cfg = {
        .id             = 0,
-       .num_resources  = ARRAY_SIZE(overo_smsc911x_resources),
-       .resource       = overo_smsc911x_resources,
-       .dev            = {
-               .platform_data = &overo_smsc911x_config,
-       },
+       .cs             = OVERO_SMSC911X_CS,
+       .gpio_irq       = OVERO_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT,
 };
 
-static struct platform_device overo_smsc911x2_device = {
-       .name           = "smsc911x",
+static struct omap_smsc911x_platform_data smsc911x2_cfg = {
        .id             = 1,
-       .num_resources  = ARRAY_SIZE(overo_smsc911x2_resources),
-       .resource       = overo_smsc911x2_resources,
-       .dev            = {
-               .platform_data = &overo_smsc911x_config,
-       },
+       .cs             = OVERO_SMSC911X2_CS,
+       .gpio_irq       = OVERO_SMSC911X2_GPIO,
+       .gpio_reset     = -EINVAL,
+       .flags          = SMSC911X_USE_32BIT,
 };
 
-static struct platform_device *smsc911x_devices[] = {
-       &overo_smsc911x_device,
-       &overo_smsc911x2_device,
-};
-
-static inline void __init overo_init_smsc911x(void)
+static void __init overo_init_smsc911x(void)
 {
-       unsigned long cs_mem_base, cs_mem_base2;
-
-       /* set up first smsc911x chip */
-
-       if (gpmc_cs_request(OVERO_SMSC911X_CS, SZ_16M, &cs_mem_base) < 0) {
-               printk(KERN_ERR "Failed request for GPMC mem for smsc911x\n");
-               return;
-       }
-
-       overo_smsc911x_resources[0].start = cs_mem_base + 0x0;
-       overo_smsc911x_resources[0].end   = cs_mem_base + 0xff;
-
-       if ((gpio_request(OVERO_SMSC911X_GPIO, "SMSC911X IRQ") == 0) &&
-           (gpio_direction_input(OVERO_SMSC911X_GPIO) == 0)) {
-               gpio_export(OVERO_SMSC911X_GPIO, 0);
-       } else {
-               printk(KERN_ERR "could not obtain gpio for SMSC911X IRQ\n");
-               return;
-       }
-
-       overo_smsc911x_resources[1].start = OMAP_GPIO_IRQ(OVERO_SMSC911X_GPIO);
-       overo_smsc911x_resources[1].end   = 0;
-
-       /* set up second smsc911x chip */
-
-       if (gpmc_cs_request(OVERO_SMSC911X2_CS, SZ_16M, &cs_mem_base2) < 0) {
-               printk(KERN_ERR "Failed request for GPMC mem for smsc911x2\n");
-               return;
-       }
-
-       overo_smsc911x2_resources[0].start = cs_mem_base2 + 0x0;
-       overo_smsc911x2_resources[0].end   = cs_mem_base2 + 0xff;
-
-       if ((gpio_request(OVERO_SMSC911X2_GPIO, "SMSC911X2 IRQ") == 0) &&
-           (gpio_direction_input(OVERO_SMSC911X2_GPIO) == 0)) {
-               gpio_export(OVERO_SMSC911X2_GPIO, 0);
-       } else {
-               printk(KERN_ERR "could not obtain gpio for SMSC911X2 IRQ\n");
-               return;
-       }
-
-       overo_smsc911x2_resources[1].start = OMAP_GPIO_IRQ(OVERO_SMSC911X2_GPIO);
-       overo_smsc911x2_resources[1].end   = 0;
-
-       platform_add_devices(smsc911x_devices, ARRAY_SIZE(smsc911x_devices));
+       gpmc_smsc911x_init(&smsc911x_cfg);
+       gpmc_smsc911x_init(&smsc911x2_cfg);
 }
 
 #else
@@ -259,21 +151,20 @@ static int dvi_enabled;
 #define OVERO_GPIO_LCD_EN 144
 #define OVERO_GPIO_LCD_BL 145
 
+static struct gpio overo_dss_gpios[] __initdata = {
+       { OVERO_GPIO_LCD_EN, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_EN" },
+       { OVERO_GPIO_LCD_BL, GPIOF_OUT_INIT_HIGH, "OVERO_GPIO_LCD_BL" },
+};
+
 static void __init overo_display_init(void)
 {
-       if ((gpio_request(OVERO_GPIO_LCD_EN, "OVERO_GPIO_LCD_EN") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_LCD_EN, 1) == 0))
-               gpio_export(OVERO_GPIO_LCD_EN, 0);
-       else
-               printk(KERN_ERR "could not obtain gpio for "
-                                       "OVERO_GPIO_LCD_EN\n");
+       if (gpio_request_array(overo_dss_gpios, ARRAY_SIZE(overo_dss_gpios))) {
+               printk(KERN_ERR "could not obtain DSS control GPIOs\n");
+               return;
+       }
 
-       if ((gpio_request(OVERO_GPIO_LCD_BL, "OVERO_GPIO_LCD_BL") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_LCD_BL, 1) == 0))
-               gpio_export(OVERO_GPIO_LCD_BL, 0);
-       else
-               printk(KERN_ERR "could not obtain gpio for "
-                                       "OVERO_GPIO_LCD_BL\n");
+       gpio_export(OVERO_GPIO_LCD_EN, 0);
+       gpio_export(OVERO_GPIO_LCD_BL, 0);
 }
 
 static int overo_panel_enable_dvi(struct omap_dss_device *dssdev)
@@ -412,45 +303,6 @@ static struct mtd_partition overo_nand_partitions[] = {
        },
 };
 
-static struct omap_nand_platform_data overo_nand_data = {
-       .parts = overo_nand_partitions,
-       .nr_parts = ARRAY_SIZE(overo_nand_partitions),
-       .dma_channel = -1,      /* disable DMA in OMAP NAND driver */
-};
-
-static void __init overo_flash_init(void)
-{
-       u8 cs = 0;
-       u8 nandcs = GPMC_CS_NUM + 1;
-
-       /* find out the chip-select on which NAND exists */
-       while (cs < GPMC_CS_NUM) {
-               u32 ret = 0;
-               ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
-               if ((ret & 0xC00) == 0x800) {
-                       printk(KERN_INFO "Found NAND on CS%d\n", cs);
-                       if (nandcs > GPMC_CS_NUM)
-                               nandcs = cs;
-               }
-               cs++;
-       }
-
-       if (nandcs > GPMC_CS_NUM) {
-               printk(KERN_INFO "NAND: Unable to find configuration "
-                                "in GPMC\n ");
-               return;
-       }
-
-       if (nandcs < GPMC_CS_NUM) {
-               overo_nand_data.cs = nandcs;
-
-               printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
-               if (gpmc_nand_init(&overo_nand_data) < 0)
-                       printk(KERN_ERR "Unable to register NAND device\n");
-       }
-}
-
 static struct omap2_hsmmc_info mmc[] = {
        {
                .mmc            = 1,
@@ -648,37 +500,15 @@ static struct twl4030_platform_data overo_twldata = {
        .vpll2          = &overo_vpll2,
 };
 
-static struct i2c_board_info __initdata overo_i2c_boardinfo[] = {
-       {
-               I2C_BOARD_INFO("tps65950", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &overo_twldata,
-       },
-};
-
 static int __init overo_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2600, overo_i2c_boardinfo,
-                       ARRAY_SIZE(overo_i2c_boardinfo));
+       omap3_pmic_init("tps65950", &overo_twldata);
        /* i2c2 pins are used for gpio */
        omap_register_i2c_bus(3, 400, NULL, 0);
        return 0;
 }
 
 static struct spi_board_info overo_spi_board_info[] __initdata = {
-#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
-       defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
-       {
-               .modalias               = "ads7846",
-               .bus_num                = 1,
-               .chip_select            = 0,
-               .max_speed_hz           = 1500000,
-               .controller_data        = &ads7846_mcspi_config,
-               .irq                    = OMAP_GPIO_IRQ(OVERO_GPIO_PENDOWN),
-               .platform_data          = &ads7846_config,
-       },
-#endif
 #if defined(CONFIG_PANEL_LGPHILIPS_LB035Q02) || \
        defined(CONFIG_PANEL_LGPHILIPS_LB035Q02_MODULE)
        {
@@ -722,20 +552,22 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data musb_board_data = {
-       .interface_type         = MUSB_INTERFACE_ULPI,
-       .mode                   = MUSB_OTG,
-       .power                  = 100,
+static struct gpio overo_bt_gpios[] __initdata = {
+       { OVERO_GPIO_BT_XGATE,  GPIOF_OUT_INIT_LOW,     "lcd enable"    },
+       { OVERO_GPIO_BT_NRESET, GPIOF_OUT_INIT_HIGH,    "lcd bl enable" },
 };
 
 static void __init overo_init(void)
 {
+       int ret;
+
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
        overo_i2c_init();
        omap_display_init(&overo_dss_data);
        omap_serial_init();
-       overo_flash_init();
-       usb_musb_init(&musb_board_data);
+       omap_nand_flash_init(0, overo_nand_partitions,
+                            ARRAY_SIZE(overo_nand_partitions));
+       usb_musb_init(NULL);
        usbhs_init(&usbhs_bdata);
        overo_spi_init();
        overo_ads7846_init();
@@ -748,9 +580,9 @@ static void __init overo_init(void)
        omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
        omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
 
-       if ((gpio_request(OVERO_GPIO_W2W_NRESET,
-                         "OVERO_GPIO_W2W_NRESET") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_W2W_NRESET, 1) == 0)) {
+       ret = gpio_request_one(OVERO_GPIO_W2W_NRESET, GPIOF_OUT_INIT_HIGH,
+                              "OVERO_GPIO_W2W_NRESET");
+       if (ret == 0) {
                gpio_export(OVERO_GPIO_W2W_NRESET, 0);
                gpio_set_value(OVERO_GPIO_W2W_NRESET, 0);
                udelay(10);
@@ -760,25 +592,20 @@ static void __init overo_init(void)
                                        "OVERO_GPIO_W2W_NRESET\n");
        }
 
-       if ((gpio_request(OVERO_GPIO_BT_XGATE, "OVERO_GPIO_BT_XGATE") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_BT_XGATE, 0) == 0))
+       ret = gpio_request_array(overo_bt_gpios, ARRAY_SIZE(overo_bt_gpios));
+       if (ret) {
+               pr_err("%s: could not obtain BT gpios\n", __func__);
+       } else {
                gpio_export(OVERO_GPIO_BT_XGATE, 0);
-       else
-               printk(KERN_ERR "could not obtain gpio for OVERO_GPIO_BT_XGATE\n");
-
-       if ((gpio_request(OVERO_GPIO_BT_NRESET, "OVERO_GPIO_BT_NRESET") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_BT_NRESET, 1) == 0)) {
                gpio_export(OVERO_GPIO_BT_NRESET, 0);
                gpio_set_value(OVERO_GPIO_BT_NRESET, 0);
                mdelay(6);
                gpio_set_value(OVERO_GPIO_BT_NRESET, 1);
-       } else {
-               printk(KERN_ERR "could not obtain gpio for "
-                                       "OVERO_GPIO_BT_NRESET\n");
        }
 
-       if ((gpio_request(OVERO_GPIO_USBH_CPEN, "OVERO_GPIO_USBH_CPEN") == 0) &&
-           (gpio_direction_output(OVERO_GPIO_USBH_CPEN, 1) == 0))
+       ret = gpio_request_one(OVERO_GPIO_USBH_CPEN, GPIOF_OUT_INIT_HIGH,
+                              "OVERO_GPIO_USBH_CPEN");
+       if (ret == 0)
                gpio_export(OVERO_GPIO_USBH_CPEN, 0);
        else
                printk(KERN_ERR "could not obtain gpio for "
index 2af8b05..42d10b1 100644 (file)
@@ -31,6 +31,7 @@
 #include "mux.h"
 #include "hsmmc.h"
 #include "sdram-nokia.h"
+#include "common-board-devices.h"
 
 static struct regulator_consumer_supply rm680_vemmc_consumers[] = {
        REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1"),
@@ -90,19 +91,9 @@ static struct twl4030_platform_data rm680_twl_data = {
        /* add rest of the children here */
 };
 
-static struct i2c_board_info __initdata rm680_twl_i2c_board_info[] = {
-       {
-               I2C_BOARD_INFO("twl5031", 0x48),
-               .flags          = I2C_CLIENT_WAKE,
-               .irq            = INT_34XX_SYS_NIRQ,
-               .platform_data  = &rm680_twl_data,
-       },
-};
-
 static void __init rm680_i2c_init(void)
 {
-       omap_register_i2c_bus(1, 2900, rm680_twl_i2c_board_info,
-                               ARRAY_SIZE(rm680_twl_i2c_board_info));
+       omap_pmic_init(1, 2900, "twl5031", INT_34XX_SYS_NIRQ, &rm680_twl_data);
        omap_register_i2c_bus(2, 400, NULL, 0);
        omap_register_i2c_bus(3, 400, NULL, 0);
 }
@@ -153,17 +144,11 @@ static struct omap_board_mux board_mux[] __initdata = {
 };
 #endif
 
-static struct omap_musb_board_data rm680_musb_data = {
-       .interface_type = MUSB_INTERFACE_ULPI,
-       .mode           = MUSB_PERIPHERAL,
-       .power          = 100,
-};
-
 static void __init rm680_init(void)
 {
        omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
        omap_serial_init();
-       usb_musb_init(&rm680_musb_data);
+       usb_musb_init(NULL);
        rm680_peripherals_init();
 }
 
index bbcb677..2b00f72 100644 (file)
@@ -43,6 +43,7 @@
 
 #include "mux.h"
 #include "hsmmc.h"
+#include "common-board-devices.h"
 
 #define SYSTEM_REV_B_USES_VAUX3        0x1699
 #define SYSTEM_REV_S_USES_VAUX3 0x8
@@ -557,10 +558,8 @@ static __init void rx51_init_si4713(void)
 static int rx51_twlgpio_setup(struct device *dev, unsigned gpio, unsigned n)
 {
        /* FIXME this gpio setup is just a placeholder for now */
-       gpio_request(gpio + 6, "backlight_pwm");
-       gpio_direction_output(gpio + 6, 0);
-       gpio_request(gpio + 7, "speaker_en");
-       gpio_direction_output(gpio + 7, 1);
+       gpio_request_one(gpio + 6, GPIOF_OUT_INIT_LOW, "backlight_pwm");
+       gpio_request_one(gpio + 7, GPIOF_OUT_INIT_HIGH, "speaker_en");
 
        return 0;
 }
@@ -730,7 +729,7 @@ static struct twl4030_resconfig twl4030_rconfig[] __initdata = {
        { .resource = RES_RESET, .devgroup = -1,
          .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
        },
-       { .resource = RES_Main_Ref, .devgroup = -1,
+       { .resource = RES_MAIN_REF, .devgroup = -1,
          .type = 1, .type2 = -1, .remap_off = -1, .remap_sleep = -1
        },
        { 0, 0},
@@ -777,15 +776,6 @@ static struct tpa6130a2_platform_data rx51_tpa6130a2_data __initdata_or_module =
        .power_gpio             = 98,
 };
 
-static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_1[] = {
-       {
-               I2C_BOARD_INFO("twl5030", 0x48),
-               .flags = I2C_CLIENT_WAKE,
-               .irq = INT_34XX_SYS_NIRQ,
-               .platform_data = &rx51_twldata,
-       },
-};
-
 /* Audio setup data */
 static struct aic3x_setup_data rx51_aic34_setup = {
        .gpio_func[0] = AIC3X_GPIO1_FUNC_DISABLED,
@@ -833,8 +823,7 @@ static int __init rx51_i2c_init(void)
                rx51_twldata.vaux3 = &rx51_vaux3_cam;
        }
        rx51_twldata.vmmc2 = &rx51_vmmc2;
-       omap_register_i2c_bus(1, 2200, rx51_peripherals_i2c_board_info_1,
-                             ARRAY_SIZE(rx51_peripherals_i2c_board_info_1));
+       omap_pmic_init(1, 2200, "twl5030", INT_34XX_SYS_NIRQ, &rx51_twldata);
        omap_register_i2c_bus(2, 100, rx51_peripherals_i2c_board_info_2,
                              ARRAY_SIZE(rx51_peripherals_i2c_board_info_2));
        omap_register_i2c_bus(3, 400, NULL, 0);
@@ -921,26 +910,20 @@ static void rx51_wl1251_set_power(bool enable)
        gpio_set_value(RX51_WL1251_POWER_GPIO, enable);
 }
 
+static struct gpio rx51_wl1251_gpios[] __initdata = {
+       { RX51_WL1251_POWER_GPIO, GPIOF_OUT_INIT_LOW,   "wl1251 power"  },
+       { RX51_WL1251_IRQ_GPIO,   GPIOF_IN,             "wl1251 irq"    },
+};
+
 static void __init rx51_init_wl1251(void)
 {
        int irq, ret;
 
-       ret = gpio_request(RX51_WL1251_POWER_GPIO, "wl1251 power");
+       ret = gpio_request_array(rx51_wl1251_gpios,
+                                ARRAY_SIZE(rx51_wl1251_gpios));
        if (ret < 0)
                goto error;
 
-       ret = gpio_direction_output(RX51_WL1251_POWER_GPIO, 0);
-       if (ret < 0)
-               goto err_power;
-
-       ret = gpio_request(RX51_WL1251_IRQ_GPIO, "wl1251 irq");
-       if (ret < 0)
-               goto err_power;
-
-       ret = gpio_direction_input(RX51_WL1251_IRQ_GPIO);
-       if (ret < 0)
-               goto err_irq;
-
        irq = gpio_to_irq(RX51_WL1251_IRQ_GPIO);
        if (irq < 0)
                goto err_irq;
@@ -952,10 +935,7 @@ static void __init rx51_init_wl1251(void)
 
 err_irq:
        gpio_free(RX51_WL1251_IRQ_GPIO);
-
-err_power:
        gpio_free(RX51_WL1251_POWER_GPIO);
-
 error:
        printk(KERN_ERR "wl1251 board initialisation failed\n");
        wl1251_pdata.set_power = NULL;
index 2df10b6..2c1289b 100644 (file)
@@ -76,13 +76,12 @@ static int __init rx51_video_init(void)
                return 0;
        }
 
-       if (gpio_request(RX51_LCD_RESET_GPIO, "LCD ACX565AKM reset")) {
+       if (gpio_request_one(RX51_LCD_RESET_GPIO, GPIOF_OUT_INIT_HIGH,
+                            "LCD ACX565AKM reset")) {
                pr_err("%s failed to get LCD Reset GPIO\n", __func__);
                return 0;
        }
 
-       gpio_direction_output(RX51_LCD_RESET_GPIO, 1);
-
        omap_display_init(&rx51_dss_board_info);
        return 0;
 }
index f8ba20a..fec4cac 100644 (file)
@@ -58,21 +58,25 @@ static struct platform_device leds_gpio = {
        },
 };
 
+/*
+ * cpuidle C-states definition override from the default values.
+ * The 'exit_latency' field is the sum of sleep and wake-up latencies.
+ */
 static struct cpuidle_params rx51_cpuidle_params[] = {
        /* C1 */
-       {1, 110, 162, 5},
+       {110 + 162, 5 , 1},
        /* C2 */
-       {1, 106, 180, 309},
+       {106 + 180, 309, 1},
        /* C3 */
-       {0, 107, 410, 46057},
+       {107 + 410, 46057, 0},
        /* C4 */
-       {0, 121, 3374, 46057},
+       {121 + 3374, 46057, 0},
        /* C5 */
-       {1, 855, 1146, 46057},
+       {855 + 1146, 46057, 1},
        /* C6 */
-       {0, 7580, 4134, 484329},
+       {7580 + 4134, 484329, 0},
        /* C7 */
-       {1, 7505, 15274, 484329},
+       {7505 + 15274, 484329, 1},
 };
 
 static struct omap_lcd_config rx51_lcd_config = {
index 007ebdc..6402e78 100644 (file)
@@ -15,6 +15,7 @@
 #include <linux/interrupt.h>
 
 #include <plat/gpmc.h>
+#include <plat/gpmc-smsc911x.h>
 
 #include <mach/board-zoom.h>
 
 #define DEBUG_BASE             0x08000000
 #define ZOOM_ETHR_START        DEBUG_BASE
 
-static struct resource zoom_smsc911x_resources[] = {
-       [0] = {
-               .start  = ZOOM_ETHR_START,
-               .end    = ZOOM_ETHR_START + SZ_4K,
-               .flags  = IORESOURCE_MEM,
-       },
-       [1] = {
-               .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
-       },
-};
-
-static struct smsc911x_platform_config zoom_smsc911x_config = {
-       .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
-       .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
+static struct omap_smsc911x_platform_data zoom_smsc911x_cfg = {
+       .cs             = ZOOM_SMSC911X_CS,
+       .gpio_irq       = ZOOM_SMSC911X_GPIO,
+       .gpio_reset     = -EINVAL,
        .flags          = SMSC911X_USE_32BIT,
-       .phy_interface  = PHY_INTERFACE_MODE_MII,
-};
-
-static struct platform_device zoom_smsc911x_device = {
-       .name           = "smsc911x",
-       .id             = -1,
-       .num_resources  = ARRAY_SIZE(zoom_smsc911x_resources),
-       .resource       = zoom_smsc911x_resources,
-       .dev            = {
-               .platform_data = &zoom_smsc911x_config,
-       },
 };
 
 static inline void __init zoom_init_smsc911x(void)
 {
-       int eth_cs;
-       unsigned long cs_mem_base;
-       int eth_gpio = 0;
-
-       eth_cs = ZOOM_SMSC911X_CS;
-
-       if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
-               printk(KERN_ERR "Failed to request GPMC mem for smsc911x\n");
-               return;
-       }
-
-       zoom_smsc911x_resources[0].start = cs_mem_base + 0x0;
-       zoom_smsc911x_resources[0].end   = cs_mem_base + 0xff;
-
-       eth_gpio = ZOOM_SMSC911X_GPIO;
-
-       zoom_smsc911x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
-
-       if (gpio_request(eth_gpio, "smsc911x irq") < 0) {
-               printk(KERN_ERR "Failed to request GPIO%d for smsc911x IRQ\n",
-                               eth_gpio);
-               return;
-       }
-       gpio_direction_input(eth_gpio);
+       gpmc_smsc911x_init(&zoom_smsc911x_cfg);
 }
 
 static struct plat_serial8250_port serial_platform_data[] = {
@@ -120,12 +77,9 @@ static inline void __init zoom_init_quaduart(void)
 
        quart_gpio = ZOOM_QUADUART_GPIO;
 
-       if (gpio_request(quart_gpio, "TL16CP754C GPIO") < 0) {
+       if (gpio_request_one(quart_gpio, GPIOF_IN, "TL16CP754C GPIO") < 0)
                printk(KERN_ERR "Failed to request GPIO%d for TL16CP754C\n",
                                                                quart_gpio);
-               return;
-       }
-       gpio_direction_input(quart_gpio);
 }
 
 static inline int omap_zoom_debugboard_detect(void)
@@ -135,12 +89,12 @@ static inline int omap_zoom_debugboard_detect(void)
 
        debug_board_detect = ZOOM_SMSC911X_GPIO;
 
-       if (gpio_request(debug_board_detect, "Zoom debug board detect") < 0) {
+       if (gpio_request_one(debug_board_detect, GPIOF_IN,
+                            "Zoom debug board detect") < 0) {
                printk(KERN_ERR "Failed to request GPIO%d for Zoom debug"
                "board detect\n", debug_board_detect);
                return 0;
        }
-       gpio_direction_input(debug_board_detect);
 
        if (!gpio_get_value(debug_board_detect)) {
                ret = 0;
@@ -150,7 +104,6 @@ static inline int omap_zoom_debugboard_detect(void)
 }
 
 static struct platform_device *zoom_devices[] __initdata = {
-       &zoom_smsc911x_device,
        &zoom_debugboard_serial_device,
 };
 
index 60e8645..c7c6beb 100644 (file)
 #define LCD_PANEL_RESET_GPIO_PILOT     55
 #define LCD_PANEL_QVGA_GPIO            56
 
+static struct gpio zoom_lcd_gpios[] __initdata = {
+       { -EINVAL,              GPIOF_OUT_INIT_HIGH, "lcd reset" },
+       { LCD_PANEL_QVGA_GPIO,  GPIOF_OUT_INIT_HIGH, "lcd qvga"  },
+};
+
 static void zoom_lcd_panel_init(void)
 {
-       int ret;
-       unsigned char lcd_panel_reset_gpio;
-
-       lcd_panel_reset_gpio = (omap_rev() > OMAP3430_REV_ES3_0) ?
+       zoom_lcd_gpios[0].gpio = (omap_rev() > OMAP3430_REV_ES3_0) ?
                        LCD_PANEL_RESET_GPIO_PROD :
                        LCD_PANEL_RESET_GPIO_PILOT;
 
-       ret = gpio_request(lcd_panel_reset_gpio, "lcd reset");
-       if (ret) {
-               pr_err("Failed to get LCD reset GPIO (gpio%d).\n",
-                       lcd_panel_reset_gpio);
-               return;
-       }
-       gpio_direction_output(lcd_panel_reset_gpio, 1);
-
-       ret = gpio_request(LCD_PANEL_QVGA_GPIO, "lcd qvga");
-       if (ret) {
-               pr_err("Failed to get LCD_PANEL_QVGA_GPIO (gpio%d).\n",
-                       LCD_PANEL_QVGA_GPIO);
-               goto err0;
-       }
-       gpio_direction_output(LCD_PANEL_QVGA_GPIO, 1);
-
-       return;
-err0:
-       gpio_free(lcd_panel_reset_gpio);
+       if (gpio_request_array(zoom_lcd_gpios, ARRAY_SIZE(zoom_lcd_gpios)))
+               pr_err("%s: Failed to get LCD GPIOs.\n", __func__);
 }
 
 static int zoom_panel_enable_lcd(struct omap_dss_device *dssdev)