[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,
	},
	[BCM2835_BOARD_REV_B_PLUS_13] = {
		"Model B+",
		"bcm2835-rpi-b-plus.dtb",
		true,
	},
	[BCM2835_BOARD_REV_CM_14] = {
		"Compute Module",
		"bcm2835-rpi-cm.dtb",
		false,
	},
#endif
};

u32 rpi_board_rev = 0;

int dram_init(void)
{
	ALLOC_CACHE_ALIGN_BUFFER(struct msg_get_arm_mem, msg, 1);
	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_CACHE_ALIGN_BUFFER(struct msg_get_mac_address, msg, 1);
	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_CACHE_ALIGN_BUFFER(struct msg_set_power_state, msg_pwr, 1);
	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_CACHE_ALIGN_BUFFER(struct msg_get_board_rev, msg, 1);
	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_CACHE_ALIGN_BUFFER(struct msg_get_clock_rate, msg_clk, 1);
	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	},
787affb4 SW	168	[BCM2835_BOARD_REV_B_PLUS_13] = {
	169	"Model B+",
	170	"bcm2835-rpi-b-plus.dtb",
	171	true,
	172	},
	173	[BCM2835_BOARD_REV_CM_14] = {
	174	"Compute Module",
	175	"bcm2835-rpi-cm.dtb",
	176	false,
	177	},
46414296	178	#endif
6fe7845a SW	179	};
	180
	181	u32 rpi_board_rev = 0;
	182
0d04f34a SW	183	int dram_init(void)
0d04f34a SW	184	{
927753ae	185	ALLOC_CACHE_ALIGN_BUFFER(struct msg_get_arm_mem, msg, 1);
3f397782 SW	186	int ret;
	187
	188	BCM2835_MBOX_INIT_HDR(msg);
	189	BCM2835_MBOX_INIT_TAG(&msg->get_arm_mem, GET_ARM_MEMORY);
	190
	191	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	192	if (ret) {
	193	printf("bcm2835: Could not query ARM memory size\n");
	194	return -1;
	195	}
	196
	197	gd->ram_size = msg->get_arm_mem.body.resp.mem_size;
0d04f34a SW	198
	199	return 0;
	200	}
	201
6fe7845a SW	202	static void set_fdtfile(void)
	203	{
	204	const char *fdtfile;
	205
	206	if (getenv("fdtfile"))
	207	return;
	208
	209	fdtfile = models[rpi_board_rev].fdtfile;
6fe7845a SW	210	setenv("fdtfile", fdtfile);
	211	}
	212
	213	static void set_usbethaddr(void)
4f80a06d	214	{
927753ae	215	ALLOC_CACHE_ALIGN_BUFFER(struct msg_get_mac_address, msg, 1);
4f80a06d SW	216	int ret;
4f80a06d SW	217
3207d8fc SW	218	if (!models[rpi_board_rev].has_onboard_eth)
	219	return;
	220
4f80a06d	221	if (getenv("usbethaddr"))
6fe7845a	222	return;
4f80a06d SW	223
	224	BCM2835_MBOX_INIT_HDR(msg);
	225	BCM2835_MBOX_INIT_TAG(&msg->get_mac_address, GET_MAC_ADDRESS);
	226
	227	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	228	if (ret) {
	229	printf("bcm2835: Could not query MAC address\n");
	230	/* Ignore error; not critical */
6fe7845a	231	return;
4f80a06d SW	232	}
	233
	234	eth_setenv_enetaddr("usbethaddr", msg->get_mac_address.body.resp.mac);
	235
6fe7845a SW	236	return;
	237	}
	238
	239	int misc_init_r(void)
	240	{
	241	set_fdtfile();
	242	set_usbethaddr();
4f80a06d SW	243	return 0;
	244	}
	245
f66f2aa2 SW	246	static int power_on_module(u32 module)
f66f2aa2 SW	247	{
927753ae	248	ALLOC_CACHE_ALIGN_BUFFER(struct msg_set_power_state, msg_pwr, 1);
f66f2aa2 SW	249	int ret;
	250
	251	BCM2835_MBOX_INIT_HDR(msg_pwr);
	252	BCM2835_MBOX_INIT_TAG(&msg_pwr->set_power_state,
	253	SET_POWER_STATE);
	254	msg_pwr->set_power_state.body.req.device_id = module;
	255	msg_pwr->set_power_state.body.req.state =
	256	BCM2835_MBOX_SET_POWER_STATE_REQ_ON \|
	257	BCM2835_MBOX_SET_POWER_STATE_REQ_WAIT;
	258
	259	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN,
	260	&msg_pwr->hdr);
	261	if (ret) {
	262	printf("bcm2835: Could not set module %u power state\n",
	263	module);
	264	return -1;
	265	}
	266
	267	return 0;
	268	}
	269
6fe7845a SW	270	static void get_board_rev(void)
6fe7845a SW	271	{
927753ae	272	ALLOC_CACHE_ALIGN_BUFFER(struct msg_get_board_rev, msg, 1);
6fe7845a SW	273	int ret;
	274	const char *name;
	275
	276	BCM2835_MBOX_INIT_HDR(msg);
	277	BCM2835_MBOX_INIT_TAG(&msg->get_board_rev, GET_BOARD_REV);
	278
	279	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg->hdr);
	280	if (ret) {
	281	printf("bcm2835: Could not query board revision\n");
	282	/* Ignore error; not critical */
	283	return;
	284	}
	285
46414296 SW	286	/*
	287	* For details of old-vs-new scheme, see:
	288	* https://github.com/pimoroni/RPi.version/blob/master/RPi/version.py
	289	* http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=99293&p=690282
	290	* (a few posts down)
95b4f112 SW	291	*
	292	* For the RPi 1, bit 24 is the "warranty bit", so we mask off just the
	293	* lower byte to use as the board rev:
	294	* http://www.raspberrypi.org/forums/viewtopic.php?f=63&t=98367&start=250
	295	* http://www.raspberrypi.org/forums/viewtopic.php?f=31&t=20594
46414296	296	*/
6fe7845a	297	rpi_board_rev = msg->get_board_rev.body.resp.rev;
46414296 SW	298	if (rpi_board_rev & 0x800000)
46414296 SW	299	rpi_board_rev = (rpi_board_rev >> 4) & 0xff;
95b4f112 SW	300	else
95b4f112 SW	301	rpi_board_rev &= 0xff;
47705eff SW	302	if (rpi_board_rev >= ARRAY_SIZE(models)) {
	303	printf("RPI: Board rev %u outside known range\n",
	304	rpi_board_rev);
6fe7845a	305	rpi_board_rev = 0;
47705eff	306	}
914627fe	307	if (!models[rpi_board_rev].name) {
47705eff	308	printf("RPI: Board rev %u unknown\n", rpi_board_rev);
914627fe	309	rpi_board_rev = 0;
47705eff	310	}
914627fe SW	311
914627fe SW	312	name = models[rpi_board_rev].name;
46414296	313	printf("RPI %s\n", name);
6fe7845a SW	314	}
6fe7845a SW	315
0d04f34a SW	316	int board_init(void)
0d04f34a SW	317	{
6fe7845a SW	318	get_board_rev();
6fe7845a SW	319
0d04f34a SW	320	gd->bd->bi_boot_params = 0x100;
0d04f34a SW	321
f66f2aa2	322	return power_on_module(BCM2835_MBOX_POWER_DEVID_USB_HCD);
0d04f34a	323	}
131a1e60	324
5dfd162e	325	int board_mmc_init(bd_t *bis)
131a1e60	326	{
927753ae	327	ALLOC_CACHE_ALIGN_BUFFER(struct msg_get_clock_rate, msg_clk, 1);
131a1e60 SW	328	int ret;
131a1e60 SW	329
f66f2aa2 SW	330	power_on_module(BCM2835_MBOX_POWER_DEVID_SDHCI);
f66f2aa2 SW	331
131a1e60 SW	332	BCM2835_MBOX_INIT_HDR(msg_clk);
	333	BCM2835_MBOX_INIT_TAG(&msg_clk->get_clock_rate, GET_CLOCK_RATE);
	334	msg_clk->get_clock_rate.body.req.clock_id = BCM2835_MBOX_CLOCK_ID_EMMC;
	335
	336	ret = bcm2835_mbox_call_prop(BCM2835_MBOX_PROP_CHAN, &msg_clk->hdr);
	337	if (ret) {
	338	printf("bcm2835: Could not query eMMC clock rate\n");
	339	return -1;
	340	}
	341
	342	return bcm2835_sdhci_init(BCM2835_SDHCI_BASE,
	343	msg_clk->get_clock_rate.body.resp.rate_hz);
	344	}
ea697ae7	345
e895a4b0	346	int ft_board_setup(void blob, bd_t bd)
ea697ae7 SW	347	{
	348	/*
	349	* For now, we simply always add the simplefb DT node. Later, we
	350	* should be more intelligent, and e.g. only do this if no enabled DT
	351	* node exists for the "real" graphics driver.
	352	*/
	353	lcd_dt_simplefb_add_node(blob);
e895a4b0 SG	354
e895a4b0 SG	355	return 0;
ea697ae7	356	}