tree c37dd2cfdb42885d1a4d47ba6f133bd7fee043d3
parent 8c4b88f5ca616fe7f71f3ea871f05bbecbd5f08b
author Gregory CLEMENT <gregory.clement@free-electrons.com> 1422281769 +0100
committer Andrew Lunn <andrew@lunn.ch> 1422322093 -0600

ARM: mvebu: armada-xp-netgear-rn2120: Relicense the device tree under GPLv2+/X11

The current GPL only licensing on the device tree makes it very
impractical for other software components licensed under another
license.

In order to make it easier for them to reuse our device trees,
relicense our device trees under a GPL/X11 dual-license.

Signed-off-by: Gregory CLEMENT <gregory.clement@free-electrons.com>
Acked-by: Jason Cooper <jason@lakedaemon.net>
Acked-by: Arnaud Ebalard <arno@natisbad.org>
Acked-by: Philipp Zabel <p.zabel@pengutronix.de>
Acked-by: Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
Acked-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
