[thirdparty/u-boot.git] / arch / arm / mach-bcm283x / mbox.c

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

#include <common.h>
#include <cpu_func.h>
#include <log.h>
#include <asm/cache.h>
#include <asm/io.h>
#include <asm/arch/base.h>
#include <asm/arch/mbox.h>
#include <phys2bus.h>

#define TIMEOUT 1000 /* ms */

int bcm2835_mbox_call_raw(u32 chan, u32 send, u32 *recv)
{
	struct bcm2835_mbox_regs *regs =
		(struct bcm2835_mbox_regs *)BCM2835_MBOX_PHYSADDR;
	ulong endtime = get_timer(0) + TIMEOUT;
	u32 val;

	debug("time: %lu timeout: %lu\n", get_timer(0), endtime);

	if (send & BCM2835_CHAN_MASK) {
		printf("mbox: Illegal mbox data 0x%08x\n", send);
		return -1;
	}

	/* Drain any stale responses */

	for (;;) {
		val = readl(&regs->mail0_status);
		if (val & BCM2835_MBOX_STATUS_RD_EMPTY)
			break;
		if (get_timer(0) >= endtime) {
			printf("mbox: Timeout draining stale responses\n");
			return -1;
		}
		val = readl(&regs->read);
	}

	/* Wait for space to send */

	for (;;) {
		val = readl(&regs->mail1_status);
		if (!(val & BCM2835_MBOX_STATUS_WR_FULL))
			break;
		if (get_timer(0) >= endtime) {
			printf("mbox: Timeout waiting for send space\n");
			return -1;
		}
	}

	/* Send the request */

	val = BCM2835_MBOX_PACK(chan, send);
	debug("mbox: TX raw: 0x%08x\n", val);
	writel(val, &regs->write);

	/* Wait for the response */

	for (;;) {
		val = readl(&regs->mail0_status);
		if (!(val & BCM2835_MBOX_STATUS_RD_EMPTY))
			break;
		if (get_timer(0) >= endtime) {
			printf("mbox: Timeout waiting for response\n");
			return -1;
		}
	}

	/* Read the response */

	val = readl(&regs->read);
	debug("mbox: RX raw: 0x%08x\n", val);

	/* Validate the response */

	if (BCM2835_MBOX_UNPACK_CHAN(val) != chan) {
		printf("mbox: Response channel mismatch\n");
		return -1;
	}

	*recv = BCM2835_MBOX_UNPACK_DATA(val);

	return 0;
}

#ifdef DEBUG
void dump_buf(struct bcm2835_mbox_hdr *buffer)
{
	u32 *p;
	u32 words;
	int i;

	p = (u32 *)buffer;
	words = buffer->buf_size / 4;
	for (i = 0; i < words; i++)
		printf("    0x%04x: 0x%08x\n", i * 4, p[i]);
}
#endif

int bcm2835_mbox_call_prop(u32 chan, struct bcm2835_mbox_hdr *buffer)
{
	int ret;
	u32 rbuffer;
	struct bcm2835_mbox_tag_hdr *tag;
	int tag_index;

#ifdef DEBUG
	printf("mbox: TX buffer\n");
	dump_buf(buffer);
#endif

	flush_dcache_range((unsigned long)buffer,
			   (unsigned long)((void *)buffer +
			   roundup(buffer->buf_size, ARCH_DMA_MINALIGN)));

	ret = bcm2835_mbox_call_raw(chan,
				    phys_to_bus((unsigned long)buffer),
				    &rbuffer);
	if (ret)
		return ret;

	invalidate_dcache_range((unsigned long)buffer,
				(unsigned long)((void *)buffer +
				roundup(buffer->buf_size, ARCH_DMA_MINALIGN)));

	if (rbuffer != phys_to_bus((unsigned long)buffer)) {
		printf("mbox: Response buffer mismatch\n");
		return -1;
	}

#ifdef DEBUG
	printf("mbox: RX buffer\n");
	dump_buf(buffer);
#endif

	/* Validate overall response status */

	if (buffer->code != BCM2835_MBOX_RESP_CODE_SUCCESS) {
		printf("mbox: Header response code invalid\n");
		return -1;
	}

	/* Validate each tag's response status */

	tag = (void *)(buffer + 1);
	tag_index = 0;
	while (tag->tag) {
		if (!(tag->val_len & BCM2835_MBOX_TAG_VAL_LEN_RESPONSE)) {
			printf("mbox: Tag %d missing val_len response bit\n",
				tag_index);
			return -1;
		}
		/*
		 * Clear the reponse bit so clients can just look right at the
		 * length field without extra processing
		 */
		tag->val_len &= ~BCM2835_MBOX_TAG_VAL_LEN_RESPONSE;
		tag = (void *)(((u8 *)tag) + sizeof(*tag) + tag->val_buf_size);
		tag_index++;
	}

	return 0;
}
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
88077280 SW	2	/*
88077280 SW	3	* (C) Copyright 2012 Stephen Warren
88077280 SW	4	*/
88077280 SW	5
d678a59d	6	#include <common.h>
1eb69ae4	7	#include <cpu_func.h>
f7ae49fc	8	#include <log.h>
90526e9f	9	#include <asm/cache.h>
88077280	10	#include <asm/io.h>
8e3361c8	11	#include <asm/arch/base.h>
88077280	12	#include <asm/arch/mbox.h>
122426d4	13	#include <phys2bus.h>
88077280	14
004c1059	15	#define TIMEOUT 1000 /* ms */
88077280 SW	16
	17	int bcm2835_mbox_call_raw(u32 chan, u32 send, u32 *recv)
	18	{
	19	struct bcm2835_mbox_regs *regs =
	20	(struct bcm2835_mbox_regs *)BCM2835_MBOX_PHYSADDR;
	21	ulong endtime = get_timer(0) + TIMEOUT;
	22	u32 val;
	23
	24	debug("time: %lu timeout: %lu\n", get_timer(0), endtime);
	25
	26	if (send & BCM2835_CHAN_MASK) {
	27	printf("mbox: Illegal mbox data 0x%08x\n", send);
	28	return -1;
	29	}
	30
	31	/* Drain any stale responses */
	32
	33	for (;;) {
49822442	34	val = readl(&regs->mail0_status);
88077280 SW	35	if (val & BCM2835_MBOX_STATUS_RD_EMPTY)
	36	break;
	37	if (get_timer(0) >= endtime) {
	38	printf("mbox: Timeout draining stale responses\n");
	39	return -1;
	40	}
	41	val = readl(&regs->read);
	42	}
	43
	44	/* Wait for space to send */
	45
	46	for (;;) {
49822442	47	val = readl(&regs->mail1_status);
88077280 SW	48	if (!(val & BCM2835_MBOX_STATUS_WR_FULL))
	49	break;
	50	if (get_timer(0) >= endtime) {
	51	printf("mbox: Timeout waiting for send space\n");
	52	return -1;
	53	}
	54	}
	55
	56	/* Send the request */
	57
	58	val = BCM2835_MBOX_PACK(chan, send);
	59	debug("mbox: TX raw: 0x%08x\n", val);
	60	writel(val, &regs->write);
	61
	62	/* Wait for the response */
	63
	64	for (;;) {
49822442	65	val = readl(&regs->mail0_status);
88077280 SW	66	if (!(val & BCM2835_MBOX_STATUS_RD_EMPTY))
	67	break;
	68	if (get_timer(0) >= endtime) {
	69	printf("mbox: Timeout waiting for response\n");
	70	return -1;
	71	}
	72	}
	73
	74	/* Read the response */
	75
	76	val = readl(&regs->read);
	77	debug("mbox: RX raw: 0x%08x\n", val);
	78
	79	/* Validate the response */
	80
	81	if (BCM2835_MBOX_UNPACK_CHAN(val) != chan) {
	82	printf("mbox: Response channel mismatch\n");
	83	return -1;
	84	}
	85
	86	*recv = BCM2835_MBOX_UNPACK_DATA(val);
	87
	88	return 0;
	89	}
	90
	91	#ifdef DEBUG
	92	void dump_buf(struct bcm2835_mbox_hdr *buffer)
	93	{
	94	u32 *p;
	95	u32 words;
	96	int i;
	97
	98	p = (u32 *)buffer;
	99	words = buffer->buf_size / 4;
	100	for (i = 0; i < words; i++)
	101	printf(" 0x%04x: 0x%08x\n", i * 4, p[i]);
	102	}
	103	#endif
	104
	105	int bcm2835_mbox_call_prop(u32 chan, struct bcm2835_mbox_hdr *buffer)
	106	{
	107	int ret;
	108	u32 rbuffer;
	109	struct bcm2835_mbox_tag_hdr *tag;
	110	int tag_index;
	111
	112	#ifdef DEBUG
	113	printf("mbox: TX buffer\n");
	114	dump_buf(buffer);
	115	#endif
	116
4342557f AS	117	flush_dcache_range((unsigned long)buffer,
	118	(unsigned long)((void *)buffer +
	119	roundup(buffer->buf_size, ARCH_DMA_MINALIGN)));
	120
2b513158 SW	121	ret = bcm2835_mbox_call_raw(chan,
	122	phys_to_bus((unsigned long)buffer),
	123	&rbuffer);
88077280 SW	124	if (ret)
88077280 SW	125	return ret;
4342557f AS	126
	127	invalidate_dcache_range((unsigned long)buffer,
	128	(unsigned long)((void *)buffer +
	129	roundup(buffer->buf_size, ARCH_DMA_MINALIGN)));
	130
2b513158	131	if (rbuffer != phys_to_bus((unsigned long)buffer)) {
88077280 SW	132	printf("mbox: Response buffer mismatch\n");
	133	return -1;
	134	}
	135
	136	#ifdef DEBUG
	137	printf("mbox: RX buffer\n");
	138	dump_buf(buffer);
	139	#endif
	140
	141	/* Validate overall response status */
	142
	143	if (buffer->code != BCM2835_MBOX_RESP_CODE_SUCCESS) {
	144	printf("mbox: Header response code invalid\n");
	145	return -1;
	146	}
	147
	148	/* Validate each tag's response status */
	149
	150	tag = (void *)(buffer + 1);
	151	tag_index = 0;
	152	while (tag->tag) {
	153	if (!(tag->val_len & BCM2835_MBOX_TAG_VAL_LEN_RESPONSE)) {
	154	printf("mbox: Tag %d missing val_len response bit\n",
	155	tag_index);
	156	return -1;
	157	}
	158	/*
	159	* Clear the reponse bit so clients can just look right at the
	160	* length field without extra processing
	161	*/
	162	tag->val_len &= ~BCM2835_MBOX_TAG_VAL_LEN_RESPONSE;
	163	tag = (void )(((u8 )tag) + sizeof(*tag) + tag->val_buf_size);
	164	tag_index++;
	165	}
	166
	167	return 0;
	168	}