tree 4c54faaf6250c1c4525add5ee1e1dfb552eb37f4
parent fe960be5e630c41c0a7e14c6295ed1f2f30535c2
author Chen-Yu Tsai <wens@csie.org> 1453883684 +0800
committer Hans de Goede <hdegoede@redhat.com> 1458767053 +0100

sunxi: Add defconfig for Cubietruck Plus

Cubietruck Plus is a A83T/H8 based development board. The board has
standard DDR3 SDRAM, AXP818 PMIC/codec, SD/MMC, eMMC, USB 2.0 host
via HSIC USB Hub, USB OTG, SATA via USB bridge, gigabit ethernet,
WiFi, headphone out / mic in, and various GPIO headers.

The board also has an EEPROM on i2c0 which holds the MAC address.

DLDO3 and DLDO4 provide power to the EMAC pins and PHY. Pin PA20
is connected to the reset control of the PHY. EMAC is not actually
supported yet.

Signed-off-by: Chen-Yu Tsai <wens@csie.org>
Acked-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
