 @@ -1,583 +1,585 @@
 /**
  * Copyright (c) 2010-2012 Broadcom. All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions, and the following disclaimer,
  *    without modification.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The names of the above-listed copyright holders may not be used
  *    to endorse or promote products derived from this software without
  *    specific prior written permission.
+ *
  * ALTERNATIVELY, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") version 2, as published by the Free
  * Software Foundation.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <interface/compat/vchi_bsd.h>
 #include <sys/param.h>
 #include <sys/malloc.h>
 #include <sys/bus.h>
 #include <sys/kmem.h>
 #include <linux/completion.h>
 #include <uvm/uvm_extern.h>
 #include <arm/cpufunc.h>
 #include <arch/arm/broadcom/bcm2835_mbox.h>
 #include <arch/arm/broadcom/bcm2835var.h>
 #define TOTAL_SLOTS (VCHIQ_SLOT_ZERO_SLOTS + 2 * 32)
 #define VCHIQ_DOORBELL_IRQ IRQ_ARM_DOORBELL_0
 #define IS_USER_ADDRESS(va)	\
 	((vaddr_t)(va) >= VM_MIN_ADDRESS && (vaddr_t)(va) < VM_MAX_ADDRESS)
 #include "vchiq_arm.h"
 #include "vchiq_2835.h"
 #include "vchiq_netbsd.h"
 #include "vchiq_connected.h"
 #define VCPAGE_OFFSET 0x0fff
 #define VCPAGE_SHIFT  12
 #define MAX_FRAGMENTS (VCHIQ_NUM_CURRENT_BULKS * 2)
 typedef struct vchiq_2835_state_struct {
    int inited;
    VCHIQ_ARM_STATE_T arm_state;
 } VCHIQ_2835_ARM_STATE_T;
 /* BSD DMA */
 static bus_dma_tag_t dma_tag;
 static bus_dmamap_t dma_map;
 static unsigned int g_cache_line_size = CACHE_LINE_SIZE;
 static unsigned int g_fragments_size;
 static char *g_fragments_base;
 static char *g_free_fragments;
 struct semaphore g_free_fragments_sema;
 static struct semaphore g_free_fragments_mutex;
 void
 vchiq_platform_attach(bus_dma_tag_t tag)
+{
 	dma_tag = tag;
+}
 int __init
 vchiq_platform_init(VCHIQ_STATE_T *state)
+{
 	VCHIQ_SLOT_ZERO_T *vchiq_slot_zero;
 	bus_dma_segment_t dma_segs[1];
 	int dma_nsegs;
 	void *slot_mem;
 	bus_addr_t slot_phys;
 	int slot_mem_size, frag_mem_size;
 	int err;
 	int i;
 	_sema_init(&g_free_fragments_mutex, 1);
 	g_cache_line_size = 32;
 	g_fragments_size = 2 * g_cache_line_size;
 	/* Allocate space for the channels in coherent memory */
 	slot_mem_size = PAGE_ALIGN(TOTAL_SLOTS * VCHIQ_SLOT_SIZE);
 	frag_mem_size = PAGE_ALIGN(g_fragments_size * MAX_FRAGMENTS);
 	dma_nsegs = __arraycount(dma_segs);
 	err = bus_dmamem_alloc(dma_tag,
 	    slot_mem_size + frag_mem_size, PAGE_SIZE, 0,
 	    dma_segs, dma_nsegs, &dma_nsegs, BUS_DMA_WAITOK);
 	if (err) {
 		vchiq_log_error(vchiq_core_log_level, "Unable to allocate channel memory");
 		err = -ENOMEM;
 		goto failed_alloc;
+	}
 	err = bus_dmamem_map(dma_tag,
 	    dma_segs, dma_nsegs, slot_mem_size + frag_mem_size,
 	    (void **)&slot_mem, BUS_DMA_COHERENT | BUS_DMA_WAITOK);
 	if (err) {
 		vchiq_log_error(vchiq_core_log_level, "Unable to map channel memory");
 		err = -ENOMEM;
 		goto failed_alloc;
+	}
 	err = bus_dmamap_create(dma_tag,
 	    slot_mem_size + frag_mem_size, 1,	/* maxsize, nsegments */
 	    slot_mem_size + frag_mem_size, 0,	/* maxsegsize, boundary */
 	    BUS_DMA_WAITOK,
 	    &dma_map);
 	if (err) {
 		vchiq_log_error(vchiq_core_log_level, "Unable to create DMA map");
 		err = -ENOMEM;
 		goto failed_alloc;
+	}
 	err = bus_dmamap_load(dma_tag, dma_map, slot_mem,
 	    slot_mem_size + frag_mem_size, NULL, BUS_DMA_WAITOK);
 	if (err) {
 		vchiq_log_error(vchiq_core_log_level, "cannot load DMA map (%d)", err);
 		err = -ENOMEM;
 		goto failed_load;
+	}
 	slot_phys = dma_map->dm_segs[0].ds_addr;
 	vchiq_log_info(vchiq_arm_log_level,
 	    "%s: slot_phys = %lx\n", __func__, slot_phys);
 	WARN_ON(((uintptr_t)slot_mem & (PAGE_SIZE - 1)) != 0);
 	vchiq_slot_zero = vchiq_init_slots(slot_mem, slot_mem_size);
 	if (!vchiq_slot_zero) {
 		err = -EINVAL;
 		goto failed_init_slots;
+	}
 	vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX] =
 		(int)slot_phys + slot_mem_size;
 	vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_COUNT_IDX] =
 		MAX_FRAGMENTS;
 	g_fragments_base = (char *)slot_mem + slot_mem_size;
 	slot_mem_size += frag_mem_size;
 	g_free_fragments = g_fragments_base;
 	for (i = 0; i < (MAX_FRAGMENTS - 1); i++) {
 		*(char **)&g_fragments_base[i*g_fragments_size] =
 			&g_fragments_base[(i + 1)*g_fragments_size];
+	}
 	*(char **)&g_fragments_base[i * g_fragments_size] = NULL;
 	_sema_init(&g_free_fragments_sema, MAX_FRAGMENTS);
 	if (vchiq_init_state(state, vchiq_slot_zero, 0/*slave*/) !=
 		VCHIQ_SUCCESS) {
 		err = -EINVAL;
 		goto failed_vchiq_init;
+	}
 	/* Send the base address of the slots to VideoCore */
 	dsb(sy); /* Ensure all writes have completed */
 	bus_dmamap_sync(dma_tag, dma_map, 0, slot_mem_size,
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	bcm_mbox_write(BCM2835_MBOX_CHAN_VCHIQ, (unsigned int)slot_phys);
 	bus_dmamap_sync(dma_tag, dma_map, 0, slot_mem_size,
 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 	vchiq_log_info(vchiq_arm_log_level,
 		"vchiq_init - done (slots %p, phys %x)",
 		vchiq_slot_zero, (unsigned int)slot_phys);
 	vchiq_call_connected_callbacks();
 	return 0;
 failed_vchiq_init:
 failed_init_slots:
 failed_load:
 	bus_dmamap_unload(dma_tag, dma_map);
 failed_alloc:
 	bus_dmamap_destroy(dma_tag, dma_map);
    return err;
+}
 void __exit
 vchiq_platform_exit(VCHIQ_STATE_T *state)
+{
 	bus_dmamap_unload(dma_tag, dma_map);
 	bus_dmamap_destroy(dma_tag, dma_map);
+}
 VCHIQ_STATUS_T
 vchiq_platform_init_state(VCHIQ_STATE_T *state)
+{
    VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
    state->platform_state = kzalloc(sizeof(VCHIQ_2835_ARM_STATE_T), GFP_KERNEL);
    ((VCHIQ_2835_ARM_STATE_T*)state->platform_state)->inited = 1;
    status = vchiq_arm_init_state(state, &((VCHIQ_2835_ARM_STATE_T*)state->platform_state)->arm_state);
    if(status != VCHIQ_SUCCESS)
+   {
       ((VCHIQ_2835_ARM_STATE_T*)state->platform_state)->inited = 0;
+   }
    return status;
+}
 VCHIQ_ARM_STATE_T*
 vchiq_platform_get_arm_state(VCHIQ_STATE_T *state)
+{
    if(!((VCHIQ_2835_ARM_STATE_T*)state->platform_state)->inited)
+   {
       BUG();
+   }
    return &((VCHIQ_2835_ARM_STATE_T*)state->platform_state)->arm_state;
+}
 int
 vchiq_copy_from_user(void *dst, const void *src, int size)
+{
 	vaddr_t va = (vaddr_t)src;
 	if (IS_USER_ADDRESS(va)) {
 		int error = copyin(src, dst, size);
 		return error ? VCHIQ_ERROR : VCHIQ_SUCCESS;
 	} else {
 		kcopy(src, dst, size);
 		return VCHIQ_SUCCESS;
+	}
+}
 typedef struct bulkinfo_struct {
 	void		*pagelist;
 	bus_dma_segment_t pagelist_sgs[1];
 	bus_size_t	pagelist_size;
 	bus_dmamap_t	pagelist_map;
 	bus_dmamap_t	dmamap;
 	struct proc	*proc;
 	void		*buf;
 	int		size;
 } BULKINFO_T;
 /* There is a potential problem with partial cache lines (pages?)
 ** at the ends of the block when reading. If the CPU accessed anything in
 ** the same line (page?) then it may have pulled old data into the cache,
 ** obscuring the new data underneath. We can solve this by transferring the
 ** partial cache lines separately, and allowing the ARM to copy into the
 ** cached area.
 */
 VCHIQ_STATUS_T
 vchiq_prepare_bulk_data(VCHIQ_BULK_T *bulk, VCHI_MEM_HANDLE_T memhandle,
 	void *buf, int size, int dir)
+{
 	PAGELIST_T *pagelist;
 	BULKINFO_T *bi;
 	int nsegs;
 	int ret;
 	vchiq_log_info(vchiq_arm_log_level,
 	    "%s: buf %p size %08x dir %s", __func__, buf, size,
 	    dir == VCHIQ_BULK_RECEIVE ? "read" : "write");
 	vaddr_t va = (vaddr_t)buf;
 	const size_t maxsegs = atop(round_page(va + size) - trunc_page(va));
  	const int uvmflags = (dir == VCHIQ_BULK_RECEIVE ?
 	    VM_PROT_READ : VM_PROT_WRITE);
 	const int dmaflags = (dir == VCHIQ_BULK_RECEIVE ?
 	    BUS_DMA_READ : BUS_DMA_WRITE);
 	WARN_ON(memhandle != VCHI_MEM_HANDLE_INVALID);
 	bi = kmem_alloc(sizeof(*bi), KM_SLEEP);
 	bi->buf = buf;
 	bi->size = size;
 	bi->pagelist_size = sizeof(PAGELIST_T) +
 	    (maxsegs * sizeof(unsigned long));
 	bi->proc = curproc;
 	ret = bus_dmamem_alloc(dma_tag, bi->pagelist_size,
 /*CACHE_LINE_SIZE*/, 0, bi->pagelist_sgs,
 	    __arraycount(bi->pagelist_sgs), &nsegs, BUS_DMA_WAITOK);
 	if (ret != 0)
 		goto fail1;
 	ret = bus_dmamem_map(dma_tag, bi->pagelist_sgs, nsegs,
 	    bi->pagelist_size, &bi->pagelist, BUS_DMA_COHERENT | BUS_DMA_WAITOK);
 	if (ret != 0)
 		goto fail2;
 	pagelist = bi->pagelist;
 	ret = bus_dmamap_create(dma_tag, bi->pagelist_size,
 	    nsegs, bi->pagelist_size, 0, BUS_DMA_WAITOK, &bi->pagelist_map);
 	if (ret != 0)
 		goto fail3;
 	ret = bus_dmamap_load(dma_tag, bi->pagelist_map, pagelist,
 	    bi->pagelist_size, NULL, BUS_DMA_WAITOK | BUS_DMA_WRITE);
 	if (ret != 0)
 		goto fail4;
 	/*
 	 * Need to wire the buffer pages in.
 	 */
 	if (IS_USER_ADDRESS(buf)) {
 		ret = uvm_vslock(bi->proc->p_vmspace, buf, size, uvmflags);
 		if (ret != 0) {
 			printf("%s: uvm_vslock failed (%d)\n", __func__, ret);
 			goto fail5;
+		}
+	}
 	ret = bus_dmamap_create(dma_tag, size, maxsegs, size, 0,
 	    BUS_DMA_WAITOK, &bi->dmamap);
 	if (ret != 0)
 		goto fail6;
 	ret = bus_dmamap_load(dma_tag, bi->dmamap, buf, size,
 	    curproc, BUS_DMA_WAITOK | dmaflags);
 	if (ret != 0)
 		goto fail7;
 	bulk->handle = memhandle;
 	/*
 	 * We've now got the bus_addr_t for the pagelist we want the transfer
 	 * to use.
 	 */
 	bulk->data = (void *)bi->pagelist_map->dm_segs[0].ds_addr;
 	pagelist->type = (dir == VCHIQ_BULK_RECEIVE) ?
 	    PAGELIST_READ : PAGELIST_WRITE;
 	pagelist->length = size;
 	pagelist->offset = va & VCPAGE_OFFSET;
 	/*
 	 * busdma already coalesces contiguous pages for us
 	 */
 	for (int i = 0; i < bi->dmamap->dm_nsegs; i++) {
 		bus_addr_t addr = bi->dmamap->dm_segs[i].ds_addr;
 		bus_size_t len = bi->dmamap->dm_segs[i].ds_len;
 		bus_size_t off = addr & VCPAGE_OFFSET;
 		int npgs = ((off + len + VCPAGE_OFFSET) >> VCPAGE_SHIFT);
 		pagelist->addrs[i] = addr & ~VCPAGE_OFFSET;
 		pagelist->addrs[i] |= npgs - 1;
+	}
 	/* Partial cache lines (fragments) require special measures */
 	if ((pagelist->type == PAGELIST_READ) &&
 	    ((pagelist->offset & (g_cache_line_size - 1)) ||
 	    ((pagelist->offset + pagelist->length) & (g_cache_line_size - 1)))) {
 		char *fragments;
 		if (down_interruptible(&g_free_fragments_sema) != 0) {
 			goto fail7;
+		}
 		WARN_ON(g_free_fragments == NULL);
 		down(&g_free_fragments_mutex);
 		fragments = g_free_fragments;
 		WARN_ON(fragments == NULL);
 		g_free_fragments = *(char **) g_free_fragments;
 		up(&g_free_fragments_mutex);
 		pagelist->type = PAGELIST_READ_WITH_FRAGMENTS +
 		    (fragments - g_fragments_base) / g_fragments_size;
 		bus_dmamap_sync(dma_tag, dma_map,
 		    (char *)fragments - g_fragments_base, sizeof(*fragments),
 		    BUS_DMASYNC_PREREAD);
+	}
 	/*
 	 * Store the BULKINFO_T address in remote_data, which isn't used by the
 	 * slave.
 	 */
 	bulk->remote_data = bi;
 	bus_dmamap_sync(dma_tag, bi->pagelist_map, 0,
 	    bi->pagelist_size, BUS_DMASYNC_PREWRITE);
 	bus_dmamap_sync(dma_tag, bi->dmamap, 0, bi->size,
 	    pagelist->type == PAGELIST_WRITE ?
 	    BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
 	return VCHIQ_SUCCESS;
 fail7:
 	bus_dmamap_destroy(dma_tag, bi->dmamap);
 fail6:
 	if (IS_USER_ADDRESS(bi->buf))
 		uvm_vsunlock(curproc->p_vmspace, bi->buf, bi->size);
 fail5:
 	bus_dmamap_unload(dma_tag, bi->pagelist_map);
 fail4:
 	bus_dmamap_destroy(dma_tag, bi->pagelist_map);
 fail3:
 	bus_dmamem_unmap(dma_tag, bi->pagelist, bi->pagelist_size);
 fail2:
 	bus_dmamem_free(dma_tag, bi->pagelist_sgs,
 	    __arraycount(bi->pagelist_sgs));
 fail1:
 	kmem_free(bi, sizeof(*bi));
 	return VCHIQ_ERROR;
+}
 void
 vchiq_complete_bulk(VCHIQ_BULK_T *bulk)
+{
 	if (bulk && bulk->remote_data && bulk->actual) {
 		int actual = bulk->actual;
 		BULKINFO_T *bi = bulk->remote_data;
 		PAGELIST_T *pagelist = bi->pagelist;
 		vchiq_log_trace(vchiq_arm_log_level,
 			"free_pagelist - %p, %d", pagelist, actual);
 		bus_dmamap_sync(dma_tag, bi->pagelist_map, 0,
 		    bi->pagelist_size, BUS_DMASYNC_POSTWRITE);
 		bus_dmamap_sync(dma_tag, bi->dmamap, 0, bi->size,
 		    pagelist->type == PAGELIST_WRITE ?
 		    BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD);
 		/* Deal with any partial cache lines (fragments) */
 		if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS) {
 			char *fragments = g_fragments_base +
 			    (pagelist->type - PAGELIST_READ_WITH_FRAGMENTS) *
 			    g_fragments_size;
 			int head_bytes, tail_bytes;
 			bus_dmamap_sync(dma_tag, dma_map,
 			    (char *)fragments - g_fragments_base, g_fragments_size,
 			    BUS_DMASYNC_POSTREAD);
 			head_bytes = (g_cache_line_size - pagelist->offset) &
 				(g_cache_line_size - 1);
 			tail_bytes = (pagelist->offset + actual) &
 				(g_cache_line_size - 1);
 			if ((actual >= 0) && (head_bytes != 0)) {
 				if (head_bytes > actual)
 					head_bytes = actual;
 				if (IS_USER_ADDRESS(bi->buf)) {
 					copyout_proc(bi->proc, fragments,
 					    bi->buf, head_bytes);
 				} else {
 					kcopy(fragments, bi->buf, head_bytes);
+				}
+			}
 			if ((actual >= 0) && (head_bytes < actual) &&
 			    (tail_bytes != 0)) {
 				void *t = (char *)bi->buf + bi->size -
 				    tail_bytes;
 				 if (IS_USER_ADDRESS(bi->buf)) {
 					copyout_proc(bi->proc,
 					    fragments + g_cache_line_size, t,
 					    tail_bytes);
 				} else {
 					kcopy(fragments + g_cache_line_size, t,
 					    tail_bytes);
+				}
+			}
 			down(&g_free_fragments_mutex);
 			*(char **)fragments = g_free_fragments;
 			g_free_fragments = fragments;
 			up(&g_free_fragments_mutex);
 			up(&g_free_fragments_sema);
+		}
 		bus_dmamap_unload(dma_tag, bi->dmamap);
 		bus_dmamap_destroy(dma_tag, bi->dmamap);
 		if (IS_USER_ADDRESS(bi->buf))
 			uvm_vsunlock(bi->proc->p_vmspace, bi->buf, bi->size);
 		bus_dmamap_unload(dma_tag, bi->pagelist_map);
 		bus_dmamap_destroy(dma_tag, bi->pagelist_map);
 		bus_dmamem_unmap(dma_tag, bi->pagelist,
 		    bi->pagelist_size);
 		bus_dmamem_free(dma_tag, bi->pagelist_sgs,
 		    __arraycount(bi->pagelist_sgs));
 		kmem_free(bi, sizeof(*bi));
+	}
+}
 void
 vchiq_transfer_bulk(VCHIQ_BULK_T *bulk)
+{
 	/*
 	 * This should only be called on the master (VideoCore) side, but
 	 * provide an implementation to avoid the need for ifdefery.
 	 */
 	BUG();
+}
 void
 vchiq_dump_platform_state(void *dump_context)
+{
 	char buf[80];
 	int len;
 	len = snprintf(buf, sizeof(buf),
 		"  Platform: 2835 (VC master)");
 	vchiq_dump(dump_context, buf, len + 1);
+}
 VCHIQ_STATUS_T
 vchiq_platform_suspend(VCHIQ_STATE_T *state)
+{
    return VCHIQ_ERROR;
+}
 VCHIQ_STATUS_T
 vchiq_platform_resume(VCHIQ_STATE_T *state)
+{
    return VCHIQ_SUCCESS;
+}
 void
 vchiq_platform_paused(VCHIQ_STATE_T *state)
+{
+}
 void
 vchiq_platform_resumed(VCHIQ_STATE_T *state)
+{
+}
 int
 vchiq_platform_videocore_wanted(VCHIQ_STATE_T* state)
+{
    return 1; // autosuspend not supported - videocore always wanted
+}
 int
 vchiq_platform_use_suspend_timer(void)
+{
    return 0;
+}
 void
 vchiq_dump_platform_use_state(VCHIQ_STATE_T *state)
+{
 	vchiq_log_info(vchiq_arm_log_level, "Suspend timer not in use");
+}
 void
 vchiq_platform_handle_timeout(VCHIQ_STATE_T *state)
+{
 	(void)state;
+}

 @@ -1,717 +1,719 @@
 /**
  * Copyright (c) 2010-2012 Broadcom. All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions, and the following disclaimer,
  *    without modification.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The names of the above-listed copyright holders may not be used
  *    to endorse or promote products derived from this software without
  *    specific prior written permission.
+ *
  * ALTERNATIVELY, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") version 2, as published by the Free
  * Software Foundation.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef VCHIQ_CORE_H
 #define VCHIQ_CORE_H
 #include <interface/compat/vchi_bsd.h>
 #include <linux/list.h>
 #include <arm/cpufunc.h>
 #include "vchiq_cfg.h"
 #include "vchiq.h"
 /* Run time control of log level, based on KERN_XXX level. */
 #ifndef VCHIQ_LOG_DEFAULT
 #define VCHIQ_LOG_DEFAULT  7
 #endif
 #define VCHIQ_LOG_ERROR    3
 #define VCHIQ_LOG_WARNING  4
 #define VCHIQ_LOG_INFO     6
 #define VCHIQ_LOG_TRACE    7
 #define VCHIQ_LOG_PREFIX   "vchiq: "
 #ifndef vchiq_log_error
 #define vchiq_log_error(cat, fmt, ...) \
 	do { if (cat >= VCHIQ_LOG_ERROR) \
 		printf_tolog(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0)
 #endif
 #ifndef vchiq_log_warning
 #define vchiq_log_warning(cat, fmt, ...) \
 	do { if (cat >= VCHIQ_LOG_WARNING) \
 		 printf_tolog(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0)
 #endif
 #ifndef vchiq_log_info
 #define vchiq_log_info(cat, fmt, ...) \
 	do { if (cat >= VCHIQ_LOG_INFO) \
 		printf_tolog(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0)
 #endif
 #ifndef vchiq_log_trace
 #define vchiq_log_trace(cat, fmt, ...) \
 	do { if (cat >= VCHIQ_LOG_TRACE) \
 		printf_tolog(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0)
 #endif
 #define vchiq_loud_error(...) \
 	vchiq_log_error(vchiq_core_log_level, "===== " __VA_ARGS__)
 #ifndef vchiq_static_assert
 #define vchiq_static_assert(cond) __attribute__((unused)) \
 	extern int vchiq_static_assert[(cond) ? 1 : -1]
 #endif
 #define IS_POW2(x) (x && ((x & (x - 1)) == 0))
 /* Ensure that the slot size and maximum number of slots are powers of 2 */
 vchiq_static_assert(IS_POW2(VCHIQ_SLOT_SIZE));
 vchiq_static_assert(IS_POW2(VCHIQ_MAX_SLOTS));
 vchiq_static_assert(IS_POW2(VCHIQ_MAX_SLOTS_PER_SIDE));
 #define VCHIQ_SLOT_MASK        (VCHIQ_SLOT_SIZE - 1)
 #define VCHIQ_SLOT_QUEUE_MASK  (VCHIQ_MAX_SLOTS_PER_SIDE - 1)
 #define VCHIQ_SLOT_ZERO_SLOTS  ((sizeof(VCHIQ_SLOT_ZERO_T) + \
 	VCHIQ_SLOT_SIZE - 1) / VCHIQ_SLOT_SIZE)
 #define VCHIQ_MSG_PADDING            0  /* -                                 */
 #define VCHIQ_MSG_CONNECT            1  /* -                                 */
 #define VCHIQ_MSG_OPEN               2  /* + (srcport, -), fourcc, client_id */
 #define VCHIQ_MSG_OPENACK            3  /* + (srcport, dstport)              */
 #define VCHIQ_MSG_CLOSE              4  /* + (srcport, dstport)              */
 #define VCHIQ_MSG_DATA               5  /* + (srcport, dstport)              */
 #define VCHIQ_MSG_BULK_RX            6  /* + (srcport, dstport), data, size  */
 #define VCHIQ_MSG_BULK_TX            7  /* + (srcport, dstport), data, size  */
 #define VCHIQ_MSG_BULK_RX_DONE       8  /* + (srcport, dstport), actual      */
 #define VCHIQ_MSG_BULK_TX_DONE       9  /* + (srcport, dstport), actual      */
 #define VCHIQ_MSG_PAUSE             10  /* -                                 */
 #define VCHIQ_MSG_RESUME            11  /* -                                 */
 #define VCHIQ_MSG_REMOTE_USE        12  /* -                                 */
 #define VCHIQ_MSG_REMOTE_RELEASE    13  /* -                                 */
 #define VCHIQ_MSG_REMOTE_USE_ACTIVE 14  /* -                                 */
 #define VCHIQ_PORT_MAX                 (VCHIQ_MAX_SERVICES - 1)
 #define VCHIQ_PORT_FREE                0x1000
 #define VCHIQ_PORT_IS_VALID(port)      (port < VCHIQ_PORT_FREE)
 #define VCHIQ_MAKE_MSG(type, srcport, dstport) \
 	((type<<24) | (srcport<<12) | (dstport<<0))
 #define VCHIQ_MSG_TYPE(msgid)          ((unsigned int)msgid >> 24)
 #define VCHIQ_MSG_SRCPORT(msgid) \
 	(unsigned short)(((unsigned int)msgid >> 12) & 0xfff)
 #define VCHIQ_MSG_DSTPORT(msgid) \
 	((unsigned short)msgid & 0xfff)
 #define VCHIQ_FOURCC_AS_4CHARS(fourcc)	\
 	((fourcc) >> 24) & 0xff, \
 	((fourcc) >> 16) & 0xff, \
 	((fourcc) >>  8) & 0xff, \
 	(fourcc) & 0xff
 /* Ensure the fields are wide enough */
 vchiq_static_assert(VCHIQ_MSG_SRCPORT(VCHIQ_MAKE_MSG(0, 0, VCHIQ_PORT_MAX))
 	== 0);
 vchiq_static_assert(VCHIQ_MSG_TYPE(VCHIQ_MAKE_MSG(0, VCHIQ_PORT_MAX, 0)) == 0);
 vchiq_static_assert((unsigned int)VCHIQ_PORT_MAX <
 	(unsigned int)VCHIQ_PORT_FREE);
 #define VCHIQ_MSGID_PADDING            VCHIQ_MAKE_MSG(VCHIQ_MSG_PADDING, 0, 0)
 #define VCHIQ_MSGID_CLAIMED            0x40000000
 #define VCHIQ_FOURCC_INVALID           0x00000000
 #define VCHIQ_FOURCC_IS_LEGAL(fourcc)  (fourcc != VCHIQ_FOURCC_INVALID)
 #define VCHIQ_BULK_ACTUAL_ABORTED -1
 typedef uint32_t BITSET_T;
 vchiq_static_assert((sizeof(BITSET_T) * 8) == 32);
 #define BITSET_SIZE(b)        ((b + 31) >> 5)
 #define BITSET_WORD(b)        (b >> 5)
 #define BITSET_BIT(b)         (1 << (b & 31))
 #define BITSET_ZERO(bs)       memset(bs, 0, sizeof(bs))
 #define BITSET_IS_SET(bs, b)  (bs[BITSET_WORD(b)] & BITSET_BIT(b))
 #define BITSET_SET(bs, b)     (bs[BITSET_WORD(b)] |= BITSET_BIT(b))
 #define BITSET_CLR(bs, b)     (bs[BITSET_WORD(b)] &= ~BITSET_BIT(b))
 #if VCHIQ_ENABLE_STATS
 #define VCHIQ_STATS_INC(state, stat) (state->stats. stat++)
 #define VCHIQ_SERVICE_STATS_INC(service, stat) (service->stats. stat++)
 #define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) \
 	(service->stats. stat += addend)
 #else
 #define VCHIQ_STATS_INC(state, stat) ((void)0)
 #define VCHIQ_SERVICE_STATS_INC(service, stat) ((void)0)
 #define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) ((void)0)
 #endif
 enum {
 	DEBUG_ENTRIES,
 #if VCHIQ_ENABLE_DEBUG
 	DEBUG_SLOT_HANDLER_COUNT,
 	DEBUG_SLOT_HANDLER_LINE,
 	DEBUG_PARSE_LINE,
 	DEBUG_PARSE_HEADER,
 	DEBUG_PARSE_MSGID,
 	DEBUG_AWAIT_COMPLETION_LINE,
 	DEBUG_DEQUEUE_MESSAGE_LINE,
 	DEBUG_SERVICE_CALLBACK_LINE,
 	DEBUG_MSG_QUEUE_FULL_COUNT,
 	DEBUG_COMPLETION_QUEUE_FULL_COUNT,
 #endif
 	DEBUG_MAX
 };
 #if VCHIQ_ENABLE_DEBUG
 #define DEBUG_INITIALISE(local) int *debug_ptr = (local)->debug;
 #define DEBUG_TRACE(d) \
 	do { debug_ptr[DEBUG_ ## d] = __LINE__; dsb(sy); } while (0)
 #define DEBUG_VALUE(d, v) \
 	do { debug_ptr[DEBUG_ ## d] = (v); dsb(sy); } while (0)
 #define DEBUG_COUNT(d) \
 	do { debug_ptr[DEBUG_ ## d]++; dsb(sy); } while (0)
 #else /* VCHIQ_ENABLE_DEBUG */
 #define DEBUG_INITIALISE(local)
 #define DEBUG_TRACE(d)
 #define DEBUG_VALUE(d, v)
 #define DEBUG_COUNT(d)
 #endif /* VCHIQ_ENABLE_DEBUG */
 typedef enum {
 	VCHIQ_CONNSTATE_DISCONNECTED,
 	VCHIQ_CONNSTATE_CONNECTING,
 	VCHIQ_CONNSTATE_CONNECTED,
 	VCHIQ_CONNSTATE_PAUSING,
 	VCHIQ_CONNSTATE_PAUSE_SENT,
 	VCHIQ_CONNSTATE_PAUSED,
 	VCHIQ_CONNSTATE_RESUMING,
 	VCHIQ_CONNSTATE_PAUSE_TIMEOUT,
 	VCHIQ_CONNSTATE_RESUME_TIMEOUT
 } VCHIQ_CONNSTATE_T;
 enum {
 	VCHIQ_SRVSTATE_FREE,
 	VCHIQ_SRVSTATE_HIDDEN,
 	VCHIQ_SRVSTATE_LISTENING,
 	VCHIQ_SRVSTATE_OPENING,
 	VCHIQ_SRVSTATE_OPEN,
 	VCHIQ_SRVSTATE_OPENSYNC,
 	VCHIQ_SRVSTATE_CLOSESENT,
 	VCHIQ_SRVSTATE_CLOSERECVD,
 	VCHIQ_SRVSTATE_CLOSEWAIT,
 	VCHIQ_SRVSTATE_CLOSED
 };
 enum {
 	VCHIQ_POLL_TERMINATE,
 	VCHIQ_POLL_REMOVE,
 	VCHIQ_POLL_TXNOTIFY,
 	VCHIQ_POLL_RXNOTIFY,
 	VCHIQ_POLL_COUNT
 };
 typedef enum {
 	VCHIQ_BULK_TRANSMIT,
 	VCHIQ_BULK_RECEIVE
 } VCHIQ_BULK_DIR_T;
 typedef void (*VCHIQ_USERDATA_TERM_T)(void *userdata);
 typedef struct vchiq_bulk_struct {
 	short mode;
 	short dir;
 	void *userdata;
 	VCHI_MEM_HANDLE_T handle;
 	void *data;
 	int size;
 	void *remote_data;
 	int remote_size;
 	int actual;
 } VCHIQ_BULK_T;
 typedef struct vchiq_bulk_queue_struct {
 	int local_insert;  /* Where to insert the next local bulk */
 	int remote_insert; /* Where to insert the next remote bulk (master) */
 	int process;       /* Bulk to transfer next */
 	int remote_notify; /* Bulk to notify the remote client of next (mstr) */
 	int remove;        /* Bulk to notify the local client of, and remove,
 			   ** next */
 	VCHIQ_BULK_T bulks[VCHIQ_NUM_SERVICE_BULKS];
 } VCHIQ_BULK_QUEUE_T;
 typedef struct remote_event_struct {
 	int32_t armed;
 	int32_t fired;
 	uint32_t event; /* offset to VCHIQ_STATE_T */
 #define REMOTE_EVENT_SEMA(s,e) ((struct semaphore *)((char *)(s) + (e)->event))
 } REMOTE_EVENT_T;
 typedef struct opaque_platform_state_t *VCHIQ_PLATFORM_STATE_T;
 typedef struct vchiq_state_struct VCHIQ_STATE_T;
 typedef struct vchiq_slot_struct {
 	char data[VCHIQ_SLOT_SIZE];
 } VCHIQ_SLOT_T;
 typedef struct vchiq_slot_info_struct {
 	/* Use two counters rather than one to avoid the need for a mutex. */
 	int16_t use_count;
 	int16_t release_count;
 } VCHIQ_SLOT_INFO_T;
 typedef struct vchiq_service_struct {
 	VCHIQ_SERVICE_BASE_T base;
 	VCHIQ_SERVICE_HANDLE_T handle;
 	unsigned int ref_count;
 	int srvstate;
 	VCHIQ_USERDATA_TERM_T userdata_term;
 	unsigned int localport;
 	unsigned int remoteport;
 	int public_fourcc;
 	int client_id;
 	char auto_close;
 	char sync;
 	char closing;
 	char trace;
 	atomic_t poll_flags;
 	short version;
 	short version_min;
 	short peer_version;
 	VCHIQ_STATE_T *state;
 	VCHIQ_INSTANCE_T instance;
 	int service_use_count;
 	VCHIQ_BULK_QUEUE_T bulk_tx;
 	VCHIQ_BULK_QUEUE_T bulk_rx;
 	struct semaphore remove_event;
 	struct semaphore bulk_remove_event;
 	struct mutex bulk_mutex;
 	struct service_stats_struct {
 		int quota_stalls;
 		int slot_stalls;
 		int bulk_stalls;
 		int error_count;
 		int ctrl_tx_count;
 		int ctrl_rx_count;
 		int bulk_tx_count;
 		int bulk_rx_count;
 		int bulk_aborted_count;
 		uint64_t ctrl_tx_bytes;
 		uint64_t ctrl_rx_bytes;
 		uint64_t bulk_tx_bytes;
 		uint64_t bulk_rx_bytes;
 	} stats;
 } VCHIQ_SERVICE_T;
 /* The quota information is outside VCHIQ_SERVICE_T so that it can be
 	statically allocated, since for accounting reasons a service's slot
 	usage is carried over between users of the same port number.
  */
 typedef struct vchiq_service_quota_struct {
 	unsigned short slot_quota;
 	unsigned short slot_use_count;
 	unsigned short message_quota;
 	unsigned short message_use_count;
 	struct semaphore quota_event;
 	int previous_tx_index;
 } VCHIQ_SERVICE_QUOTA_T;
 typedef struct vchiq_shared_state_struct {
 	/* A non-zero value here indicates that the content is valid. */
 	int32_t initialised;
 	/* The first and last (inclusive) slots allocated to the owner. */
 	int32_t slot_first;
 	int32_t slot_last;
 	/* The slot allocated to synchronous messages from the owner. */
 	int32_t slot_sync;
 	/* Signalling this event indicates that owner's slot handler thread
 	** should run. */
 	REMOTE_EVENT_T trigger;
 	/* Indicates the byte position within the stream where the next message
 	** will be written. The least significant bits are an index into the
 	** slot. The next bits are the index of the slot in slot_queue. */
 	int32_t tx_pos;
 	/* This event should be signalled when a slot is recycled. */
 	REMOTE_EVENT_T recycle;
 	/* The slot_queue index where the next recycled slot will be written. */
 	int slot_queue_recycle;
 	/* This event should be signalled when a synchronous message is sent. */
 	REMOTE_EVENT_T sync_trigger;
 	/* This event should be signalled when a synchronous message has been
 	** released. */
 	REMOTE_EVENT_T sync_release;
 	/* A circular buffer of slot indexes. */
 	int32_t slot_queue[VCHIQ_MAX_SLOTS_PER_SIDE];
 	/* Debugging state */
 	int32_t debug[DEBUG_MAX];
 } VCHIQ_SHARED_STATE_T;
 typedef struct vchiq_slot_zero_struct {
 	int32_t magic;
 	int16_t version;
 	int16_t version_min;
 	int32_t slot_zero_size;
 	int32_t slot_size;
 	int32_t max_slots;
 	int32_t max_slots_per_side;
 	int32_t platform_data[2];
 	VCHIQ_SHARED_STATE_T master;
 	VCHIQ_SHARED_STATE_T slave;
 	VCHIQ_SLOT_INFO_T slots[VCHIQ_MAX_SLOTS];
 } VCHIQ_SLOT_ZERO_T;
 struct vchiq_state_struct {
 	int id;
 	int initialised;
 	VCHIQ_CONNSTATE_T conn_state;
 	int is_master;
 	short version_common;
 	VCHIQ_SHARED_STATE_T *local;
 	VCHIQ_SHARED_STATE_T *remote;
 	VCHIQ_SLOT_T *slot_data;
 	unsigned short default_slot_quota;
 	unsigned short default_message_quota;
 	/* Event indicating connect message received */
 	struct semaphore connect;
 	/* Mutex protecting services */
 	struct mutex mutex;
 	VCHIQ_INSTANCE_T *instance;
 	/* Processes incoming messages */
 	VCHIQ_THREAD_T slot_handler_thread;
 	/* Processes recycled slots */
 	VCHIQ_THREAD_T recycle_thread;
 	/* Processes synchronous messages */
 	VCHIQ_THREAD_T sync_thread;
 	/* Local implementation of the trigger remote event */
 	struct semaphore trigger_event;
 	/* Local implementation of the recycle remote event */
 	struct semaphore recycle_event;
 	/* Local implementation of the sync trigger remote event */
 	struct semaphore sync_trigger_event;
 	/* Local implementation of the sync release remote event */
 	struct semaphore sync_release_event;
 	char *tx_data;
 	char *rx_data;
 	VCHIQ_SLOT_INFO_T *rx_info;
 	struct mutex slot_mutex;
 	struct mutex recycle_mutex;
 	struct mutex sync_mutex;
 	struct mutex bulk_transfer_mutex;
 	/* Indicates the byte position within the stream from where the next
 	** message will be read. The least significant bits are an index into
 	** the slot.The next bits are the index of the slot in
 	** remote->slot_queue. */
 	int rx_pos;
 	/* A cached copy of local->tx_pos. Only write to local->tx_pos, and read
 		from remote->tx_pos. */
 	int local_tx_pos;
 	/* The slot_queue index of the slot to become available next. */
 	int slot_queue_available;
 	/* A flag to indicate if any poll has been requested */
 	int poll_needed;
 	/* Ths index of the previous slot used for data messages. */
 	int previous_data_index;
 	/* The number of slots occupied by data messages. */
 	unsigned short data_use_count;
 	/* The maximum number of slots to be occupied by data messages. */
 	unsigned short data_quota;
 	/* An array of bit sets indicating which services must be polled. */
 	atomic_t poll_services[BITSET_SIZE(VCHIQ_MAX_SERVICES)];
 	/* The number of the first unused service */
 	int unused_service;
 	/* Signalled when a free slot becomes available. */
 	struct semaphore slot_available_event;
 	struct semaphore slot_remove_event;
 	/* Signalled when a free data slot becomes available. */
 	struct semaphore data_quota_event;
 	/* Incremented when there are bulk transfers which cannot be processed
 	 * whilst paused and must be processed on resume */
 	int deferred_bulks;
 	struct state_stats_struct {
 		int slot_stalls;
 		int data_stalls;
 		int ctrl_tx_count;
 		int ctrl_rx_count;
 		int error_count;
 	} stats;
 	VCHIQ_SERVICE_T * services[VCHIQ_MAX_SERVICES];
 	VCHIQ_SERVICE_QUOTA_T service_quotas[VCHIQ_MAX_SERVICES];
 	VCHIQ_SLOT_INFO_T slot_info[VCHIQ_MAX_SLOTS];
 	VCHIQ_PLATFORM_STATE_T platform_state;
 };
 struct bulk_waiter {
 	VCHIQ_BULK_T *bulk;
 	struct semaphore event;
 	int actual;
 };
 extern spinlock_t bulk_waiter_spinlock;
 extern int vchiq_core_log_level;
 extern int vchiq_core_msg_log_level;
 extern int vchiq_sync_log_level;
 extern VCHIQ_STATE_T *vchiq_states[VCHIQ_MAX_STATES];
 extern const char *
 get_conn_state_name(VCHIQ_CONNSTATE_T conn_state);
 extern VCHIQ_SLOT_ZERO_T *
 vchiq_init_slots(void *mem_base, int mem_size);
 extern VCHIQ_STATUS_T
 vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero,
 	int is_master);
 extern VCHIQ_STATUS_T
 vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);
 extern VCHIQ_SERVICE_T *
 vchiq_add_service_internal(VCHIQ_STATE_T *state,
 	const VCHIQ_SERVICE_PARAMS_T *params, int srvstate,
 	VCHIQ_INSTANCE_T instance, VCHIQ_USERDATA_TERM_T userdata_term);
 extern VCHIQ_STATUS_T
 vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id);
 extern VCHIQ_STATUS_T
 vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd);
 extern void
 vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service);
 extern void
 vchiq_free_service_internal(VCHIQ_SERVICE_T *service);
 extern VCHIQ_STATUS_T
 vchiq_shutdown_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);
 extern VCHIQ_STATUS_T
 vchiq_pause_internal(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_resume_internal(VCHIQ_STATE_T *state);
 extern void
 remote_event_pollall(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_bulk_transfer(VCHIQ_SERVICE_HANDLE_T handle,
 	VCHI_MEM_HANDLE_T memhandle, void *offset, int size, void *userdata,
 	VCHIQ_BULK_MODE_T mode, VCHIQ_BULK_DIR_T dir);
 extern void
 vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state);
 extern void
 vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service);
 extern void
 vchiq_loud_error_header(void);
 extern void
 vchiq_loud_error_footer(void);
 extern void
 request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type);
 static inline VCHIQ_SERVICE_T *
 handle_to_service(VCHIQ_SERVICE_HANDLE_T handle)
+{
 	VCHIQ_STATE_T *state = vchiq_states[(handle / VCHIQ_MAX_SERVICES) &
 		(VCHIQ_MAX_STATES - 1)];
 	if (!state)
 		return NULL;
 	return state->services[handle & (VCHIQ_MAX_SERVICES - 1)];
+}
 extern VCHIQ_SERVICE_T *
 find_service_by_handle(VCHIQ_SERVICE_HANDLE_T handle);
 extern VCHIQ_SERVICE_T *
 find_service_by_port(VCHIQ_STATE_T *state, int localport);
 extern VCHIQ_SERVICE_T *
 find_service_for_instance(VCHIQ_INSTANCE_T instance,
 	VCHIQ_SERVICE_HANDLE_T handle);
 extern VCHIQ_SERVICE_T *
 find_closed_service_for_instance(VCHIQ_INSTANCE_T instance,
 	VCHIQ_SERVICE_HANDLE_T handle);
 extern VCHIQ_SERVICE_T *
 next_service_by_instance(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance,
 	int *pidx);
 extern void
 lock_service(VCHIQ_SERVICE_T *service);
 extern void
 unlock_service(VCHIQ_SERVICE_T *service);
 /* The following functions are called from vchiq_core, and external
 ** implementations must be provided. */
 extern VCHIQ_STATUS_T
 vchiq_prepare_bulk_data(VCHIQ_BULK_T *bulk,
 	VCHI_MEM_HANDLE_T memhandle, void *offset, int size, int dir);
 extern void
 vchiq_transfer_bulk(VCHIQ_BULK_T *bulk);
 extern void
 vchiq_complete_bulk(VCHIQ_BULK_T *bulk);
 extern VCHIQ_STATUS_T
 vchiq_copy_from_user(void *dst, const void *src, int size);
 extern void
 remote_event_signal(REMOTE_EVENT_T *event);
 void
 vchiq_platform_check_suspend(VCHIQ_STATE_T *state);
 extern void
 vchiq_platform_paused(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_platform_resume(VCHIQ_STATE_T *state);
 extern void
 vchiq_platform_resumed(VCHIQ_STATE_T *state);
 extern void
 vchiq_dump(void *dump_context, const char *str, int len);
 extern void
 vchiq_dump_platform_state(void *dump_context);
 extern void
 vchiq_dump_platform_instances(void *dump_context);
 extern void
 vchiq_dump_platform_service_state(void *dump_context,
 	VCHIQ_SERVICE_T *service);
 extern VCHIQ_STATUS_T
 vchiq_use_service_internal(VCHIQ_SERVICE_T *service);
 extern VCHIQ_STATUS_T
 vchiq_release_service_internal(VCHIQ_SERVICE_T *service);
 extern void
 vchiq_on_remote_use(VCHIQ_STATE_T *state);
 extern void
 vchiq_on_remote_release(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_platform_init_state(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_check_service(VCHIQ_SERVICE_T *service);
 extern void
 vchiq_on_remote_use_active(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_send_remote_use(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_send_remote_release(VCHIQ_STATE_T *state);
 extern VCHIQ_STATUS_T
 vchiq_send_remote_use_active(VCHIQ_STATE_T *state);
 extern void
 vchiq_platform_conn_state_changed(VCHIQ_STATE_T *state,
 	VCHIQ_CONNSTATE_T oldstate, VCHIQ_CONNSTATE_T newstate);
 extern void
 vchiq_platform_handle_timeout(VCHIQ_STATE_T *state);
 extern void
 vchiq_set_conn_state(VCHIQ_STATE_T *state, VCHIQ_CONNSTATE_T newstate);
 extern void
 vchiq_log_dump_mem(const char *label, uint32_t addr, const void *voidMem,
 	size_t numBytes);
 extern void
 vchiq_core_initialize(void);
 #endif