[people/ms/u-boot.git] / board / raspberrypi / rpi / rpi.c

/*
 * (C) Copyright 2012-2013,2015 Stephen Warren
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

#include <common.h>
#include <config.h>
#include <dm.h>
#include <fdt_support.h>
#include <fdt_simplefb.h>
#include <lcd.h>
#include <mmc.h>
#include <asm/gpio.h>
#include <asm/arch/mbox.h>
#include <asm/arch/sdhci.h>
#include <asm/global_data.h>
#include <dm/platform_data/serial_pl01x.h>

DECLARE_GLOBAL_DATA_PTR;

static const struct bcm2835_gpio_platdata gpio_platdata = {
	.base = BCM2835_GPIO_BASE,
};

U_BOOT_DEVICE(bcm2835_gpios) = {
	.name = "gpio_bcm2835",
	.platdata = &gpio_platdata,
};

static const struct pl01x_serial_platdata serial_platdata = {
#ifdef CONFIG_BCM2836
	.base = 0x3f201000,
#else
	.base = 0x20201000,
#endif
	.type = TYPE_PL011,
	.clock = 3000000,
};

U_BOOT_DEVICE(bcm2835_serials) = {
	.name = "serial_pl01x",
	.platdata = &serial_platdata,
};

struct msg_get_arm_mem {
	struct bcm2835_mbox_hdr hdr;
	struct bcm2835_mbox_tag_get_arm_mem get_arm_mem;
	u32 end_tag;
};

struct msg_get_board_rev {
	struct bcm2835_mbox_hdr hdr;
	struct bcm2835_mbox_tag_get_board_rev get_board_rev;
	u32 end_tag;
};

struct msg_get_mac_address {
	struct bcm2835_mbox_hdr hdr;
	struct bcm2835_mbox_tag_get_mac_address get_mac_address;
	u32 end_tag;
};

struct msg_set_power_state {
	struct bcm2835_mbox_hdr hdr;
	struct bcm2835_mbox_tag_set_power_state set_power_state;
	u32 end_tag;
};

struct msg_get_clock_rate {
	struct bcm2835_mbox_hdr hdr;
	struct bcm2835_mbox_tag_get_clock_rate get_clock_rate;
	u32 end_tag;
};

/* See comments in mbox.h for data source */
static const struct {
	const char *name;
	const char *fdtfile;
	bool has_onboard_eth;
} models[] = {
	[0] = {
		"Unknown model",
#ifdef CONFIG_BCM2836
		"bcm2836-rpi-other.dtb",
#else
		"bcm2835-rpi-other.dtb",
#endif
		false,
	},
#ifdef CONFIG_BCM2836
	[BCM2836_BOARD_REV_2_B] = {
		"2 Model B",
		"bcm2836-rpi-2-b.dtb",
		true,
	},
#else
	[BCM2835_BOARD_REV_B_I2C0_2] = {
		"Model B (no P5)",
		"bcm2835-rpi-b-i2c0.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_I2C0_3] = {
		"Model B (no P5)",
		"bcm2835-rpi-b-i2c0.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_I2C1_4] = {
		"Model B",
		"bcm2835-rpi-b.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_I2C1_5] = {
		"Model B",
		"bcm2835-rpi-b.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_I2C1_6] = {
		"Model B",
		"bcm2835-rpi-b.dtb",
		true,
	},
	[BCM2835_BOARD_REV_A_7] = {
		"Model A",
		"bcm2835-rpi-a.dtb",
		false,
	},
	[BCM2835_BOARD_REV_A_8] = {
		"Model A",
		"bcm2835-rpi-a.dtb",
		false,
	},
	[BCM2835_BOARD_REV_A_9] = {
		"Model A",
		"bcm2835-rpi-a.dtb",
		false,
	},
	[BCM2835_BOARD_REV_B_REV2_d] = {
		"Model B rev2",
		"bcm2835-rpi-b-rev2.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_REV2_e] = {
		"Model B rev2",
		"bcm2835-rpi-b-rev2.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_REV2_f] = {
		"Model B rev2",
		"bcm2835-rpi-b-rev2.dtb",
		true,
	},
	[BCM2835_BOARD_REV_B_PLUS] = {
		"Model B+",
		"bcm2835-rpi-b-plus.dtb",
		true,
	},
	[BCM2835_BOARD_REV_CM] = {
		"Compute Module",
		"bcm2835-rpi-cm.dtb",
		false,
	},
	[BCM2835_BOARD_REV_A_PLUS] = {
		"Model A+",
		"bcm2835-rpi-a-plus.dtb",
		false,
	},
#endif
};

u32 rpi_board_rev = 0;

int dram_init(void)
{
	ALLOC_ALIGN_BUFFER(struct msg_get_arm_mem, msg, 1, 16);
	int ret;

	BCM2835_MBOX_INIT_HDR(msg);
	BCM2835_MBOX_INIT_TAG(&msg->get_arm_mem, GET_ARM_MEMORY);

	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	if (ret) {
		printf("bcm2835: Could not query ARM memory size\n");
		return -1;
	}

	gd->ram_size = msg->get_arm_mem.body.resp.mem_size;

	return 0;
}

static void set_fdtfile(void)
{
	const char *fdtfile;

	if (getenv("fdtfile"))
		return;

	fdtfile = models[rpi_board_rev].fdtfile;
	setenv("fdtfile", fdtfile);
}

static void set_usbethaddr(void)
{
	ALLOC_ALIGN_BUFFER(struct msg_get_mac_address, msg, 1, 16);
	int ret;

	if (!models[rpi_board_rev].has_onboard_eth)
		return;

	if (getenv("usbethaddr"))
		return;

	BCM2835_MBOX_INIT_HDR(msg);
	BCM2835_MBOX_INIT_TAG(&msg->get_mac_address, GET_MAC_ADDRESS);

	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	if (ret) {
		printf("bcm2835: Could not query MAC address\n");
		/* Ignore error; not critical */
		return;
	}

	eth_setenv_enetaddr("usbethaddr", msg->get_mac_address.body.resp.mac);

	return;
}

int misc_init_r(void)
{
	set_fdtfile();
	set_usbethaddr();
	return 0;
}

static int power_on_module(u32 module)
{
	ALLOC_ALIGN_BUFFER(struct msg_set_power_state, msg_pwr, 1, 16);
	int ret;

	BCM2835_MBOX_INIT_HDR(msg_pwr);
	BCM2835_MBOX_INIT_TAG(&msg_pwr->set_power_state,
			      SET_POWER_STATE);
	msg_pwr->set_power_state.body.req.device_id = module;
	msg_pwr->set_power_state.body.req.state =
		BCM2835_MBOX_SET_POWER_STATE_REQ_ON |
		BCM2835_MBOX_SET_POWER_STATE_REQ_WAIT;

	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN,
				     &msg_pwr->hdr);
	if (ret) {
		printf("bcm2835: Could not set module %u power state\n",
		       module);
		return -1;
	}

	return 0;
}

static void get_board_rev(void)
{
	ALLOC_ALIGN_BUFFER(struct msg_get_board_rev, msg, 1, 16);
	int ret;
	const char *name;

	BCM2835_MBOX_INIT_HDR(msg);
	BCM2835_MBOX_INIT_TAG(&msg->get_board_rev, GET_BOARD_REV);

	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	if (ret) {
		printf("bcm2835: Could not query board revision\n");
		/* Ignore error; not critical */
		return;
	}

	/*
	 * For details of old-vs-new scheme, see:
	 * https://github.com/pimoroni/RPi.version/blob/master/RPi/version.py
	 * http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=99293&p=690282
	 * (a few posts down)
	 *
	 * For the RPi 1, bit 24 is the "warranty bit", so we mask off just the
	 * lower byte to use as the board rev:
	 * http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=98367&start=250
	 * http://www.raspberrypi.org/forums/viewtopic.php?f=31&t=20594
	 */
	rpi_board_rev = msg->get_board_rev.body.resp.rev;
	if (rpi_board_rev & 0x800000)
		rpi_board_rev = (rpi_board_rev >> 4) & 0xff;
	else
		rpi_board_rev &= 0xff;
	if (rpi_board_rev >= ARRAY_SIZE(models)) {
		printf("RPI: Board rev %u outside known range\n",
		       rpi_board_rev);
		rpi_board_rev = 0;
	}
	if (!models[rpi_board_rev].name) {
		printf("RPI: Board rev %u unknown\n", rpi_board_rev);
		rpi_board_rev = 0;
	}

	name = models[rpi_board_rev].name;
	printf("RPI %s\n", name);
}

int board_init(void)
{
	get_board_rev();

	gd->bd->bi_boot_params = 0x100;

	return power_on_module(BCM2835_MBOX_POWER_DEVID_USB_HCD);
}

int board_mmc_init(bd_t *bis)
{
	ALLOC_ALIGN_BUFFER(struct msg_get_clock_rate, msg_clk, 1, 16);
	int ret;

	power_on_module(BCM2835_MBOX_POWER_DEVID_SDHCI);

	BCM2835_MBOX_INIT_HDR(msg_clk);
	BCM2835_MBOX_INIT_TAG(&msg_clk->get_clock_rate, GET_CLOCK_RATE);
	msg_clk->get_clock_rate.body.req.clock_id = BCM2835_MBOX_CLOCK_ID_EMMC;

	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg_clk->hdr);
	if (ret) {
		printf("bcm2835: Could not query eMMC clock rate\n");
		return -1;
	}

	return bcm2835_sdhci_init(BCM2835_SDHCI_BASE,
				  msg_clk->get_clock_rate.body.resp.rate_hz);
}

int ft_board_setup(void *blob, bd_t *bd)
{
	/*
	 * For now, we simply always add the simplefb DT node. Later, we
	 * should be more intelligent, and e.g. only do this if no enabled DT
	 * node exists for the "real" graphics driver.
	 */
	lcd_dt_simplefb_add_node(blob);

	return 0;
}
Commit	Line	Data
0d04f34a	1	/*
46414296	2	* (C) Copyright 2012-2013,2015 Stephen Warren
0d04f34a	3	*
a033171b	4	* SPDX-License-Identifier: GPL-2.0
0d04f34a SW	5	*/
	6
	7	#include <common.h>
ea697ae7	8	#include <config.h>
41e98e01	9	#include <dm.h>
5dfd162e	10	#include <fdt_support.h>
033167c4	11	#include <fdt_simplefb.h>
ea697ae7	12	#include <lcd.h>
5dfd162e	13	#include <mmc.h>
41e98e01	14	#include <asm/gpio.h>
3f397782	15	#include <asm/arch/mbox.h>
131a1e60	16	#include <asm/arch/sdhci.h>
0d04f34a	17	#include <asm/global_data.h>
11506666	18	#include <dm/platform_data/serial_pl01x.h>
0d04f34a SW	19
	20	DECLARE_GLOBAL_DATA_PTR;
	21
41e98e01 SG	22	static const struct bcm2835_gpio_platdata gpio_platdata = {
	23	.base = BCM2835_GPIO_BASE,
	24	};
	25
	26	U_BOOT_DEVICE(bcm2835_gpios) = {
	27	.name = "gpio_bcm2835",
	28	.platdata = &gpio_platdata,
	29	};
	30
11506666	31	static const struct pl01x_serial_platdata serial_platdata = {
46414296 SW	32	#ifdef CONFIG_BCM2836
	33	.base = 0x3f201000,
	34	#else
11506666	35	.base = 0x20201000,
46414296	36	#endif
11506666 SG	37	.type = TYPE_PL011,
	38	.clock = 3000000,
	39	};
	40
	41	U_BOOT_DEVICE(bcm2835_serials) = {
	42	.name = "serial_pl01x",
	43	.platdata = &serial_platdata,
	44	};
	45
3f397782 SW	46	struct msg_get_arm_mem {
	47	struct bcm2835_mbox_hdr hdr;
	48	struct bcm2835_mbox_tag_get_arm_mem get_arm_mem;
	49	u32 end_tag;
	50	};
	51
6fe7845a SW	52	struct msg_get_board_rev {
	53	struct bcm2835_mbox_hdr hdr;
	54	struct bcm2835_mbox_tag_get_board_rev get_board_rev;
	55	u32 end_tag;
	56	};
	57
4f80a06d SW	58	struct msg_get_mac_address {
	59	struct bcm2835_mbox_hdr hdr;
	60	struct bcm2835_mbox_tag_get_mac_address get_mac_address;
	61	u32 end_tag;
	62	};
	63
f66f2aa2 SW	64	struct msg_set_power_state {
	65	struct bcm2835_mbox_hdr hdr;
	66	struct bcm2835_mbox_tag_set_power_state set_power_state;
	67	u32 end_tag;
	68	};
	69
131a1e60 SW	70	struct msg_get_clock_rate {
	71	struct bcm2835_mbox_hdr hdr;
	72	struct bcm2835_mbox_tag_get_clock_rate get_clock_rate;
	73	u32 end_tag;
	74	};
	75
6fe7845a SW	76	/* See comments in mbox.h for data source */
	77	static const struct {
	78	const char *name;
	79	const char *fdtfile;
3207d8fc	80	bool has_onboard_eth;
6fe7845a	81	} models[] = {
914627fe SW	82	[0] = {
914627fe SW	83	"Unknown model",
46414296 SW	84	#ifdef CONFIG_BCM2836
	85	"bcm2836-rpi-other.dtb",
	86	#else
914627fe	87	"bcm2835-rpi-other.dtb",
46414296	88	#endif
914627fe SW	89	false,
914627fe SW	90	},
46414296 SW	91	#ifdef CONFIG_BCM2836
	92	[BCM2836_BOARD_REV_2_B] = {
	93	"2 Model B",
	94	"bcm2836-rpi-2-b.dtb",
	95	true,
	96	},
	97	#else
6fe7845a SW	98	[BCM2835_BOARD_REV_B_I2C0_2] = {
	99	"Model B (no P5)",
	100	"bcm2835-rpi-b-i2c0.dtb",
3207d8fc	101	true,
6fe7845a SW	102	},
	103	[BCM2835_BOARD_REV_B_I2C0_3] = {
	104	"Model B (no P5)",
	105	"bcm2835-rpi-b-i2c0.dtb",
3207d8fc	106	true,
6fe7845a SW	107	},
	108	[BCM2835_BOARD_REV_B_I2C1_4] = {
	109	"Model B",
	110	"bcm2835-rpi-b.dtb",
3207d8fc	111	true,
6fe7845a SW	112	},
	113	[BCM2835_BOARD_REV_B_I2C1_5] = {
	114	"Model B",
	115	"bcm2835-rpi-b.dtb",
3207d8fc	116	true,
6fe7845a SW	117	},
	118	[BCM2835_BOARD_REV_B_I2C1_6] = {
	119	"Model B",
	120	"bcm2835-rpi-b.dtb",
3207d8fc	121	true,
6fe7845a SW	122	},
	123	[BCM2835_BOARD_REV_A_7] = {
	124	"Model A",
	125	"bcm2835-rpi-a.dtb",
3207d8fc	126	false,
6fe7845a SW	127	},
	128	[BCM2835_BOARD_REV_A_8] = {
	129	"Model A",
	130	"bcm2835-rpi-a.dtb",
3207d8fc	131	false,
6fe7845a SW	132	},
	133	[BCM2835_BOARD_REV_A_9] = {
	134	"Model A",
	135	"bcm2835-rpi-a.dtb",
3207d8fc	136	false,
6fe7845a SW	137	},
	138	[BCM2835_BOARD_REV_B_REV2_d] = {
	139	"Model B rev2",
	140	"bcm2835-rpi-b-rev2.dtb",
3207d8fc	141	true,
6fe7845a SW	142	},
	143	[BCM2835_BOARD_REV_B_REV2_e] = {
	144	"Model B rev2",
	145	"bcm2835-rpi-b-rev2.dtb",
3207d8fc	146	true,
6fe7845a SW	147	},
	148	[BCM2835_BOARD_REV_B_REV2_f] = {
	149	"Model B rev2",
	150	"bcm2835-rpi-b-rev2.dtb",
3207d8fc	151	true,
6fe7845a SW	152	},
	153	[BCM2835_BOARD_REV_B_PLUS] = {
	154	"Model B+",
	155	"bcm2835-rpi-b-plus.dtb",
3207d8fc	156	true,
6fe7845a SW	157	},
	158	[BCM2835_BOARD_REV_CM] = {
	159	"Compute Module",
	160	"bcm2835-rpi-cm.dtb",
3207d8fc	161	false,
6fe7845a	162	},
47705eff SW	163	[BCM2835_BOARD_REV_A_PLUS] = {
	164	"Model A+",
	165	"bcm2835-rpi-a-plus.dtb",
	166	false,
	167	},
46414296	168	#endif
6fe7845a SW	169	};
	170
	171	u32 rpi_board_rev = 0;
	172
0d04f34a SW	173	int dram_init(void)
0d04f34a SW	174	{
3f397782 SW	175	ALLOC_ALIGN_BUFFER(struct msg_get_arm_mem, msg, 1, 16);
	176	int ret;
	177
	178	BCM2835_MBOX_INIT_HDR(msg);
	179	BCM2835_MBOX_INIT_TAG(&msg->get_arm_mem, GET_ARM_MEMORY);
	180
	181	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	182	if (ret) {
	183	printf("bcm2835: Could not query ARM memory size\n");
	184	return -1;
	185	}
	186
	187	gd->ram_size = msg->get_arm_mem.body.resp.mem_size;
0d04f34a SW	188
	189	return 0;
	190	}
	191
6fe7845a SW	192	static void set_fdtfile(void)
	193	{
	194	const char *fdtfile;
	195
	196	if (getenv("fdtfile"))
	197	return;
	198
	199	fdtfile = models[rpi_board_rev].fdtfile;
6fe7845a SW	200	setenv("fdtfile", fdtfile);
	201	}
	202
	203	static void set_usbethaddr(void)
4f80a06d SW	204	{
	205	ALLOC_ALIGN_BUFFER(struct msg_get_mac_address, msg, 1, 16);
	206	int ret;
	207
3207d8fc SW	208	if (!models[rpi_board_rev].has_onboard_eth)
	209	return;
	210
4f80a06d	211	if (getenv("usbethaddr"))
6fe7845a	212	return;
4f80a06d SW	213
	214	BCM2835_MBOX_INIT_HDR(msg);
	215	BCM2835_MBOX_INIT_TAG(&msg->get_mac_address, GET_MAC_ADDRESS);
	216
	217	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	218	if (ret) {
	219	printf("bcm2835: Could not query MAC address\n");
	220	/* Ignore error; not critical */
6fe7845a	221	return;
4f80a06d SW	222	}
	223
	224	eth_setenv_enetaddr("usbethaddr", msg->get_mac_address.body.resp.mac);
	225
6fe7845a SW	226	return;
	227	}
	228
	229	int misc_init_r(void)
	230	{
	231	set_fdtfile();
	232	set_usbethaddr();
4f80a06d SW	233	return 0;
	234	}
	235
f66f2aa2 SW	236	static int power_on_module(u32 module)
	237	{
	238	ALLOC_ALIGN_BUFFER(struct msg_set_power_state, msg_pwr, 1, 16);
	239	int ret;
	240
	241	BCM2835_MBOX_INIT_HDR(msg_pwr);
	242	BCM2835_MBOX_INIT_TAG(&msg_pwr->set_power_state,
	243	SET_POWER_STATE);
	244	msg_pwr->set_power_state.body.req.device_id = module;
	245	msg_pwr->set_power_state.body.req.state =
	246	BCM2835_MBOX_SET_POWER_STATE_REQ_ON \|
	247	BCM2835_MBOX_SET_POWER_STATE_REQ_WAIT;
	248
	249	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN,
	250	&msg_pwr->hdr);
	251	if (ret) {
	252	printf("bcm2835: Could not set module %u power state\n",
	253	module);
	254	return -1;
	255	}
	256
	257	return 0;
	258	}
	259
6fe7845a SW	260	static void get_board_rev(void)
	261	{
	262	ALLOC_ALIGN_BUFFER(struct msg_get_board_rev, msg, 1, 16);
	263	int ret;
	264	const char *name;
	265
	266	BCM2835_MBOX_INIT_HDR(msg);
	267	BCM2835_MBOX_INIT_TAG(&msg->get_board_rev, GET_BOARD_REV);
	268
	269	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	270	if (ret) {
	271	printf("bcm2835: Could not query board revision\n");
	272	/* Ignore error; not critical */
	273	return;
	274	}
	275
46414296 SW	276	/*
	277	* For details of old-vs-new scheme, see:
	278	* https://github.com/pimoroni/RPi.version/blob/master/RPi/version.py
	279	* http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=99293&p=690282
	280	* (a few posts down)
95b4f112 SW	281	*
	282	* For the RPi 1, bit 24 is the "warranty bit", so we mask off just the
	283	* lower byte to use as the board rev:
	284	* http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=98367&start=250
	285	* http://www.raspberrypi.org/forums/viewtopic.php?f=31&t=20594
46414296	286	*/
6fe7845a	287	rpi_board_rev = msg->get_board_rev.body.resp.rev;
46414296 SW	288	if (rpi_board_rev & 0x800000)
46414296 SW	289	rpi_board_rev = (rpi_board_rev >> 4) & 0xff;
95b4f112 SW	290	else
95b4f112 SW	291	rpi_board_rev &= 0xff;
47705eff SW	292	if (rpi_board_rev >= ARRAY_SIZE(models)) {
	293	printf("RPI: Board rev %u outside known range\n",
	294	rpi_board_rev);
6fe7845a	295	rpi_board_rev = 0;
47705eff	296	}
914627fe	297	if (!models[rpi_board_rev].name) {
47705eff	298	printf("RPI: Board rev %u unknown\n", rpi_board_rev);
914627fe	299	rpi_board_rev = 0;
47705eff	300	}
914627fe SW	301
914627fe SW	302	name = models[rpi_board_rev].name;
46414296	303	printf("RPI %s\n", name);
6fe7845a SW	304	}
6fe7845a SW	305
0d04f34a SW	306	int board_init(void)
0d04f34a SW	307	{
6fe7845a SW	308	get_board_rev();
6fe7845a SW	309
0d04f34a SW	310	gd->bd->bi_boot_params = 0x100;
0d04f34a SW	311
f66f2aa2	312	return power_on_module(BCM2835_MBOX_POWER_DEVID_USB_HCD);
0d04f34a	313	}
131a1e60	314
5dfd162e	315	int board_mmc_init(bd_t *bis)
131a1e60 SW	316	{
	317	ALLOC_ALIGN_BUFFER(struct msg_get_clock_rate, msg_clk, 1, 16);
	318	int ret;
	319
f66f2aa2 SW	320	power_on_module(BCM2835_MBOX_POWER_DEVID_SDHCI);
f66f2aa2 SW	321
131a1e60 SW	322	BCM2835_MBOX_INIT_HDR(msg_clk);
	323	BCM2835_MBOX_INIT_TAG(&msg_clk->get_clock_rate, GET_CLOCK_RATE);
	324	msg_clk->get_clock_rate.body.req.clock_id = BCM2835_MBOX_CLOCK_ID_EMMC;
	325
	326	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg_clk->hdr);
	327	if (ret) {
	328	printf("bcm2835: Could not query eMMC clock rate\n");
	329	return -1;
	330	}
	331
	332	return bcm2835_sdhci_init(BCM2835_SDHCI_BASE,
	333	msg_clk->get_clock_rate.body.resp.rate_hz);
	334	}
ea697ae7	335
e895a4b0	336	int ft_board_setup(void blob, bd_t bd)
ea697ae7 SW	337	{
	338	/*
	339	* For now, we simply always add the simplefb DT node. Later, we
	340	* should be more intelligent, and e.g. only do this if no enabled DT
	341	* node exists for the "real" graphics driver.
	342	*/
	343	lcd_dt_simplefb_add_node(blob);
e895a4b0 SG	344
e895a4b0 SG	345	return 0;
ea697ae7	346	}