#########################################################################
#									#
# Regular Maintainers for U-Boot board support:				#
#									#
# For any board without permanent maintainer, please contact		#
#	Wolfgang Denk <wd@denx.de>					#
# and Cc: the <u-boot@lists.denx.de> mailing list.			#
#									#
# Note: lists sorted by Maintainer Name					#
#########################################################################


#########################################################################
# PowerPC Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Poonam Aggrwal <poonam.aggrwal@freescale.com>

	P2020RDB	P2020

Greg Allen <gallen@arlut.utexas.edu>

	UTX8245		MPC8245

Pantelis Antoniou <panto@intracom.gr>

	NETVIA		MPC8xx

Reinhard Arlt <reinhard.arlt@esd-electronics.com>

	cpci5200	MPC5200
	mecp5123	MPC5121
	mecp5200	MPC5200
	pf5200		MPC5200

	caddy2		MPC8349
	vme8349		MPC8349

	CPCI750		PPC750FX/GX

Yuli Barcohen <yuli@arabellasw.com>

	Adder		MPC87x/MPC852T
	ep8248		MPC8248
	ISPAN		MPC8260
	MPC8260ADS	MPC826x/MPC827x/MPC8280
	Rattler		MPC8248
	ZPC1900		MPC8265

Michael Barkowski <michael.barkowski@freescale.com>

	MPC8323ERDB	MPC8323

Jerry Van Baren <gerald.vanbaren@smiths-aerospace.com>

	sacsng		MPC8260

Oliver Brown <obrown@adventnetworks.com>

	gw8260		MPC8260

Cyril Chemparathy <cyril@ti.com>

	tnetv107x_evm	tnetv107x

Conn Clark <clark@esteem.com>

	ESTEEM192E	MPC8xx

Joe D'Abbraccio <ljd015@freescale.com>

	MPC837xERDB	MPC837x

Kári Davíðsson <kd@flaga.is>

	FLAGADM		MPC823

Torsten Demke <torsten.demke@fci.com>

	eXalion		MPC824x

Wolfgang Denk <wd@denx.de>

	IceCube_5200	MPC5200

	ARIA		MPC5121e

	AMX860		MPC860
	ETX094		MPC850
	FPS850L		MPC850
	FPS860L		MPC860
	ICU862		MPC862
	IP860		MPC860
	IVML24		MPC860
	IVML24_128	MPC860
	IVML24_256	MPC860
	IVMS8		MPC860
	IVMS8_128	MPC860
	IVMS8_256	MPC860
	LANTEC		MPC850
	LWMON		MPC823
	R360MPI		MPC823
	RMU		MPC850
	RRvision	MPC823
	SM850		MPC850
	SPD823TS	MPC823
	TQM823L		MPC823
	TQM823L_LCD	MPC823
	TQM850L		MPC850
	TQM855L		MPC855
	TQM860L		MPC860
	TQM860L_FEC	MPC860
	c2mon		MPC855
	hermes		MPC860
	lwmon		MPC823

	CU824		MPC8240
	Sandpoint8240	MPC8240

	ATC		MPC8250
	PM825		MPC8250

	TQM8255		MPC8255

	CPU86		MPC8260
	PM826		MPC8260
	TQM8260		MPC8260

	P3G4		MPC7410

	PCIPPC2		MPC750
	PCIPPC6		MPC750

Jon Diekema <jon.diekema@smiths-aerospace.com>

	sbc8260		MPC8260

Alex Dubov <oakad@yahoo.com>

	mpq101		MPC8548

Phil Edworthy <phil.edworthy@renesas.com>

	rsk7264		SH7264

Dirk Eibach <eibach@gdsys.de>

	devconcenter	PPC460EX
	dlvision        PPC405EP
	dlvision-10g	PPC405EP
	gdppc440etx	PPC440EP/GR
	intip		PPC460EX
	io		PPC405EP
	iocon		PPC405EP
	neo		PPC405EP

Dave Ellis <DGE@sixnetio.com>

	SXNI855T	MPC8xx

Thomas Frieden <ThomasF@hyperion-entertainment.com>

	AmigaOneG3SE	MPC7xx

Matthias Fuchs <matthias.fuchs@esd-electronics.com>

	ADCIOP		IOP480 (PPC401)
	APC405		PPC405GP
	AR405		PPC405GP
	ASH405		PPC405EP
	CANBT		PPC405CR
	CPCI2DP		PPC405GP
	CPCI405		PPC405GP
	CPCI4052	PPC405GP
	CPCI405AB	PPC405GP
	CPCI405DT	PPC405GP
	CPCIISER4	PPC405GP
	DASA_SIM	IOP480 (PPC401)
	DP405		PPC405EP
	DU405		PPC405GP
	DU440		PPC440EPx
	G2000		PPC405EP
	HH405		PPC405EP
	HUB405		PPC405EP
	OCRTC		PPC405GP
	ORSG		PPC405GP
	PCI405		PPC405GP
	PLU405		PPC405EP
	PMC405		PPC405GP
	PMC405DE	PPC405EP
	PMC440		PPC440EPx
	VOH405		PPC405EP
	VOM405		PPC405EP
	WUH405		PPC405EP
	CMS700		PPC405EP

Siddarth Gore <gores@marvell.com>

	guruplug	ARM926EJS (Kirkwood SoC)

Paul Gortmaker <paul.gortmaker@windriver.com>

	sbc8349		MPC8349
	sbc8540		MPC8540
	sbc8548		MPC8548
	sbc8560		MPC8560
	sbc8641d	MPC8641D

Frank Gottschling <fgottschling@eltec.de>

	MHPC		MPC8xx

	BAB7xx		MPC740/MPC750

Wolfgang Grandegger <wg@denx.de>

	ipek01		MPC5200

	PN62		MPC8240
	IPHASE4539	MPC8260
	SCM		MPC8260

Klaus Heydeck <heydeck@kieback-peter.de>

	KUP4K		MPC855
	KUP4X		MPC859

Ilko Iliev <iliev@ronetix.at>

	PM9261		AT91SAM9261
	PM9263		AT91SAM9263
	PM9G45		ARM926EJS (AT91SAM9G45 SoC)

Gary Jennejohn <garyj@denx.de>

	quad100hd	PPC405EP

Murray Jensen <Murray.Jensen@csiro.au>

	cogent_mpc8xx	MPC8xx

	cogent_mpc8260	MPC8260
	hymod		MPC8260

Larry Johnson <lrj@acm.org>

	korat		PPC440EPx

Feng Kan <fkan@amcc.com>

	redwood			PPC4xx

Brad Kemp <Brad.Kemp@seranoa.com>

	ppmc8260	MPC8260

Sangmoon Kim <dogoil@etinsys.com>

	debris		MPC8245
	KVME080		MPC8245

The LEOX team <team@leox.org>

	ELPT860		MPC860T

Guennadi Liakhovetski <g.liakhovetski@gmx.de>

	linkstation	MPC8241

Dave Liu <daveliu@freescale.com>

	MPC8315ERDB	MPC8315
	MPC832XEMDS	MPC832x
	MPC8360EMDS	MPC8360
	MPC837XEMDS	MPC837x

Nye Liu <nyet@zumanetworks.com>

	ZUMA		MPC7xx_74xx

Kumar Gala <kumar.gala@freescale.com>

	MPC8540ADS	MPC8540
	MPC8560ADS	MPC8560
	MPC8541CDS	MPC8541
	MPC8555CDS	MPC8555

	MPC8641HPCN	MPC8641D

Ron Madrid <info@sheldoninst.com>

	SIMPC8313	MPC8313

Dan Malek <dan@embeddedalley.com>

	stxgp3		MPC85xx
	stxssa		MPC85xx
	stxxtc		MPC8xx

Ryan Mallon <ryan@bluewatersys.com>

	snapper9260		ARM926EJS (AT91SAM9260 SoC)
	snapper9g20		ARM926EJS (AT91SAM9G20 SoC)

Eran Man <eran@nbase.co.il>

	EVB64260_750CX	MPC750CX

Andrea "llandre" Marson <andrea.marson@dave-tech.it>

	PPChameleonEVB	PPC405EP

Tirumala Marri <tmarri@apm.com>

	bluestone       APM821XX

Reinhard Meyer <reinhard.meyer@emk-elektronik.de>

	TOP860		MPC860T
	TOP5200		MPC5200
	TOP9000		ARM926EJS (AT91SAM9xxx SoC)

Tolunay Orkun <torkun@nextio.com>

	csb272		PPC405GP
	csb472		PPC405GP

John Otken <jotken@softadvances.com>

	luan		PPC440SP
	taihu		PPC405EP

Keith Outwater <Keith_Outwater@mvis.com>

	GEN860T		MPC860T
	GEN860T_SC	MPC860T

Frank Panno <fpanno@delphintech.com>

	ep8260		MPC8260

Denis Peter <d.peter@mpl.ch>

	MIP405		PPC4xx
	PIP405		PPC4xx

Werner Pfister <Pfister_Werner@intercontrol.de>
	digsy_mtc	mpc5200
	digsy_mtc_rev5	mpc5200

Kim Phillips <kim.phillips@freescale.com>

	MPC8349EMDS	MPC8349

Daniel Poirot <dan.poirot@windriver.com>

	sbc8240		MPC8240
	sbc405		PPC405GP

Sergei Poselenov <sposelenov@emcraft.com>

	a4m072		MPC5200

Sudhakar Rajashekhara <sudhakar.raj@ti.com>

	da850evm	ARM926EJS (DA850/OMAP-L138)

Ricardo Ribalda <ricardo.ribalda@uam.es>

	ml507 		PPC440x5
	v5fx30teval	PPC440x5
	xilinx-ppc405-generic	PPC405
	xilinx-ppc440-generic	PPC440x5

Stefan Roese <sr@denx.de>

	P3M7448		MPC7448

	uc100		MPC857

	TQM85xx		MPC8540/8541/8555/8560

	acadia		PPC405EZ
	alpr		PPC440GX
	bamboo		PPC440EP
	bunbinga	PPC405EP
	canyonlands	PPC460EX
	ebony		PPC440GP
	glacier		PPC460GT
	haleakala	PPC405EXr
	icon		PPC440SPe
	katmai		PPC440SPe
	kilauea		PPC405EX
	lwmon5		PPC440EPx
	makalu		PPC405EX
	ocotea		PPC440GX
	p3p440		PPC440GP
	pcs440ep	PPC440EP
	rainier		PPC440GRx
	sequoia		PPC440EPx
	sycamore	PPC405GPr
	t3corp		PPC460GT
	taishan		PPC440GX
	walnut		PPC405GP
	yellowstone	PPC440GR
	yosemite	PPC440EP
	zeus		PPC405EP

	P3M750		PPC750FX/GX/GL

Yusdi Santoso <yusdi_santoso@adaptec.com>

	HIDDEN_DRAGON	MPC8241/MPC8245

Travis Sawyer (travis.sawyer@sandburst.com>

	KAREF		PPC440GX
	METROBOX	PPC440GX

Georg Schardt <schardt@team-ctech.de>

	fx12mm		PPC405

Heiko Schocher <hs@denx.de>

	charon		MPC5200
	ids8247		MPC8247
	jupiter		MPC5200
	kmeter1		MPC8360
	kmsupx5		MPC8321
	mgcoge		MPC8247
	mgcoge3ne	MPC8247
	mucmc52		MPC5200
	muas3001	MPC8270
	municse		MPC5200
	sc3		PPC405GP
	suvd3		MPC8321
	tuda1		MPC8321
	tuxa1		MPC8321
	uc101		MPC5200
	ve8313		MPC8313

Peter De Schrijver <p2@mind.be>

	ML2		PPC4xx

Andre Schwarz <andre.schwarz@matrix-vision.de>

	mergerbox	MPC8377
	mvbc_p		MPC5200
	mvblm7		MPC8343
	mvsmr		MPC5200

Jon Smirl <jonsmirl@gmail.com>

	pcm030		MPC5200

Timur Tabi <timur@freescale.com>

	MPC8349E-mITX	MPC8349
	MPC8349E-mITX-GP MPC8349
	P1022DS		P1022

Erik Theisen <etheisen@mindspring.com>

	W7OLMC		PPC4xx
	W7OLMG		PPC4xx

Jim Thompson <jim@musenki.com>

	MUSENKI		MPC8245/8241
	Sandpoint8245	MPC8245

Rune Torgersen <runet@innovsys.com>

	MPC8266ADS	MPC8266

Peter Tyser <ptyser@xes-inc.com>

	xpedite1000	PPC440GX
	xpedite5170	MPC8640
	xpedite5200	MPC8548
	xpedite5370	MPC8572
	xpedite5500	P2020

David Updegraff <dave@cray.com>

	CRAYL1		PPC4xx

Anton Vorontsov <avorontsov@ru.mvista.com>

	MPC8360ERDK	MPC8360

Josef Wagner <Wagner@Microsys.de>

	CPC45		MPC8245
	PM520		MPC5200

Michael Weiss <michael.weiss@ifm.com>

	PDM360NG	MPC5121e

Stephen Williams <steve@icarus.com>

	JSE		PPC405GPr

Ilya Yanok <yanok@emcraft.com>

	mpc8308_p1m	MPC8308
	MPC8308RDB	MPC8308

Roy Zang <tie-fei.zang@freescale.com>

	mpc7448hpc2	MPC7448
	P1023RDS	P1023

John Zhan <zhanz@sinovee.com>

	svm_sc8xx	MPC8xx

Detlev Zundel <dzu@denx.de>

	inka4x0		MPC5200

-------------------------------------------------------------------------

Unknown / orphaned boards:

	ADS860		MPC8xx
	FADS823		MPC8xx
	FADS850SAR	MPC8xx
	FADS860T	MPC8xx
	GENIETV		MPC8xx
	IAD210		MPC8xx
	MBX		MPC8xx
	MBX860T		MPC8xx
	NX823		MPC8xx
	RPXClassic	MPC8xx
	RPXlite		MPC8xx

	MOUSSE		MPC824x

	RPXsuper	MPC8260
	rsdproto	MPC8260

	EVB64260	MPC7xx_74xx

	integratorcp	various
	versatile	ARM926EJ-S
	versatile	ARM926EJ-S


#########################################################################
# ARM Systems:								#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Albert ARIBAUD <albert.u.boot@aribaud.net>

	edminiv2	ARM926EJS (Orion5x SoC)

Rowel Atienza <rowel@diwalabs.com>

	armadillo	ARM720T

Stefano Babic <sbabic@denx.de>

	ea20		davinci
	mx35pdk		i.MX35
	mx51evk		i.MX51
	polaris		xscale/pxa
	trizepsiv	xscale/pxa
 	vision2		i.MX51

Jason Liu <r64343@freescale.com>

	mx53evk         i.MX53
	mx53loco        i.MX53

Enric Balletbo i Serra <eballetbo@iseebcn.com>

	igep0020	ARM ARMV7 (OMAP3xx SoC)
	igep0030	ARM ARMV7 (OMAP3xx SoC)

Dirk Behme <dirk.behme@gmail.com>

	omap3_beagle	ARM ARMV7 (OMAP3530 SoC)

Eric Benard <eric@eukrea.com>

	cpuat91		ARM920T
	cpu9260		ARM926EJS (AT91SAM9260 SoC)
	cpu9G20		ARM926EJS (AT91SAM9G20 SoC)

Ajay Bhargav <ajay.bhargav@einfochips.com>

	gplugd		ARM926EJS (ARMADA100 88AP168 SoC)

Rishi Bhattacharya <rishi@ti.com>

	omap5912osk	ARM926EJS

Andreas Bießmann <andreas.devel@gmail.com>

	at91rm9200ek	at91rm9200
	grasshopper	avr32

Cliff Brake <cliff.brake@gmail.com>

	pxa255_idp	xscale/pxa

Rick Bronson <rick@efn.org>

	AT91RM9200DK	at91rm9200

Luca Ceresoli <luca.ceresoli@comelit.it>

	dig297		ARM ARMV7 (OMAP3530 SoC)

Po-Yu Chuang <ratbert@faraday-tech.com>

	a320evb		FA526 (ARM920T-like) (a320 SoC)

Eric Cooper <ecc@cmu.edu>

	dockstar	ARM926EJS (Kirkwood SoC)

George G. Davis <gdavis@mvista.com>

	assabet		SA1100
	gcplus		SA1100

Wolfgang Denk <wd@denx.de>
	imx27lite	i.MX27
	qong		i.MX31

Thomas Elste <info@elste.org>

	modnet50	ARM720T (NET+50)

Kristoffer Ericson <kristoffer.ericson@gmail.com>

	jornada	SA1110

Fabio Estevam <fabio.estevam@freescale.com>

	mx31pdk		i.MX31
	mx53ard		i.MX53
	mx53smd		i.MX53

Daniel Gorsulowski <daniel.gorsulowski@esd.eu>

	meesc		ARM926EJS (AT91SAM9263 SoC)
	otc570		ARM926EJS (AT91SAM9263 SoC)

Sedji Gaouaou<sedji.gaouaou@atmel.com>
	at91sam9g10ek		ARM926EJS (AT91SAM9G10 SoC)
	at91sam9m10g45ek	ARM926EJS (AT91SAM9G45 SoC)

Simon Guinot <simon.guinot@sequanux.org>

	inetspace_v2	ARM926EJS (Kirkwood SoC)
	netspace_v2	ARM926EJS (Kirkwood SoC)
	netspace_max_v2	ARM926EJS (Kirkwood SoC)

Marius Gröger <mag@sysgo.de>

	impa7		ARM720T (EP7211)
	ep7312		ARM720T (EP7312)

Igor Grinberg <grinberg@compulab.co.il>

	cm-t35		ARM ARMV7 (OMAP3xx Soc)

Kshitij Gupta <kshitij@ti.com>

	omap1510inn	ARM925T
	omap1610inn	ARM926EJS

Vaibhav Hiremath <hvaibhav@ti.com>

	am3517_evm	ARM ARMV7 (AM35x SoC)

Grazvydas Ignotas <notasas@gmail.com>

	omap3_pandora	ARM ARMV7 (OMAP3xx SoC)

Gary Jennejohn <garyj@denx.de>

	smdk2400	ARM920T

Matthias Kaehlcke <matthias@kaehlcke.net>
	edb9301			ARM920T (EP9301)
	edb9302			ARM920T (EP9302)
	edb9302a		ARM920T (EP9302)
	edb9307			ARM920T (EP9307)
	edb9307a		ARM920T (EP9307)
	edb9312			ARM920T (EP9312)
	edb9315			ARM920T (EP9315)
	edb9315a		ARM920T (EP9315)

Nishant Kamat <nskamat@ti.com>

	omap1610h2	ARM926EJS

Minkyu Kang <mk7.kang@samsung.com>

	SMDKC100		ARM ARMV7 (S5PC100 SoC)
	s5p_goni		ARM ARMV7 (S5PC110 SoC)
	s5pc210_universal	ARM ARMV7 (S5PC210 SoC)

Chander Kashyap <k.chander@samsung.com>

	SMDKV310		ARM ARMV7 (S5PC210 SoC)

Torsten Koschorrek <koschorrek@synertronixx.de>
	scb9328		ARM920T (i.MXL)

Frederik Kriewitz <frederik@kriewitz.eu>

	devkit8000	ARM ARMV7 (OMAP3530 SoC)

Sergey Kubushyn <ksi@koi8.net>

	DV-EVM		ARM926EJS
	SONATA		ARM926EJS
	SCHMOOGIE	ARM926EJS

Prakash Kumar <prakash@embedx.com>

	cerf250		xscale/pxa

Vipin Kumar <vipin.kumar@st.com>

	spear300	ARM926EJS (spear300 Soc)
	spear310	ARM926EJS (spear310 Soc)
	spear320	ARM926EJS (spear320 Soc)
	spear600	ARM926EJS (spear600 Soc)

Sergey Lapin <slapin@ossfans.org>

	afeb9260	ARM926EJS (AT91SAM9260 SoC)

Valentin Longchamp <valentin.longchamp@keymile.com>

	km_kirkwood	ARM926EJS (Kirkwood SoC)
	portl2		ARM926EJS (Kirkwood SoC)

Nishanth Menon <nm@ti.com>

	omap3_sdp3430	ARM ARMV7 (OMAP3xx SoC)
	omap3_zoom1	ARM ARMV7 (OMAP3xx SoC)

David Müller <d.mueller@elsoft.ch>

	smdk2410	ARM920T
	VCMA9		ARM920T

Eric Millbrandt <emillbrandt@dekaresearch.com>

	galaxy5200	mpc5200

Nagendra T S  <nagendra@mistralsolutions.com>

   am3517_crane    ARM ARMV7 (AM35x SoC)

Rolf Offermanns <rof@sysgo.de>

	shannon		SA1100

Kyungmin Park <kyungmin.park@samsung.com>

	apollon		ARM1136EJS

Sandeep Paulraj <s-paulraj@ti.com>

	davinci_dm355evm	ARM926EJS
	davinci_dm355leopard	ARM926EJS
	davinci_dm365evm	ARM926EJS
	davinci_dm6467evm	ARM926EJS

Linus Walleij <linus.walleij@linaro.org>
	integratorap	ARM920T

Dave Peverley <dpeverley@mpc-data.co.uk>

	omap730p2	ARM926EJS

Manikandan Pillai <mani.pillai@ti.com>

	omap3_evm	ARM ARMV7 (OMAP3xx SoC)

Stelian Pop <stelian.pop@leadtechdesign.com>

	at91cap9adk	ARM926EJS (AT91CAP9 SoC)
	at91sam9260ek	ARM926EJS (AT91SAM9260 SoC)
	at91sam9261ek	ARM926EJS (AT91SAM9261 SoC)
	at91sam9263ek	ARM926EJS (AT91SAM9263 SoC)
	at91sam9rlek	ARM926EJS (AT91SAM9RL SoC)

Tom Rix <Tom.Rix@windriver.com>

	omap3_zoom2	ARM ARMV7 (OMAP3xx SoC)

John Rigby <jcrigby@gmail.com>

	tx25		i.MX25

Stefan Roese <sr@denx.de>

	ixdpg425	xscale/ixp
	pdnb3		xscale/ixp
	scpu		xscale/ixp

Alessandro Rubini <rubini@unipv.it>
Nomadik Linux Team <STN_WMM_nomadik_linux@list.st.com>

	nhk8815		ARM926EJS (Nomadik 8815 Soc)

Steve Sakoman <sakoman@gmail.com>

	omap3_overo	ARM ARMV7 (OMAP3xx SoC)
	omap4_panda	ARM ARMV7 (OMAP4xx SoC)
	omap4_sdp4430	ARM ARMV7 (OMAP4xx SoC)

Jens Scharsig <esw@bus-elektronik.de>

	eb_cpux9k2	ARM920T (AT91RM9200 SoC)

Heiko Schocher <hs@denx.de>

	magnesium	i.MX27
	mgcoge3un	ARM926EJS (Kirkwood SoC)

Robert Schwebel <r.schwebel@pengutronix.de>

	csb226		xscale/pxa
	innokom		xscale/pxa

Michael Schwingen <michael@schwingen.org>

	actux1		xscale/ixp
	actux2		xscale/ixp
	actux3		xscale/ixp
	actux4		xscale/ixp
	dvlhost		xscale/ixp

Andrea Scian <andrea.scian@dave-tech.it>

	B2		ARM7TDMI (S3C44B0X)

Nick Thompson <nick.thompson@gefanuc.com>

	da830evm	ARM926EJS (DA830/OMAP-L137)

Albin Tonnerre <albin.tonnerre@free-electrons.com>

	sbc35_a9g20	ARM926EJS (AT91SAM9G20 SoC)
	tny_a9260	ARM926EJS (AT91SAM9260 SoC)
	tny_a9g20	ARM926EJS (AT91SAM9G20 SoC)

Greg Ungerer <greg.ungerer@opengear.com>

	cm4008		ks8695p
	cm4116		ks8695p
	cm4148		ks8695p

Marek Vasut <marek.vasut@gmail.com>

	balloon3	xscale/pxa
	colibri_pxa270	xscale/pxa
	palmld		xscale/pxa
	palmtc		xscale/pxa
	vpac270		xscale/pxa
	zipitz2		xscale/pxa
 	efikamx		i.MX51

Hugo Villeneuve <hugo.villeneuve@lyrtech.com>

	SFFSDR		ARM926EJS

Matt Waddel <matt.waddel@linaro.org>

	ca9x4_ct_vxp	ARM ARMV7 (Quad Core)

Prafulla Wadaskar <prafulla@marvell.com>

	aspenite	ARM926EJS (ARMADA100 88AP168 SoC)
	mv88f6281gtw_ge	ARM926EJS (Kirkwood SoC)
	openrd_base     ARM926EJS (Kirkwood SoC)
	rd6281a		ARM926EJS (Kirkwood SoC)
	sheevaplug	ARM926EJS (Kirkwood SoC)

Tom Warren <twarren@nvidia.com>

	harmony		Tegra2 (ARM7 & A9 Dual Core)
	seaboard	Tegra2 (ARM7 & A9 Dual Core)

Lei Wen <leiwen@marvell.com>

	dkb		ARM926EJS (PANTHEON 88AP920 SOC)

Matthias Weisser <weisserm@arcor.de>

	jadecpu		ARM926EJS (MB86R01 SoC)
	zmx25		ARM926EJS (imx25 SoC)

Richard Woodruff <r-woodruff2@ti.com>

	omap2420h4	ARM1136EJS

Alex Züpke <azu@sysgo.de>

	lart		SA1100
	dnp1110		SA1110

Syed Mohammed Khasim <sm.khasim@gmail.com>
Sughosh Ganu <urwithsughosh@gmail.com>

	hawkboard	ARM926EJS (OMAP-L138)

-------------------------------------------------------------------------

Unknown / orphaned boards:
 	Board		CPU	Last known maintainer / Comment
.........................................................................
	cradle		xscale/pxa	Kyle Harris <kharris@nexus-tech.net> / dead address
	ixdp425		xscale/ixp	Kyle Harris <kharris@nexus-tech.net> / dead address
	lubbock		xscale/pxa	Kyle Harris <kharris@nexus-tech.net> / dead address

	imx31_phycore_eet i.MX31  Guennadi Liakhovetski <g.liakhovetski@gmx.de> / resigned
	mx31ads		  i.MX31  Guennadi Liakhovetski <g.liakhovetski@gmx.de> / resigned
	SMDK6400	  S3C6400 Guennadi Liakhovetski <g.liakhovetski@gmx.de> / resigned

#########################################################################
# x86 Systems:								#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Graeme Russ <graeme.russ@gmail.com>

	eNET		AMD SC520

#########################################################################
# MIPS Systems:								#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Wolfgang Denk <wd@denx.de>

	incaip		MIPS32 4Kc

Thomas Lange <thomas@corelatus.se>
	dbau1x00	MIPS32 Au1000
	gth2		MIPS32 Au1000

Vlad Lungu <vlad.lungu@windriver.com>
	qemu_mips	MIPS32

Stefan Roese <sr@denx.de>

	vct_xxx		MIPS32 4Kc

#########################################################################
# Nios-II Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Scott McNutt <smcnutt@psyent.com>

	PCI5441		Nios-II
	PK1C20		Nios-II
	nios2-generic	Nios-II

#########################################################################
# MicroBlaze Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Michal Simek <monstr@monstr.eu>

	microblaze-generic	MicroBlaze

#########################################################################
# Coldfire Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Hayden Fraser <Hayden.Fraser@freescale.com>

	M5253EVBE	mcf52x2

Matthias Fuchs <matthias.fuchs@esd-electronics.com>

	TASREG		MCF5249

TsiChung Liew <Tsi-Chung.Liew@freescale.com>

	M52277EVB	mcf5227x
	M5235EVB	mcf52x2
	M5253DEMO	mcf52x2
	M53017EVB	mcf532x
	M5329EVB	mcf532x
	M5373EVB	mcf532x
	M54455EVB	mcf5445x
	M5475EVB	mcf547x_8x
	M5485EVB	mcf547x_8x

Wolfgang Wegner <w.wegner@astro-kom.de>

	astro_mcf5373l	MCF5373L

#########################################################################
# AVR32 Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>

	FAVR-32-EZKIT		AT32AP7000

Mark Jackson <mpfj@mimc.co.uk>

	MIMC200			AT32AP7000

Alex Raimondi <alex.raimondi@miromico.ch>
Julien May <julien.may@miromico.ch>

	HAMMERHEAD		AT32AP7000

Haavard Skinnemoen <haavard.skinnemoen@atmel.com>

	ATSTK1000	AT32AP7xxx
	ATSTK1002	AT32AP7000
	ATSTK1003	AT32AP7001
	ATSTK1004	AT32AP7002
	ATSTK1006	AT32AP7000
	ATNGW100	AT32AP7000

#########################################################################
# SuperH Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Yusuke Goda <goda.yusuke@renesas.com>

	MIGO-R		SH7722

Nobuhiro Iwamatsu <iwamatsu@nigauri.org>
		  <iwamatsu.nobuhiro@renesas.com>

	MS7750SE	SH7750
	MS7722SE	SH7722
	R7780MP		SH7780
	R2DPlus		SH7751R
	SH7763RDP	SH7763
	RSK7203		SH7203
	AP325RXA	SH7723
	SHMIN		SH7706

Mark Jonas <mark.jonas@de.bosch.com>

	mpr2		SH7720

Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>

	MS7720SE	SH7720
	R0P77570030RL	SH7757
	R0P77850011RL	SH7785

#########################################################################
# Blackfin Systems:							#
#									#
# Maintainer Name, Email Address					#
#	Board		CPU						#
#########################################################################

Mike Frysinger <vapier@gentoo.org>
Blackfin Team <u-boot-devel@blackfin.uclinux.org>

	BF506F-EZKIT	BF506
	BF518F-EZBRD	BF518
	BF526-EZBRD	BF526
	BF527-AD7160-EVAL	BF527
	BF527-EZKIT	BF527
	BF527-EZKIT-V2	BF527
	BF527-SDP	BF527
	BF533-EZKIT	BF533
	BF533-STAMP	BF533
	BF537-PNAV	BF537
	BF537-STAMP	BF537
	BF538F-EZKIT	BF538
	BF548-EZKIT	BF548
	BF561-EZKIT	BF561

M.Hasewinkel (MHA) <info@ssv-embedded.de>

	dnp5370		BF537

Brent Kandetzki <brentk@teleco.com>

	IP04		BF532

Peter Meerwald <devel@bct-electronic.com>

	bct-brettl2	BF536

I-SYST Micromodule <support@i-syst.com>

	IBF-DSP561	BF561

Wojtek Skulski <skulski@pas.rochester.edu>
Wojtek Skulski <info@skutek.com>
Benjamin Matthews <mben12@gmail.com>

	BlackStamp	BF533
	BlackVME	BF561

Martin Strubel <strubel@section5.ch>

	BF537-minotaur	BF537
	BF537-srv1	BF537

Bluetechnix Tinyboards <bluetechnix@blackfin.uclinux.org>

	CM-BF527	BF527
	CM-BF533	BF533
	CM-BF537E	BF537
	CM-BF537U	BF537
	CM-BF548	BF548
	CM-BF561	BF561
	TCM-BF518	BF518
	TCM-BF537	BF537

Valentin Yakovenkov <yakovenkov@niistt.ru>
Anton Shurpin <shurpin.aa@niistt.ru>

	BF561-ACVILON	BF561

Haitao Zhang <hzhang@ucrobotics.com>
Chong Huang <chuang@ucrobotics.com>

	bf525-ucr2	BF525

#########################################################################
# End of MAINTAINERS list						#
#########################################################################
