projects / openwrt / svn-archive / archive.git / blob
? search:


bee41d712ed0e7c4587777225ff56fd3bbb99a4f
[openwrt/svn-archive/archive.git] / target / linux / brcm2708 / patches-3.3 / 0005-bcm2708-vchiq-driver.patch
1 From a2e42fbc97cde9e851f5b036f46b8f34a5be6eb9 Mon Sep 17 00:00:00 2001
2 From: popcornmix <popcornmix@gmail.com>
3 Date: Tue, 17 Jan 2012 19:22:19 +0000
4 Subject: [PATCH 5/7] bcm2708 vchiq driver
5
6 Signed-off-by: popcornmix <popcornmix@gmail.com>
7 ---
8 drivers/misc/Kconfig | 1 +
9 drivers/misc/Makefile | 1 +
10 drivers/misc/vc04_services/Kconfig | 7 +
11 drivers/misc/vc04_services/Makefile | 19 +
12 .../misc/vc04_services/interface/vchi/vchi_mh.h | 19 +
13 .../misc/vc04_services/interface/vchiq_arm/vchiq.h | 27 +
14 .../vc04_services/interface/vchiq_arm/vchiq_2835.h | 27 +
15 .../interface/vchiq_arm/vchiq_2835_arm.c | 487 ++++
16 .../vc04_services/interface/vchiq_arm/vchiq_arm.c | 1293 ++++++++++
17 .../vc04_services/interface/vchiq_arm/vchiq_arm.h | 38 +
18 .../vc04_services/interface/vchiq_arm/vchiq_cfg.h | 43 +
19 .../interface/vchiq_arm/vchiq_connected.c | 101 +
20 .../interface/vchiq_arm/vchiq_connected.h | 32 +
21 .../vc04_services/interface/vchiq_arm/vchiq_core.c | 2604 ++++++++++++++++++++
22 .../vc04_services/interface/vchiq_arm/vchiq_core.h | 480 ++++
23 .../vc04_services/interface/vchiq_arm/vchiq_if.h | 148 ++
24 .../interface/vchiq_arm/vchiq_ioctl.h | 105 +
25 .../interface/vchiq_arm/vchiq_kern_lib.c | 297 +++
26 .../vc04_services/interface/vchiq_arm/vchiq_lib.c | 1518 ++++++++++++
27 .../interface/vchiq_arm/vchiq_memdrv.h | 45 +
28 .../interface/vchiq_arm/vchiq_pagelist.h | 43 +
29 .../vc04_services/interface/vchiq_arm/vchiq_shim.c | 970 ++++++++
30 .../vc04_services/interface/vchiq_arm/vchiq_util.c | 97 +
31 .../vc04_services/interface/vchiq_arm/vchiq_util.h | 47 +
32 .../interface/vcos/generic/vcos_cmd.c | 681 +++++
33 .../interface/vcos/generic/vcos_common.h | 76 +
34 .../vcos/generic/vcos_generic_blockpool.h | 260 ++
35 .../vcos/generic/vcos_generic_event_flags.c | 297 +++
36 .../vcos/generic/vcos_generic_event_flags.h | 104 +
37 .../vcos/generic/vcos_generic_named_sem.h | 81 +
38 .../vcos/generic/vcos_generic_quickslow_mutex.h | 75 +
39 .../vcos/generic/vcos_generic_reentrant_mtx.h | 75 +
40 .../interface/vcos/generic/vcos_generic_tls.h | 144 ++
41 .../vcos/generic/vcos_joinable_thread_from_plain.h | 202 ++
42 .../interface/vcos/generic/vcos_latch_from_sem.h | 48 +
43 .../interface/vcos/generic/vcos_logcat.c | 549 +++++
44 .../interface/vcos/generic/vcos_mem_from_malloc.c | 73 +
45 .../interface/vcos/generic/vcos_mem_from_malloc.h | 54 +
46 .../vcos/generic/vcos_mutexes_are_reentrant.h | 68 +
47 .../interface/vcos/generic/vcos_thread_reaper.h | 35 +
48 .../interface/vcos/linuxkernel/stdint.h | 17 +
49 .../interface/vcos/linuxkernel/vcos_linuxkernel.c | 616 +++++
50 .../vcos/linuxkernel/vcos_linuxkernel_cfg.c | 332 +++
51 .../vcos/linuxkernel/vcos_linuxkernel_misc.c | 113 +
52 .../interface/vcos/linuxkernel/vcos_mod_init.c | 64 +
53 .../interface/vcos/linuxkernel/vcos_platform.h | 496 ++++
54 .../vcos/linuxkernel/vcos_platform_types.h | 47 +
55 .../interface/vcos/linuxkernel/vcos_thread_map.c | 129 +
56 .../interface/vcos/linuxkernel/vcos_thread_map.h | 39 +
57 drivers/misc/vc04_services/interface/vcos/vcos.h | 201 ++
58 .../vc04_services/interface/vcos/vcos_assert.h | 269 ++
59 .../interface/vcos/vcos_atomic_flags.h | 72 +
60 .../vc04_services/interface/vcos/vcos_build_info.h | 5 +
61 .../misc/vc04_services/interface/vcos/vcos_cfg.h | 113 +
62 .../misc/vc04_services/interface/vcos/vcos_cmd.h | 98 +
63 .../misc/vc04_services/interface/vcos/vcos_ctype.h | 29 +
64 .../misc/vc04_services/interface/vcos/vcos_dlfcn.h | 69 +
65 .../misc/vc04_services/interface/vcos/vcos_event.h | 97 +
66 .../interface/vcos/vcos_event_flags.h | 98 +
67 .../misc/vc04_services/interface/vcos/vcos_init.h | 43 +
68 .../vc04_services/interface/vcos/vcos_logging.h | 279 +++
69 .../interface/vcos/vcos_lowlevel_thread.h | 107 +
70 .../misc/vc04_services/interface/vcos/vcos_mem.h | 81 +
71 .../vc04_services/interface/vcos/vcos_msgqueue.h | 157 ++
72 .../misc/vc04_services/interface/vcos/vcos_mutex.h | 92 +
73 .../misc/vc04_services/interface/vcos/vcos_once.h | 42 +
74 .../vc04_services/interface/vcos/vcos_semaphore.h | 115 +
75 .../vc04_services/interface/vcos/vcos_stdbool.h | 17 +
76 .../vc04_services/interface/vcos/vcos_stdint.h | 193 ++
77 .../vc04_services/interface/vcos/vcos_string.h | 73 +
78 .../vc04_services/interface/vcos/vcos_thread.h | 259 ++
79 .../interface/vcos/vcos_thread_attr.h | 73 +
80 .../misc/vc04_services/interface/vcos/vcos_timer.h | 95 +
81 .../misc/vc04_services/interface/vcos/vcos_types.h | 197 ++
82 74 files changed, 15998 insertions(+), 0 deletions(-)
83 create mode 100644 drivers/misc/vc04_services/Kconfig
84 create mode 100644 drivers/misc/vc04_services/Makefile
85 create mode 100644 drivers/misc/vc04_services/interface/vchi/vchi_mh.h
86 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq.h
87 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_2835.h
88 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c
89 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_arm.c
90 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_arm.h
91 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_cfg.h
92 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_connected.c
93 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_connected.h
94 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_core.c
95 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_core.h
96 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_if.h
97 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
98 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_kern_lib.c
99 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_lib.c
100 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_memdrv.h
101 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_pagelist.h
102 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_shim.c
103 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_util.c
104 create mode 100644 drivers/misc/vc04_services/interface/vchiq_arm/vchiq_util.h
105 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_cmd.c
106 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_common.h
107 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_blockpool.h
108 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_event_flags.c
109 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_event_flags.h
110 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_named_sem.h
111 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_quickslow_mutex.h
112 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_reentrant_mtx.h
113 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_tls.h
114 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_joinable_thread_from_plain.h
115 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_latch_from_sem.h
116 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_logcat.c
117 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_mem_from_malloc.c
118 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_mem_from_malloc.h
119 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_mutexes_are_reentrant.h
120 create mode 100644 drivers/misc/vc04_services/interface/vcos/generic/vcos_thread_reaper.h
121 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/stdint.h
122 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel.c
123 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel_cfg.c
124 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel_misc.c
125 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_mod_init.c
126 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_platform.h
127 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_platform_types.h
128 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_thread_map.c
129 create mode 100644 drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_thread_map.h
130 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos.h
131 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_assert.h
132 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_atomic_flags.h
133 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_build_info.h
134 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_cfg.h
135 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_cmd.h
136 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_ctype.h
137 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_dlfcn.h
138 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_event.h
139 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_event_flags.h
140 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_init.h
141 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_logging.h
142 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_lowlevel_thread.h
143 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_mem.h
144 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_msgqueue.h
145 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_mutex.h
146 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_once.h
147 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_semaphore.h
148 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_stdbool.h
149 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_stdint.h
150 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_string.h
151 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_thread.h
152 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_thread_attr.h
153 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_timer.h
154 create mode 100644 drivers/misc/vc04_services/interface/vcos/vcos_types.h
155
156 --- a/drivers/misc/Kconfig
157 +++ b/drivers/misc/Kconfig
158 @@ -506,4 +506,5 @@ source "drivers/misc/ti-st/Kconfig"
159 source "drivers/misc/lis3lv02d/Kconfig"
160 source "drivers/misc/carma/Kconfig"
161 source "drivers/misc/altera-stapl/Kconfig"
162 +source "drivers/misc/vc04_services/Kconfig"
163 endmenu
164 --- a/drivers/misc/Makefile
165 +++ b/drivers/misc/Makefile
166 @@ -49,3 +49,5 @@ obj-y += carma/
167 obj-$(CONFIG_USB_SWITCH_FSA9480) += fsa9480.o
168 obj-$(CONFIG_ALTERA_STAPL) +=altera-stapl/
169 obj-$(CONFIG_MAX8997_MUIC) += max8997-muic.o
170 +obj-y += vc04_services/
171 +
172 --- /dev/null
173 +++ b/drivers/misc/vc04_services/Kconfig
174 @@ -0,0 +1,7 @@
175 +config BCM2708_VCHIQ
176 + tristate "Videocore VCHIQ"
177 + depends on MACH_BCM2708
178 + default y
179 + help
180 + Helper for communication for VideoCore.
181 +
182 --- /dev/null
183 +++ b/drivers/misc/vc04_services/Makefile
184 @@ -0,0 +1,19 @@
185 +obj-$(CONFIG_BCM2708_VCHIQ) += vchiq.o
186 +
187 +vchiq-objs := \
188 + interface/vchiq_arm/vchiq_core.o \
189 + interface/vchiq_arm/vchiq_arm.o \
190 + interface/vchiq_arm/vchiq_kern_lib.o \
191 + interface/vchiq_arm/vchiq_2835_arm.o \
192 + interface/vcos/linuxkernel/vcos_linuxkernel.o \
193 + interface/vcos/linuxkernel/vcos_thread_map.o \
194 + interface/vcos/linuxkernel/vcos_linuxkernel_cfg.o \
195 + interface/vcos/generic/vcos_generic_event_flags.o \
196 + interface/vcos/generic/vcos_logcat.o \
197 + interface/vcos/generic/vcos_mem_from_malloc.o \
198 + interface/vcos/generic/vcos_cmd.o
199 +
200 +EXTRA_CFLAGS += -DVCOS_VERIFY_BKPTS=1 -Idrivers/misc/vc04_services -Idrivers/misc/vc04_services/interface/vcos/linuxkernel
201 +
202 +
203 +
204 --- /dev/null
205 +++ b/drivers/misc/vc04_services/interface/vchi/vchi_mh.h
206 @@ -0,0 +1,19 @@
207 +/*=============================================================================
208 +Copyright (c) 2010 Broadcom Europe Limited. All rights reserved.
209 +
210 +Project : vchi
211 +Module : vchi
212 +
213 +FILE DESCRIPTION:
214 +Definitions for memory handle types.
215 +=============================================================================*/
216 +
217 +#ifndef VCHI_MH_H_
218 +#define VCHI_MH_H_
219 +
220 +#include <interface/vcos/vcos.h>
221 +
222 +typedef int32_t VCHI_MEM_HANDLE_T;
223 +#define VCHI_MEM_HANDLE_INVALID 0
224 +
225 +#endif
226 --- /dev/null
227 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq.h
228 @@ -0,0 +1,27 @@
229 +/*
230 + * Copyright (c) 2010-2011 Broadcom. All rights reserved.
231 + *
232 + * This program is free software; you can redistribute it and/or modify
233 + * it under the terms of the GNU General Public License as published by
234 + * the Free Software Foundation; either version 2 of the License, or
235 + * (at your option) any later version.
236 + *
237 + * This program is distributed in the hope that it will be useful,
238 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
239 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
240 + * GNU General Public License for more details.
241 + *
242 + * You should have received a copy of the GNU General Public License
243 + * along with this program; if not, write to the Free Software
244 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
245 + */
246 +
247 +#ifndef VCHIQ_VCHIQ_H
248 +#define VCHIQ_VCHIQ_H
249 +
250 +#include "vchiq_if.h"
251 +#include "vchiq_util.h"
252 +#include "interface/vcos/vcos.h"
253 +
254 +#endif
255 +
256 --- /dev/null
257 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_2835.h
258 @@ -0,0 +1,27 @@
259 +/*
260 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
261 + *
262 + * This program is free software; you can redistribute it and/or modify
263 + * it under the terms of the GNU General Public License as published by
264 + * the Free Software Foundation; either version 2 of the License, or
265 + * (at your option) any later version.
266 + *
267 + * This program is distributed in the hope that it will be useful,
268 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
269 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
270 + * GNU General Public License for more details.
271 + *
272 + * You should have received a copy of the GNU General Public License
273 + * along with this program; if not, write to the Free Software
274 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
275 + */
276 +
277 +#ifndef VCHIQ_2835_H
278 +#define VCHIQ_2835_H
279 +
280 +#include "vchiq_pagelist.h"
281 +
282 +#define VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX 0
283 +#define VCHIQ_PLATFORM_FRAGMENTS_COUNT_IDX 1
284 +
285 +#endif /* VCHIQ_2835_H */
286 --- /dev/null
287 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c
288 @@ -0,0 +1,487 @@
289 +/*
290 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
291 + *
292 + * This program is free software; you can redistribute it and/or modify
293 + * it under the terms of the GNU General Public License as published by
294 + * the Free Software Foundation; either version 2 of the License, or
295 + * (at your option) any later version.
296 + *
297 + * This program is distributed in the hope that it will be useful,
298 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
299 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
300 + * GNU General Public License for more details.
301 + *
302 + * You should have received a copy of the GNU General Public License
303 + * along with this program; if not, write to the Free Software
304 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
305 + */
306 +
307 +#include <linux/kernel.h>
308 +#include <linux/types.h>
309 +#include <linux/errno.h>
310 +#include <linux/interrupt.h>
311 +#include <linux/irq.h>
312 +#include <linux/pagemap.h>
313 +#include <linux/dma-mapping.h>
314 +#include <linux/version.h>
315 +#include <asm/pgtable.h>
316 +#include <asm/io.h>
317 +#include <asm/uaccess.h>
318 +
319 +#include <mach/irqs.h>
320 +
321 +#include <mach/platform.h>
322 +#include <mach/vcio.h>
323 +
324 +#define TOTAL_SLOTS (VCHIQ_SLOT_ZERO_SLOTS + 2 * 32)
325 +
326 +#define VCHIQ_DOORBELL_IRQ IRQ_ARM_DOORBELL_0
327 +#define VCHIQ_ARM_ADDRESS(x) __virt_to_bus(x)
328 +
329 +#include "vchiq_arm.h"
330 +#include "vchiq_2835.h"
331 +
332 +#define MAX_FRAGMENTS (VCHIQ_NUM_CURRENT_BULKS * 2)
333 +
334 +#define VCOS_LOG_CATEGORY (&vchiq_arm_log_category)
335 +
336 +static char *g_slot_mem;
337 +static int g_slot_mem_size;
338 +dma_addr_t g_slot_phys;
339 +static FRAGMENTS_T *g_fragments_base;
340 +static FRAGMENTS_T *g_free_fragments;
341 +struct semaphore g_free_fragments_sema;
342 +
343 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
344 +static DEFINE_SEMAPHORE(g_free_fragments_mutex);
345 +#else
346 +static DECLARE_MUTEX(g_free_fragments_mutex);
347 +#endif
348 +
349 +static irqreturn_t
350 +vchiq_doorbell_irq(int irq, void *dev_id);
351 +
352 +static int
353 +create_pagelist(char __user *buf, size_t count, unsigned short type,
354 + struct task_struct *task, PAGELIST_T ** ppagelist);
355 +
356 +static void
357 +free_pagelist(PAGELIST_T *pagelist, int actual);
358 +
359 +int __init
360 +vchiq_platform_vcos_init(void)
361 +{
362 + return (vcos_init() == VCOS_SUCCESS) ? 0 : -EINVAL;
363 +}
364 +
365 +int __init
366 +vchiq_platform_init(VCHIQ_STATE_T *state)
367 +{
368 + VCHIQ_SLOT_ZERO_T *vchiq_slot_zero;
369 + int frag_mem_size;
370 + int err;
371 + int i;
372 +
373 + /* Allocate space for the channels in coherent memory */
374 + g_slot_mem_size = PAGE_ALIGN(TOTAL_SLOTS * VCHIQ_SLOT_SIZE);
375 + frag_mem_size = PAGE_ALIGN(sizeof(FRAGMENTS_T) * MAX_FRAGMENTS);
376 +
377 + g_slot_mem = dma_alloc_coherent(NULL, g_slot_mem_size + frag_mem_size,
378 + &g_slot_phys, GFP_ATOMIC);
379 +
380 + if (!g_slot_mem) {
381 + vcos_log_error("Unable to allocate channel memory");
382 + err = -ENOMEM;
383 + goto failed_alloc;
384 + }
385 +
386 + vcos_assert(((int)g_slot_mem & (PAGE_SIZE - 1)) == 0);
387 +
388 + vchiq_slot_zero = vchiq_init_slots(g_slot_mem, g_slot_mem_size);
389 + if (!vchiq_slot_zero)
390 + {
391 + err = -EINVAL;
392 + goto failed_init_slots;
393 + }
394 +
395 + vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX] = (int)g_slot_phys + g_slot_mem_size;
396 + vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_COUNT_IDX] = MAX_FRAGMENTS;
397 +
398 + g_fragments_base = (FRAGMENTS_T *)(g_slot_mem + g_slot_mem_size);
399 + g_slot_mem_size += frag_mem_size;
400 +
401 + g_free_fragments = g_fragments_base;
402 + for (i = 0; i < (MAX_FRAGMENTS - 1); i++) {
403 + *(FRAGMENTS_T **) & g_fragments_base[i] =
404 + &g_fragments_base[i + 1];
405 + }
406 + *(FRAGMENTS_T **) & g_fragments_base[i] = NULL;
407 + sema_init(&g_free_fragments_sema, MAX_FRAGMENTS);
408 +
409 + if (vchiq_init_state(state, vchiq_slot_zero, 0/*slave*/) !=
410 + VCHIQ_SUCCESS)
411 + {
412 + err = -EINVAL;
413 + goto failed_vchiq_init;
414 + }
415 +
416 + err = request_irq(VCHIQ_DOORBELL_IRQ, vchiq_doorbell_irq,
417 + IRQF_SAMPLE_RANDOM | IRQF_IRQPOLL, "VCHIQ doorbell",
418 + state);
419 + if (err < 0)
420 + {
421 + printk( KERN_ERR "%s: failed to register irq=%d err=%d\n", __func__,
422 + VCHIQ_DOORBELL_IRQ, err );
423 + goto failed_request_irq;
424 + }
425 +
426 + /* Send the base address of the slots to VideoCore */
427 +
428 + dsb(); /* Ensure all writes have completed */
429 +
430 + bcm_mailbox_write(MBOX_CHAN_VCHIQ, (unsigned int)g_slot_phys);
431 +
432 + vcos_log_info("vchiq_init - done (slots %x, phys %x)",
433 + (unsigned int)vchiq_slot_zero, g_slot_phys);
434 +
435 + return 0;
436 +
437 +failed_request_irq:
438 +failed_vchiq_init:
439 +failed_init_slots:
440 + dma_free_coherent(NULL, g_slot_mem_size, g_slot_mem, g_slot_phys);
441 +
442 +failed_alloc:
443 + return err;
444 +}
445 +
446 +void __exit
447 +vchiq_platform_exit(VCHIQ_STATE_T *state)
448 +{
449 + free_irq(VCHIQ_DOORBELL_IRQ, state);
450 + dma_free_coherent(NULL, g_slot_mem_size,
451 + g_slot_mem, g_slot_phys);
452 +}
453 +
454 +void
455 +remote_event_signal(REMOTE_EVENT_T *event)
456 +{
457 + event->fired = 1;
458 +
459 + /* The test on the next line also ensures the write on the previous line
460 + has completed */
461 +
462 + if (event->armed) {
463 + /* trigger vc interrupt */
464 + dsb(); /* data barrier operation */
465 +
466 + writel(0, __io_address(ARM_0_BELL2));
467 + }
468 +}
469 +
470 +int
471 +vchiq_copy_from_user(void *dst, const void *src, int size)
472 +{
473 + return copy_from_user(dst, src, size);
474 +}
475 +
476 +VCHIQ_STATUS_T
477 +vchiq_prepare_bulk_data(VCHIQ_BULK_T *bulk, VCHI_MEM_HANDLE_T memhandle,
478 + void *offset, int size, int dir)
479 +{
480 + PAGELIST_T *pagelist;
481 + int ret;
482 +
483 + vcos_assert(memhandle == VCHI_MEM_HANDLE_INVALID);
484 +
485 + ret = create_pagelist((char __user *)offset, size,
486 + (dir == VCHIQ_BULK_RECEIVE)
487 + ? PAGELIST_READ
488 + : PAGELIST_WRITE,
489 + current,
490 + &pagelist);
491 + if (ret != 0)
492 + return VCHIQ_ERROR;
493 +
494 + bulk->handle = memhandle;
495 + bulk->data = VCHIQ_ARM_ADDRESS(pagelist);
496 +
497 + /* Store the pagelist address in remote_data, which isn't used by the
498 + slave. */
499 + bulk->remote_data = pagelist;
500 +
501 + return VCHIQ_SUCCESS;
502 +}
503 +
504 +void
505 +vchiq_complete_bulk(VCHIQ_BULK_T *bulk)
506 +{
507 + free_pagelist((PAGELIST_T *)bulk->remote_data, bulk->actual);
508 +}
509 +
510 +void
511 +vchiq_transfer_bulk(VCHIQ_BULK_T *bulk)
512 +{
513 + /*
514 + * This should only be called on the master (VideoCore) side, but
515 + * provide an implementation to avoid the need for ifdefery.
516 + */
517 + vcos_assert(!"This code should not be called by the ARM on BCM2835");
518 +}
519 +
520 +void
521 +vchiq_dump_platform_state(void *dump_context)
522 +{
523 + char buf[80];
524 + int len;
525 + len = vcos_snprintf(buf, sizeof(buf),
526 + " Platform: 2835 (VC master)");
527 + vchiq_dump(dump_context, buf, len + 1);
528 +}
529 +
530 +void
531 +vchiq_platform_paused(VCHIQ_STATE_T *state)
532 +{
533 + vcos_unused(state);
534 + vcos_assert_msg(0, "Suspend/resume not supported");
535 +}
536 +
537 +void
538 +vchiq_platform_resumed(VCHIQ_STATE_T *state)
539 +{
540 + vcos_unused(state);
541 + vcos_assert_msg(0, "Suspend/resume not supported");
542 +}
543 +
544 +VCHIQ_STATUS_T
545 +vchiq_use_service(VCHIQ_SERVICE_HANDLE_T handle)
546 +{
547 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
548 + if (!service)
549 + return VCHIQ_ERROR;
550 + return VCHIQ_SUCCESS;
551 +}
552 +
553 +VCHIQ_STATUS_T
554 +vchiq_release_service(VCHIQ_SERVICE_HANDLE_T handle)
555 +{
556 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
557 + if (!service)
558 + return VCHIQ_ERROR;
559 + return VCHIQ_SUCCESS;
560 +}
561 +
562 +VCHIQ_STATUS_T
563 +vchiq_check_service(VCHIQ_SERVICE_HANDLE_T handle)
564 +{
565 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
566 + if (!service)
567 + return VCHIQ_ERROR;
568 + return VCHIQ_SUCCESS;
569 +}
570 +
571 +/*
572 + * Local functions
573 + */
574 +
575 +static irqreturn_t
576 +vchiq_doorbell_irq(int irq, void *dev_id)
577 +{
578 + VCHIQ_STATE_T *state = dev_id;
579 + irqreturn_t ret = IRQ_NONE;
580 + unsigned int status;
581 +
582 + /* Read (and clear) the doorbell */
583 + status = readl(__io_address(ARM_0_BELL0));
584 +
585 + if (status & 0x4) { /* Was the doorbell rung? */
586 + remote_event_pollall(state);
587 + ret = IRQ_HANDLED;
588 + }
589 +
590 + return ret;
591 +}
592 +
593 +/* There is a potential problem with partial cache lines (pages?)
594 + at the ends of the block when reading. If the CPU accessed anything in
595 + the same line (page?) then it may have pulled old data into the cache,
596 + obscuring the new data underneath. We can solve this by transferring the
597 + partial cache lines separately, and allowing the ARM to copy into the
598 + cached area.
599 +
600 + N.B. This implementation plays slightly fast and loose with the Linux
601 + driver programming rules, e.g. its use of __virt_to_bus instead of
602 + dma_map_single, but it isn't a multi-platform driver and it benefits
603 + from increased speed as a result.
604 + */
605 +
606 +static int
607 +create_pagelist(char __user *buf, size_t count, unsigned short type,
608 + struct task_struct *task, PAGELIST_T ** ppagelist)
609 +{
610 + PAGELIST_T *pagelist;
611 + struct page **pages;
612 + struct page *page;
613 + unsigned long *addrs;
614 + unsigned int num_pages, offset, i;
615 + char *addr, *base_addr, *next_addr;
616 + int run, addridx, actual_pages;
617 +
618 + offset = (unsigned int)buf & (PAGE_SIZE - 1);
619 + num_pages = (count + offset + PAGE_SIZE - 1) / PAGE_SIZE;
620 +
621 + *ppagelist = NULL;
622 +
623 + /* Allocate enough storage to hold the page pointers and the page list */
624 + pagelist = (PAGELIST_T *) kmalloc(sizeof(PAGELIST_T) +
625 + (num_pages * sizeof(unsigned long)) +
626 + (num_pages * sizeof(pages[0])),
627 + GFP_KERNEL);
628 +
629 + vcos_log_trace("create_pagelist - %x", (unsigned int)pagelist);
630 + if (!pagelist)
631 + return -ENOMEM;
632 +
633 + addrs = pagelist->addrs;
634 + pages = (struct page **)(addrs + num_pages);
635 +
636 + down_read(&task->mm->mmap_sem);
637 + actual_pages = get_user_pages(task, task->mm,
638 + (unsigned long)buf & ~(PAGE_SIZE - 1), num_pages,
639 + (type == PAGELIST_READ) /*Write */ , 0 /*Force */ ,
640 + pages, NULL /*vmas */ );
641 + up_read(&task->mm->mmap_sem);
642 +
643 + if (actual_pages != num_pages)
644 + {
645 + for (i = 0; i < actual_pages; i++) {
646 + page_cache_release(pages[i]);
647 + }
648 + kfree(pagelist);
649 + return -EINVAL;
650 + }
651 +
652 + pagelist->length = count;
653 + pagelist->type = type;
654 + pagelist->offset = offset;
655 +
656 + /* Group the pages into runs of contiguous pages */
657 +
658 + base_addr = VCHIQ_ARM_ADDRESS(page_address(pages[0]));
659 + next_addr = base_addr + PAGE_SIZE;
660 + addridx = 0;
661 + run = 0;
662 +
663 + for (i = 1; i < num_pages; i++) {
664 + addr = VCHIQ_ARM_ADDRESS(page_address(pages[i]));
665 + if ((addr == next_addr) && (run < (PAGE_SIZE - 1))) {
666 + next_addr += PAGE_SIZE;
667 + run++;
668 + } else {
669 + addrs[addridx] = (unsigned long)base_addr + run;
670 + addridx++;
671 + base_addr = addr;
672 + next_addr = addr + PAGE_SIZE;
673 + run = 0;
674 + }
675 + }
676 +
677 + addrs[addridx] = (unsigned long)base_addr + run;
678 + addridx++;
679 +
680 + /* Partial cache lines (fragments) require special measures */
681 + if ((type == PAGELIST_READ) &&
682 + ((pagelist->offset & (CACHE_LINE_SIZE - 1)) ||
683 + ((pagelist->offset + pagelist->length) & (CACHE_LINE_SIZE - 1)))) {
684 + FRAGMENTS_T *fragments;
685 +
686 + if (down_interruptible(&g_free_fragments_sema) != 0) {
687 + kfree(pagelist);
688 + return -EINTR;
689 + }
690 +
691 + vcos_assert(g_free_fragments != NULL);
692 +
693 + down(&g_free_fragments_mutex);
694 + fragments = (FRAGMENTS_T *) g_free_fragments;
695 + vcos_assert(fragments != NULL);
696 + g_free_fragments = *(FRAGMENTS_T **) g_free_fragments;
697 + up(&g_free_fragments_mutex);
698 + pagelist->type =
699 + PAGELIST_READ_WITH_FRAGMENTS + (fragments -
700 + g_fragments_base);
701 + }
702 +
703 + for (page = virt_to_page(pagelist);
704 + page <= virt_to_page(addrs + num_pages - 1); page++) {
705 + flush_dcache_page(page);
706 + }
707 +
708 + *ppagelist = pagelist;
709 +
710 + return 0;
711 +}
712 +
713 +static void
714 +free_pagelist(PAGELIST_T *pagelist, int actual)
715 +{
716 + struct page **pages;
717 + unsigned int num_pages, i;
718 +
719 + vcos_log_trace("free_pagelist - %x, %d", (unsigned int)pagelist, actual);
720 +
721 + num_pages =
722 + (pagelist->length + pagelist->offset + PAGE_SIZE - 1) / PAGE_SIZE;
723 +
724 + pages = (struct page **)(pagelist->addrs + num_pages);
725 +
726 + /* Deal with any partial cache lines (fragments) */
727 + if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS) {
728 + FRAGMENTS_T *fragments =
729 + g_fragments_base + (pagelist->type -
730 + PAGELIST_READ_WITH_FRAGMENTS);
731 + int head_bytes, tail_bytes;
732 +
733 + if (actual >= 0)
734 + {
735 + if ((head_bytes = (CACHE_LINE_SIZE - pagelist->offset) & (CACHE_LINE_SIZE - 1)) != 0) {
736 + if (head_bytes > actual)
737 + head_bytes = actual;
738 +
739 + memcpy((char *)page_address(pages[0]) +
740 + pagelist->offset, fragments->headbuf,
741 + head_bytes);
742 + }
743 + if ((head_bytes < actual) &&
744 + (tail_bytes =
745 + (pagelist->offset + actual) & (CACHE_LINE_SIZE -
746 + 1)) != 0) {
747 + memcpy((char *)page_address(pages[num_pages - 1]) +
748 + ((pagelist->offset + actual) & (PAGE_SIZE -
749 + 1) & ~(CACHE_LINE_SIZE - 1)),
750 + fragments->tailbuf, tail_bytes);
751 + }
752 + }
753 +
754 + down(&g_free_fragments_mutex);
755 + *(FRAGMENTS_T **) fragments = g_free_fragments;
756 + g_free_fragments = fragments;
757 + up(&g_free_fragments_mutex);
758 + up(&g_free_fragments_sema);
759 + }
760 +
761 + for (i = 0; i < num_pages; i++) {
762 + if (pagelist->type != PAGELIST_WRITE)
763 + set_page_dirty(pages[i]);
764 + page_cache_release(pages[i]);
765 + }
766 +
767 + kfree(pagelist);
768 +}
769 +
770 +VCHIQ_STATUS_T
771 +vchiq_platform_suspend(VCHIQ_STATE_T *state)
772 +{
773 + vcos_unused(state);
774 + return VCHIQ_ERROR;
775 +}
776 --- /dev/null
777 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_arm.c
778 @@ -0,0 +1,1293 @@
779 +/*
780 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
781 + *
782 + * This program is free software; you can redistribute it and/or modify
783 + * it under the terms of the GNU General Public License as published by
784 + * the Free Software Foundation; either version 2 of the License, or
785 + * (at your option) any later version.
786 + *
787 + * This program is distributed in the hope that it will be useful,
788 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
789 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
790 + * GNU General Public License for more details.
791 + *
792 + * You should have received a copy of the GNU General Public License
793 + * along with this program; if not, write to the Free Software
794 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
795 + */
796 +
797 +#include <linux/kernel.h>
798 +#include <linux/module.h>
799 +#include <linux/types.h>
800 +#include <linux/errno.h>
801 +#include <linux/cdev.h>
802 +#include <linux/fs.h>
803 +#include <linux/device.h>
804 +
805 +#include "vchiq_core.h"
806 +#include "vchiq_ioctl.h"
807 +#include "vchiq_arm.h"
808 +
809 +#define DEVICE_NAME "vchiq"
810 +
811 +/* Override the default prefix, which would be vchiq_arm (from the filename) */
812 +#undef MODULE_PARAM_PREFIX
813 +#define MODULE_PARAM_PREFIX DEVICE_NAME "."
814 +
815 +#define VCHIQ_MINOR 0
816 +
817 +/* Some per-instance constants */
818 +#define MAX_COMPLETIONS 16
819 +#define MAX_SERVICES 64
820 +#define MAX_ELEMENTS 8
821 +#define MSG_QUEUE_SIZE 64
822 +
823 +#define VCOS_LOG_CATEGORY (&vchiq_arm_log_category)
824 +
825 +typedef struct client_service_struct {
826 + VCHIQ_SERVICE_T *service;
827 + void *userdata;
828 + VCHIQ_INSTANCE_T instance;
829 + int handle;
830 + int is_vchi;
831 + volatile int dequeue_pending;
832 + volatile int message_available_pos;
833 + volatile int msg_insert;
834 + volatile int msg_remove;
835 + VCOS_EVENT_T insert_event;
836 + VCOS_EVENT_T remove_event;
837 + VCHIQ_HEADER_T *msg_queue[MSG_QUEUE_SIZE];
838 +} USER_SERVICE_T;
839 +
840 +struct vchiq_instance_struct {
841 + VCHIQ_STATE_T *state;
842 + VCHIQ_COMPLETION_DATA_T completions[MAX_COMPLETIONS];
843 + volatile int completion_insert;
844 + volatile int completion_remove;
845 + VCOS_EVENT_T insert_event;
846 + VCOS_EVENT_T remove_event;
847 +
848 + USER_SERVICE_T services[MAX_SERVICES];
849 +
850 + int connected;
851 + int closing;
852 + int pid;
853 + int mark;
854 +};
855 +
856 +typedef struct dump_context_struct
857 +{
858 + char __user *buf;
859 + size_t actual;
860 + size_t space;
861 + loff_t offset;
862 +} DUMP_CONTEXT_T;
863 +
864 +VCOS_LOG_CAT_T vchiq_arm_log_category;
865 +
866 +static struct cdev vchiq_cdev;
867 +static dev_t vchiq_devid;
868 +static VCHIQ_STATE_T g_state;
869 +static struct class *vchiq_class;
870 +static struct device *vchiq_dev;
871 +
872 +static const char *ioctl_names[] =
873 +{
874 + "CONNECT",
875 + "SHUTDOWN",
876 + "CREATE_SERVICE",
877 + "REMOVE_SERVICE",
878 + "QUEUE_MESSAGE",
879 + "QUEUE_BULK_TRANSMIT",
880 + "QUEUE_BULK_RECEIVE",
881 + "AWAIT_COMPLETION",
882 + "DEQUEUE_MESSAGE",
883 + "GET_CLIENT_ID",
884 + "GET_CONFIG",
885 + "CLOSE_SERVICE",
886 + "USE_SERVICE",
887 + "RELEASE_SERIVCE"
888 +};
889 +
890 +VCOS_LOG_LEVEL_T vchiq_default_arm_log_level = VCOS_LOG_WARN;
891 +
892 +/****************************************************************************
893 +*
894 +* find_service_by_handle
895 +*
896 +***************************************************************************/
897 +
898 +static inline USER_SERVICE_T *find_service_by_handle(
899 + VCHIQ_INSTANCE_T instance, int handle )
900 +{
901 + USER_SERVICE_T *user_service;
902 +
903 + if (( handle >= 0 )
904 + && ( handle < MAX_SERVICES ))
905 + {
906 + user_service = &instance->services[ handle ];
907 +
908 + if ( user_service->service != NULL )
909 + {
910 + return user_service;
911 + }
912 + }
913 +
914 + return NULL;
915 +}
916 +
917 +/****************************************************************************
918 +*
919 +* find_avail_service_handle
920 +*
921 +***************************************************************************/
922 +
923 +static inline USER_SERVICE_T *find_avail_service_handle(
924 + VCHIQ_INSTANCE_T instance)
925 +{
926 + int handle;
927 +
928 + for ( handle = 0; handle < MAX_SERVICES; handle++ )
929 + {
930 + if ( instance->services[handle].service == NULL )
931 + {
932 + instance->services[handle].instance = instance;
933 + instance->services[handle].handle = handle;
934 +
935 + return &instance->services[handle];
936 + }
937 + }
938 + return NULL;
939 +}
940 +
941 +/****************************************************************************
942 +*
943 +* add_completion
944 +*
945 +***************************************************************************/
946 +
947 +static VCHIQ_STATUS_T
948 +add_completion(VCHIQ_INSTANCE_T instance, VCHIQ_REASON_T reason,
949 + VCHIQ_HEADER_T *header, USER_SERVICE_T *service, void *bulk_userdata)
950 +{
951 + VCHIQ_COMPLETION_DATA_T *completion;
952 + DEBUG_INITIALISE(g_state.local)
953 +
954 + while (instance->completion_insert ==
955 + (instance->completion_remove + MAX_COMPLETIONS)) {
956 + /* Out of space - wait for the client */
957 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
958 + vcos_log_trace("add_completion - completion queue full");
959 + DEBUG_COUNT(COMPLETION_QUEUE_FULL_COUNT);
960 + if (vcos_event_wait(&instance->remove_event) != VCOS_SUCCESS) {
961 + vcos_log_info("service_callback interrupted");
962 + return VCHIQ_RETRY;
963 + } else if (instance->closing) {
964 + vcos_log_info("service_callback closing");
965 + return VCHIQ_ERROR;
966 + }
967 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
968 + }
969 +
970 + completion =
971 + &instance->
972 + completions[instance->completion_insert & (MAX_COMPLETIONS - 1)];
973 +
974 + completion->header = header;
975 + completion->reason = reason;
976 + completion->service_userdata = service;
977 + completion->bulk_userdata = bulk_userdata;
978 +
979 + /* A write barrier is needed here to ensure that the entire completion
980 + record is written out before the insert point. */
981 + vcos_wmb(&completion->bulk_userdata);
982 +
983 + if (reason == VCHIQ_MESSAGE_AVAILABLE)
984 + service->message_available_pos = instance->completion_insert;
985 + instance->completion_insert++;
986 +
987 + vcos_event_signal(&instance->insert_event);
988 +
989 + return VCHIQ_SUCCESS;
990 +}
991 +
992 +/****************************************************************************
993 +*
994 +* service_callback
995 +*
996 +***************************************************************************/
997 +
998 +static VCHIQ_STATUS_T
999 +service_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header,
1000 + VCHIQ_SERVICE_HANDLE_T handle, void *bulk_userdata)
1001 +{
1002 + /* How do we ensure the callback goes to the right client?
1003 + The service_user data points to a USER_SERVICE_T record containing the
1004 + original callback and the user state structure, which contains a circular
1005 + buffer for completion records.
1006 + */
1007 + USER_SERVICE_T *service =
1008 + (USER_SERVICE_T *) VCHIQ_GET_SERVICE_USERDATA(handle);
1009 + VCHIQ_INSTANCE_T instance = service->instance;
1010 + DEBUG_INITIALISE(g_state.local)
1011 +
1012 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1013 + vcos_log_trace
1014 + ("service_callback - service %lx(%d), reason %d, header %lx, "
1015 + "instance %lx, bulk_userdata %lx",
1016 + (unsigned long)service, ((VCHIQ_SERVICE_T *) handle)->localport,
1017 + reason, (unsigned long)header,
1018 + (unsigned long)instance, (unsigned long)bulk_userdata);
1019 +
1020 + if (!instance || instance->closing) {
1021 + return VCHIQ_SUCCESS;
1022 + }
1023 +
1024 + if (header && service->is_vchi)
1025 + {
1026 + while (service->msg_insert == (service->msg_remove + MSG_QUEUE_SIZE))
1027 + {
1028 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1029 + DEBUG_COUNT(MSG_QUEUE_FULL_COUNT);
1030 + vcos_log_trace("service_callback - msg queue full");
1031 + /* If there is no MESSAGE_AVAILABLE in the completion queue, add one */
1032 + if ((service->message_available_pos - instance->completion_remove) < 0)
1033 + {
1034 + VCHIQ_STATUS_T status;
1035 + vcos_log_warn("Inserting extra MESSAGE_AVAILABLE");
1036 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1037 + status = add_completion(instance, reason, NULL, service, bulk_userdata);
1038 + if (status != VCHIQ_SUCCESS)
1039 + {
1040 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1041 + return status;
1042 + }
1043 + }
1044 +
1045 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1046 + if (vcos_event_wait(&service->remove_event) != VCOS_SUCCESS) {
1047 + vcos_log_info("service_callback interrupted");
1048 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1049 + return VCHIQ_RETRY;
1050 + } else if (instance->closing) {
1051 + vcos_log_info("service_callback closing");
1052 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1053 + return VCHIQ_ERROR;
1054 + }
1055 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1056 + }
1057 +
1058 + service->msg_queue[service->msg_insert & (MSG_QUEUE_SIZE - 1)] =
1059 + header;
1060 +
1061 + /* A write memory barrier is needed to ensure that the store of header
1062 + is completed before the insertion point is updated */
1063 + vcos_wmb(&service->msg_queue[service->msg_insert & (MSG_QUEUE_SIZE - 1)]);
1064 +
1065 + service->msg_insert++;
1066 + vcos_event_signal(&service->insert_event);
1067 +
1068 + /* If there is a thread waiting in DEQUEUE_MESSAGE, or if
1069 + there is a MESSAGE_AVAILABLE in the completion queue then
1070 + bypass the completion queue. */
1071 + if (((service->message_available_pos - instance->completion_remove) >= 0) ||
1072 + service->dequeue_pending)
1073 + {
1074 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1075 + service->dequeue_pending = 0;
1076 + return VCHIQ_SUCCESS;
1077 + }
1078 +
1079 + header = NULL;
1080 + }
1081 + DEBUG_TRACE(SERVICE_CALLBACK_LINE);
1082 +
1083 + return add_completion(instance, reason, header, service, bulk_userdata);
1084 +}
1085 +
1086 +/****************************************************************************
1087 +*
1088 +* vchiq_ioctl
1089 +*
1090 +***************************************************************************/
1091 +
1092 +static long
1093 +vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1094 +{
1095 + VCHIQ_INSTANCE_T instance = file->private_data;
1096 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
1097 + long ret = 0;
1098 + int i, rc;
1099 + DEBUG_INITIALISE(g_state.local)
1100 +
1101 + vcos_log_trace("vchiq_ioctl - instance %x, cmd %s, arg %lx",
1102 + (unsigned int)instance,
1103 + ((_IOC_TYPE(cmd) == VCHIQ_IOC_MAGIC) && (_IOC_NR(cmd) <= VCHIQ_IOC_MAX)) ?
1104 + ioctl_names[_IOC_NR(cmd)] : "<invalid>", arg);
1105 +
1106 + switch (cmd) {
1107 + case VCHIQ_IOC_SHUTDOWN:
1108 + if (!instance->connected)
1109 + break;
1110 +
1111 + /* Remove all services */
1112 + for (i = 0; i < MAX_SERVICES; i++) {
1113 + USER_SERVICE_T *service = &instance->services[i];
1114 + if (service->service != NULL) {
1115 + status = vchiq_remove_service(&service->service->base);
1116 + if (status != VCHIQ_SUCCESS)
1117 + break;
1118 + service->service = NULL;
1119 + }
1120 + }
1121 +
1122 + if (status == VCHIQ_SUCCESS) {
1123 + /* Wake the completion thread and ask it to exit */
1124 + instance->closing = 1;
1125 + vcos_event_signal(&instance->insert_event);
1126 + }
1127 +
1128 + break;
1129 +
1130 + case VCHIQ_IOC_CONNECT:
1131 + if (instance->connected) {
1132 + ret = -EINVAL;
1133 + break;
1134 + }
1135 + if ((rc=vcos_mutex_lock(&instance->state->mutex)) != VCOS_SUCCESS) {
1136 + vcos_log_error("vchiq: connect: could not lock mutex for state %d: %d",
1137 + instance->state->id, rc);
1138 + ret = -EINTR;
1139 + break;
1140 + }
1141 + status = vchiq_connect_internal(instance->state, instance);
1142 + vcos_mutex_unlock(&instance->state->mutex);
1143 +
1144 + if (status == VCHIQ_SUCCESS)
1145 + instance->connected = 1;
1146 + else
1147 + vcos_log_error("vchiq: could not connect: %d", status);
1148 + break;
1149 +
1150 + case VCHIQ_IOC_CREATE_SERVICE:
1151 + {
1152 + VCHIQ_CREATE_SERVICE_T args;
1153 + VCHIQ_SERVICE_T *service = NULL;
1154 + USER_SERVICE_T *user_service = NULL;
1155 + void *userdata;
1156 + int srvstate;
1157 +
1158 + if (copy_from_user
1159 + (&args, (const void __user *)arg,
1160 + sizeof(args)) != 0) {
1161 + ret = -EFAULT;
1162 + break;
1163 + }
1164 +
1165 + for (i = 0; i < MAX_SERVICES; i++) {
1166 + if (instance->services[i].service == NULL) {
1167 + user_service = &instance->services[i];
1168 + break;
1169 + }
1170 + }
1171 +
1172 + if (!user_service) {
1173 + ret = -EMFILE;
1174 + break;
1175 + }
1176 +
1177 + if (args.is_open) {
1178 + if (instance->connected)
1179 + srvstate = VCHIQ_SRVSTATE_OPENING;
1180 + else {
1181 + ret = -ENOTCONN;
1182 + break;
1183 + }
1184 + } else {
1185 + srvstate =
1186 + instance->connected ?
1187 + VCHIQ_SRVSTATE_LISTENING :
1188 + VCHIQ_SRVSTATE_HIDDEN;
1189 + }
1190 +
1191 + vcos_mutex_lock(&instance->state->mutex);
1192 +
1193 + userdata = args.params.userdata;
1194 + args.params.callback = service_callback;
1195 + args.params.userdata = user_service;
1196 + service =
1197 + vchiq_add_service_internal(instance->state,
1198 + &args.params, srvstate,
1199 + instance);
1200 +
1201 + vcos_mutex_unlock(&instance->state->mutex);
1202 +
1203 + if (service != NULL) {
1204 + user_service->service = service;
1205 + user_service->userdata = userdata;
1206 + user_service->instance = instance;
1207 + user_service->handle = i;
1208 + user_service->is_vchi = args.is_vchi;
1209 + user_service->dequeue_pending = 0;
1210 + user_service->message_available_pos = instance->completion_remove - 1;
1211 + user_service->msg_insert = 0;
1212 + user_service->msg_remove = 0;
1213 + vcos_event_create(&user_service->insert_event, "insert_event");
1214 + vcos_event_create(&user_service->remove_event, "remove_event");
1215 +
1216 + if (args.is_open) {
1217 + status =
1218 + vchiq_open_service_internal
1219 + (service, instance->pid);
1220 + if (status != VCHIQ_SUCCESS) {
1221 + vchiq_remove_service
1222 + (&service->base);
1223 + ret =
1224 + (status ==
1225 + VCHIQ_RETRY) ? -EINTR :
1226 + -EIO;
1227 + user_service->service = NULL;
1228 + user_service->instance = NULL;
1229 + vcos_event_delete(&user_service->insert_event);
1230 + vcos_event_delete(&user_service->remove_event);
1231 + break;
1232 + }
1233 + }
1234 +
1235 + if (copy_to_user((void __user *)
1236 + &(((VCHIQ_CREATE_SERVICE_T __user
1237 + *) arg)->handle),
1238 + (const void *)&user_service->
1239 + handle,
1240 + sizeof(user_service->
1241 + handle)) != 0)
1242 + ret = -EFAULT;
1243 + } else {
1244 + ret = -EEXIST;
1245 + }
1246 + }
1247 + break;
1248 +
1249 + case VCHIQ_IOC_CLOSE_SERVICE:
1250 + {
1251 + USER_SERVICE_T *user_service;
1252 + int handle = (int)arg;
1253 +
1254 + user_service = find_service_by_handle(instance, handle);
1255 + if (user_service != NULL)
1256 + {
1257 + int is_server = (user_service->service->public_fourcc != VCHIQ_FOURCC_INVALID);
1258 +
1259 + status =
1260 + vchiq_close_service(&user_service->service->base);
1261 + if ((status == VCHIQ_SUCCESS) && !is_server)
1262 + {
1263 + vcos_event_delete(&user_service->insert_event);
1264 + vcos_event_delete(&user_service->remove_event);
1265 + user_service->service = NULL;
1266 + }
1267 + } else
1268 + ret = -EINVAL;
1269 + }
1270 + break;
1271 +
1272 + case VCHIQ_IOC_REMOVE_SERVICE:
1273 + {
1274 + USER_SERVICE_T *user_service;
1275 + int handle = (int)arg;
1276 +
1277 + user_service = find_service_by_handle(instance, handle);
1278 + if (user_service != NULL)
1279 + {
1280 + status =
1281 + vchiq_remove_service(&user_service->service->base);
1282 + if (status == VCHIQ_SUCCESS)
1283 + {
1284 + vcos_event_delete(&user_service->insert_event);
1285 + vcos_event_delete(&user_service->remove_event);
1286 + user_service->service = NULL;
1287 + }
1288 + } else
1289 + ret = -EINVAL;
1290 + }
1291 + break;
1292 +
1293 + case VCHIQ_IOC_USE_SERVICE:
1294 + case VCHIQ_IOC_RELEASE_SERVICE:
1295 + {
1296 + USER_SERVICE_T *user_service;
1297 + int handle = (int)arg;
1298 +
1299 + user_service = find_service_by_handle(instance, handle);
1300 + if (user_service != NULL)
1301 + {
1302 + status = (cmd == VCHIQ_IOC_USE_SERVICE) ? vchiq_use_service(&user_service->service->base) : vchiq_release_service(&user_service->service->base);
1303 + if (status != VCHIQ_SUCCESS)
1304 + {
1305 + ret = -EINVAL; // ???
1306 + }
1307 + }
1308 + }
1309 + break;
1310 +
1311 + case VCHIQ_IOC_QUEUE_MESSAGE:
1312 + {
1313 + VCHIQ_QUEUE_MESSAGE_T args;
1314 + USER_SERVICE_T *user_service;
1315 +
1316 + if (copy_from_user
1317 + (&args, (const void __user *)arg,
1318 + sizeof(args)) != 0) {
1319 + ret = -EFAULT;
1320 + break;
1321 + }
1322 + user_service = find_service_by_handle(instance, args.handle);
1323 + if ((user_service != NULL) && (args.count <= MAX_ELEMENTS))
1324 + {
1325 + /* Copy elements into kernel space */
1326 + VCHIQ_ELEMENT_T elements[MAX_ELEMENTS];
1327 + if (copy_from_user
1328 + (elements, args.elements,
1329 + args.count * sizeof(VCHIQ_ELEMENT_T)) == 0)
1330 + status =
1331 + vchiq_queue_message
1332 + (&user_service->service->base,
1333 + elements, args.count);
1334 + else
1335 + ret = -EFAULT;
1336 + } else {
1337 + ret = -EINVAL;
1338 + }
1339 + }
1340 + break;
1341 +
1342 + case VCHIQ_IOC_QUEUE_BULK_TRANSMIT:
1343 + case VCHIQ_IOC_QUEUE_BULK_RECEIVE:
1344 + {
1345 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
1346 + USER_SERVICE_T *user_service;
1347 + VCHIQ_BULK_DIR_T dir =
1348 + (cmd == VCHIQ_IOC_QUEUE_BULK_TRANSMIT) ?
1349 + VCHIQ_BULK_TRANSMIT : VCHIQ_BULK_RECEIVE;
1350 +
1351 + if (copy_from_user
1352 + (&args, (const void __user *)arg,
1353 + sizeof(args)) != 0) {
1354 + ret = -EFAULT;
1355 + break;
1356 + }
1357 + user_service = find_service_by_handle(instance, args.handle);
1358 + if (user_service != NULL)
1359 + {
1360 + status =
1361 + vchiq_bulk_transfer
1362 + ((VCHIQ_SERVICE_T *)user_service->service,
1363 + VCHI_MEM_HANDLE_INVALID,
1364 + args.data, args.size,
1365 + args.userdata, args.mode,
1366 + dir);
1367 + } else {
1368 + ret = -EINVAL;
1369 + }
1370 + }
1371 + break;
1372 +
1373 + case VCHIQ_IOC_AWAIT_COMPLETION:
1374 + {
1375 + VCHIQ_AWAIT_COMPLETION_T args;
1376 +
1377 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1378 + if (!instance->connected) {
1379 + ret = -ENOTCONN;
1380 + break;
1381 + }
1382 +
1383 + if (copy_from_user
1384 + (&args, (const void __user *)arg,
1385 + sizeof(args)) != 0) {
1386 + ret = -EFAULT;
1387 + break;
1388 + }
1389 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1390 + while ((instance->completion_remove ==
1391 + instance->completion_insert)
1392 + && !instance->closing) {
1393 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1394 + if (vcos_event_wait(&instance->insert_event) !=
1395 + VCOS_SUCCESS) {
1396 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1397 + vcos_log_info
1398 + ("AWAIT_COMPLETION interrupted");
1399 + ret = -EINTR;
1400 + break;
1401 + }
1402 + }
1403 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1404 +
1405 + /* A read memory barrier is needed to stop prefetch of a stale
1406 + completion record */
1407 + vcos_rmb();
1408 +
1409 + if (ret == 0) {
1410 + int msgbufcount = args.msgbufcount;
1411 + for (ret = 0; ret < args.count; ret++) {
1412 + VCHIQ_COMPLETION_DATA_T *completion;
1413 + USER_SERVICE_T *service;
1414 + VCHIQ_HEADER_T *header;
1415 + if (instance->completion_remove ==
1416 + instance->completion_insert)
1417 + break;
1418 + completion =
1419 + &instance->
1420 + completions
1421 + [instance->completion_remove &
1422 + (MAX_COMPLETIONS - 1)];
1423 +
1424 + service = (USER_SERVICE_T *)completion->service_userdata;
1425 + completion->service_userdata = service->userdata;
1426 +
1427 + header = completion->header;
1428 + if (header)
1429 + {
1430 + void __user *msgbuf;
1431 + int msglen;
1432 +
1433 + msglen = header->size + sizeof(VCHIQ_HEADER_T);
1434 + /* This must be a VCHIQ-style service */
1435 + if (args.msgbufsize < msglen)
1436 + {
1437 + vcos_log_error("header %x: msgbufsize %x < msglen %x",
1438 + (unsigned int)header, args.msgbufsize, msglen);
1439 + vcos_assert(0);
1440 + if (ret == 0)
1441 + ret = -EMSGSIZE;
1442 + break;
1443 + }
1444 + if (msgbufcount <= 0)
1445 + {
1446 + /* Stall here for lack of a buffer for the message */
1447 + break;
1448 + }
1449 + /* Get the pointer from user space */
1450 + msgbufcount--;
1451 + if (copy_from_user(&msgbuf,
1452 + (const void __user *)&args.msgbufs[msgbufcount],
1453 + sizeof(msgbuf)) != 0)
1454 + {
1455 + if (ret == 0)
1456 + ret = -EFAULT;
1457 + break;
1458 + }
1459 +
1460 + /* Copy the message to user space */
1461 + if (copy_to_user(msgbuf, header, msglen) != 0)
1462 + {
1463 + if (ret == 0)
1464 + ret = -EFAULT;
1465 + break;
1466 + }
1467 +
1468 + /* Now it has been copied, the message can be released. */
1469 + vchiq_release_message(&service->service->base, header);
1470 +
1471 + /* The completion must point to the msgbuf */
1472 + completion->header = msgbuf;
1473 + }
1474 +
1475 + if (copy_to_user
1476 + ((void __user *)((size_t) args.buf +
1477 + ret *
1478 + sizeof
1479 + (VCHIQ_COMPLETION_DATA_T)),
1480 + completion,
1481 + sizeof(VCHIQ_COMPLETION_DATA_T)) !=
1482 + 0) {
1483 + if (ret == 0)
1484 + ret = -EFAULT;
1485 + break;
1486 + }
1487 + instance->completion_remove++;
1488 + }
1489 +
1490 + if (msgbufcount != args.msgbufcount)
1491 + {
1492 + if (copy_to_user((void __user *)
1493 + &((VCHIQ_AWAIT_COMPLETION_T *)arg)->msgbufcount,
1494 + &msgbufcount, sizeof(msgbufcount)) != 0)
1495 + {
1496 + ret = -EFAULT;
1497 + break;
1498 + }
1499 + }
1500 + }
1501 +
1502 + if (ret != 0)
1503 + vcos_event_signal(&instance->remove_event);
1504 + DEBUG_TRACE(AWAIT_COMPLETION_LINE);
1505 + }
1506 + break;
1507 +
1508 + case VCHIQ_IOC_DEQUEUE_MESSAGE:
1509 + {
1510 + VCHIQ_DEQUEUE_MESSAGE_T args;
1511 + USER_SERVICE_T *user_service;
1512 + VCHIQ_HEADER_T *header;
1513 +
1514 + DEBUG_TRACE(DEQUEUE_MESSAGE_LINE);
1515 + if (copy_from_user
1516 + (&args, (const void __user *)arg,
1517 + sizeof(args)) != 0) {
1518 + ret = -EFAULT;
1519 + break;
1520 + }
1521 + user_service = &instance->services[args.handle];
1522 + if ((args.handle < 0) || (args.handle >= MAX_SERVICES) ||
1523 + (user_service->service == NULL) ||
1524 + (user_service->is_vchi == 0)) {
1525 + ret = -EINVAL;
1526 + break;
1527 + }
1528 + if (user_service->msg_remove == user_service->msg_insert)
1529 + {
1530 + if (!args.blocking)
1531 + {
1532 + DEBUG_TRACE(DEQUEUE_MESSAGE_LINE);
1533 + ret = -EWOULDBLOCK;
1534 + break;
1535 + }
1536 + user_service->dequeue_pending = 1;
1537 + do {
1538 + DEBUG_TRACE(DEQUEUE_MESSAGE_LINE);
1539 + if (vcos_event_wait(&user_service->insert_event) !=
1540 + VCOS_SUCCESS) {
1541 + vcos_log_info("DEQUEUE_MESSAGE interrupted");
1542 + ret = -EINTR;
1543 + break;
1544 + }
1545 + }
1546 + while (user_service->msg_remove == user_service->msg_insert);
1547 + }
1548 +
1549 + /* A read memory barrier is needed to stop prefetch of a stale
1550 + header value */
1551 + vcos_rmb();
1552 +
1553 + header = user_service->msg_queue[user_service->msg_remove &
1554 + (MSG_QUEUE_SIZE - 1)];
1555 + if (header == NULL)
1556 + ret = -ENOTCONN;
1557 + else if (header->size <= args.bufsize)
1558 + {
1559 + /* Copy to user space if msgbuf is not NULL */
1560 + if ((args.buf == NULL) ||
1561 + (copy_to_user((void __user *)args.buf, header->data,
1562 + header->size) == 0))
1563 + {
1564 + ret = header->size;
1565 + vchiq_release_message(&user_service->service->base,
1566 + header);
1567 + user_service->msg_remove++;
1568 + vcos_event_signal(&user_service->remove_event);
1569 + }
1570 + else
1571 + ret = -EFAULT;
1572 + }
1573 + else
1574 + {
1575 + vcos_log_error("header %x: bufsize %x < size %x",
1576 + (unsigned int)header, args.bufsize, header->size);
1577 + vcos_assert(0);
1578 + ret = -EMSGSIZE;
1579 + }
1580 + DEBUG_TRACE(DEQUEUE_MESSAGE_LINE);
1581 + }
1582 + break;
1583 +
1584 + case VCHIQ_IOC_GET_CLIENT_ID:
1585 + {
1586 + USER_SERVICE_T *user_service;
1587 + int handle = (int)arg;
1588 +
1589 + user_service = find_service_by_handle(instance, handle);
1590 + if (user_service != NULL)
1591 + ret = vchiq_get_client_id(&user_service->service->base);
1592 + else
1593 + ret = 0;
1594 + }
1595 + break;
1596 +
1597 + case VCHIQ_IOC_GET_CONFIG:
1598 + {
1599 + VCHIQ_GET_CONFIG_T args;
1600 + VCHIQ_CONFIG_T config;
1601 +
1602 + if (copy_from_user
1603 + (&args, (const void __user *)arg,
1604 + sizeof(args)) != 0) {
1605 + ret = -EFAULT;
1606 + break;
1607 + }
1608 + if (args.config_size > sizeof(config))
1609 + {
1610 + ret = -EINVAL;
1611 + break;
1612 + }
1613 + status = vchiq_get_config(instance, args.config_size, &config);
1614 + if (status == VCHIQ_SUCCESS)
1615 + {
1616 + if (copy_to_user((void __user *)args.pconfig,
1617 + &config, args.config_size) != 0)
1618 + {
1619 + ret = -EFAULT;
1620 + break;
1621 + }
1622 + }
1623 + }
1624 + break;
1625 +
1626 + case VCHIQ_IOC_SET_SERVICE_OPTION:
1627 + {
1628 + VCHIQ_SET_SERVICE_OPTION_T args;
1629 + USER_SERVICE_T *user_service;
1630 +
1631 + if (copy_from_user(
1632 + &args, (const void __user *)arg,
1633 + sizeof(args)) != 0)
1634 + {
1635 + ret = -EFAULT;
1636 + break;
1637 + }
1638 +
1639 + user_service = find_service_by_handle(instance, args.handle);
1640 + if (user_service != NULL)
1641 + {
1642 + status = vchiq_set_service_option(
1643 + &user_service->service->base,
1644 + args.option, args.value);
1645 + }
1646 + else
1647 + {
1648 + ret = -EINVAL;
1649 + }
1650 + }
1651 + break;
1652 +
1653 + default:
1654 + ret = -ENOTTY;
1655 + break;
1656 + }
1657 +
1658 + if (ret == 0) {
1659 + if (status == VCHIQ_ERROR)
1660 + ret = -EIO;
1661 + else if (status == VCHIQ_RETRY)
1662 + ret = -EINTR;
1663 + }
1664 +
1665 + if ((ret < 0) && (ret != -EINTR) && (ret != -EWOULDBLOCK))
1666 + vcos_log_warn(" ioctl instance %lx, cmd %s -> status %d, %ld",
1667 + (unsigned long)instance,
1668 + (_IOC_NR(cmd) <= VCHIQ_IOC_MAX) ? ioctl_names[_IOC_NR(cmd)] :
1669 + "<invalid>", status, ret);
1670 + else
1671 + vcos_log_trace(" ioctl instance %lx, cmd %s -> status %d, %ld",
1672 + (unsigned long)instance,
1673 + (_IOC_NR(cmd) <= VCHIQ_IOC_MAX) ? ioctl_names[_IOC_NR(cmd)] :
1674 + "<invalid>", status, ret);
1675 +
1676 + return ret;
1677 +}
1678 +
1679 +/****************************************************************************
1680 +*
1681 +* vchiq_open
1682 +*
1683 +***************************************************************************/
1684 +
1685 +static int
1686 +vchiq_open(struct inode *inode, struct file *file)
1687 +{
1688 + int dev = iminor(inode) & 0x0f;
1689 + vcos_log_info("vchiq_open");
1690 + switch (dev) {
1691 + case VCHIQ_MINOR:
1692 + {
1693 + VCHIQ_STATE_T *state = vchiq_get_state();
1694 + VCHIQ_INSTANCE_T instance;
1695 +
1696 + if (!state)
1697 + {
1698 + vcos_log_error( "vchiq has no connection to VideoCore");
1699 + return -ENOTCONN;
1700 + }
1701 +
1702 + instance = kzalloc(sizeof(*instance), GFP_KERNEL);
1703 + if (!instance)
1704 + return -ENOMEM;
1705 +
1706 + instance->state = state;
1707 + instance->pid = current->tgid;
1708 + vcos_event_create(&instance->insert_event, DEVICE_NAME);
1709 + vcos_event_create(&instance->remove_event, DEVICE_NAME);
1710 +
1711 + file->private_data = instance;
1712 + }
1713 + break;
1714 +
1715 + default:
1716 + vcos_log_error("Unknown minor device: %d", dev);
1717 + return -ENXIO;
1718 + }
1719 +
1720 + return 0;
1721 +}
1722 +
1723 +/****************************************************************************
1724 +*
1725 +* vchiq_release
1726 +*
1727 +***************************************************************************/
1728 +
1729 +static int
1730 +vchiq_release(struct inode *inode, struct file *file)
1731 +{
1732 + int dev = iminor(inode) & 0x0f;
1733 + int ret = 0;
1734 + switch (dev) {
1735 + case VCHIQ_MINOR:
1736 + {
1737 + VCHIQ_INSTANCE_T instance = file->private_data;
1738 + int i;
1739 +
1740 + vcos_log_info("vchiq_release: instance=%lx",
1741 + (unsigned long)instance);
1742 +
1743 + instance->closing = 1;
1744 +
1745 + /* Wake the slot handler if the completion queue is full */
1746 + vcos_event_signal(&instance->remove_event);
1747 +
1748 + /* Mark all services for termination... */
1749 +
1750 + for (i = 0; i < MAX_SERVICES; i++) {
1751 + USER_SERVICE_T *user_service =
1752 + &instance->services[i];
1753 + if (user_service->service != NULL)
1754 + {
1755 + /* Wake the slot handler if the msg queue is full */
1756 + vcos_event_signal(&user_service->remove_event);
1757 +
1758 + if ((user_service->service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT) &&
1759 + (user_service->service->srvstate != VCHIQ_SRVSTATE_LISTENING))
1760 + {
1761 + vchiq_terminate_service_internal(user_service->service);
1762 + }
1763 + }
1764 + }
1765 +
1766 + /* ...and wait for them to die */
1767 +
1768 + for (i = 0; i < MAX_SERVICES; i++) {
1769 + USER_SERVICE_T *user_service =
1770 + &instance->services[i];
1771 + if (user_service->service != NULL)
1772 + {
1773 + /* Wait in this non-portable fashion because interruptible
1774 + calls will not block in this context. */
1775 + while ((user_service->service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT) &&
1776 + (user_service->service->srvstate != VCHIQ_SRVSTATE_LISTENING))
1777 + {
1778 + down(&user_service->service->remove_event);
1779 + }
1780 +
1781 + vchiq_free_service_internal
1782 + (user_service->service);
1783 + }
1784 + }
1785 +
1786 + vcos_event_delete(&instance->insert_event);
1787 + vcos_event_delete(&instance->remove_event);
1788 +
1789 + kfree(instance);
1790 + file->private_data = NULL;
1791 + }
1792 + break;
1793 +
1794 + default:
1795 + vcos_log_error("Unknown minor device: %d", dev);
1796 + ret = -ENXIO;
1797 + }
1798 +
1799 + return ret;
1800 +}
1801 +
1802 +/****************************************************************************
1803 +*
1804 +* vchiq_dump
1805 +*
1806 +***************************************************************************/
1807 +
1808 +void
1809 +vchiq_dump(void *dump_context, const char *str, int len)
1810 +{
1811 + DUMP_CONTEXT_T *context = (DUMP_CONTEXT_T *)dump_context;
1812 +
1813 + if ((context->actual >= 0) && (context->actual < context->space))
1814 + {
1815 + int copy_bytes;
1816 + if (context->offset > 0)
1817 + {
1818 + int skip_bytes = vcos_min(len, context->offset);
1819 + str += skip_bytes;
1820 + len -= skip_bytes;
1821 + context->offset -= skip_bytes;
1822 + if (context->offset > 0)
1823 + return;
1824 + }
1825 + copy_bytes = vcos_min(len, context->space - context->actual);
1826 + if (copy_bytes == 0)
1827 + return;
1828 + if (copy_to_user(context->buf + context->actual, str, copy_bytes))
1829 + context->actual = -EFAULT;
1830 + context->actual += copy_bytes;
1831 + len -= copy_bytes;
1832 +
1833 + /* If tne terminating NUL is included in the length, then it marks
1834 + * the end of a line and should be replaced with a carriage return.
1835 + */
1836 + if ((len == 0) && (str[copy_bytes - 1] == '\0'))
1837 + {
1838 + char cr = '\n';
1839 + if (copy_to_user(context->buf + context->actual - 1, &cr, 1))
1840 + {
1841 + context->actual = -EFAULT;
1842 + }
1843 + }
1844 + }
1845 +}
1846 +
1847 +/****************************************************************************
1848 +*
1849 +* vchiq_dump_platform_instance_state
1850 +*
1851 +***************************************************************************/
1852 +
1853 +void
1854 +vchiq_dump_platform_instances(void *dump_context)
1855 +{
1856 + VCHIQ_STATE_T *state = vchiq_get_state();
1857 + char buf[80];
1858 + int len;
1859 + int i;
1860 +
1861 + /* There is no list of instances, so instead scan all services,
1862 + marking those that have been dumped. */
1863 +
1864 + for (i = 0; i < state->unused_service; i++)
1865 + {
1866 + VCHIQ_SERVICE_T *service = state->services[i];
1867 + VCHIQ_INSTANCE_T instance;
1868 +
1869 + if (service
1870 + && ((instance = service->instance) != NULL)
1871 + && (service->base.callback == service_callback))
1872 + instance->mark = 0;
1873 + }
1874 +
1875 + for (i = 0; i < state->unused_service; i++)
1876 + {
1877 + VCHIQ_SERVICE_T *service = state->services[i];
1878 + VCHIQ_INSTANCE_T instance;
1879 +
1880 + if (service
1881 + && ((instance = service->instance) != NULL)
1882 + && (service->base.callback == service_callback))
1883 + {
1884 + if (!instance->mark)
1885 + {
1886 + len = vcos_snprintf(buf, sizeof(buf),
1887 + "Instance %x: pid %d,%s completions %d/%d",
1888 + (unsigned int)instance, instance->pid,
1889 + instance->connected ? " connected," : "",
1890 + instance->completion_insert - instance->completion_remove,
1891 + MAX_COMPLETIONS);
1892 +
1893 + vchiq_dump(dump_context, buf, len + 1);
1894 +
1895 + instance->mark = 1;
1896 + }
1897 + }
1898 + }
1899 +}
1900 +
1901 +/****************************************************************************
1902 +*
1903 +* vchiq_dump_platform_service_state
1904 +*
1905 +***************************************************************************/
1906 +
1907 +void
1908 +vchiq_dump_platform_service_state(void *dump_context, VCHIQ_SERVICE_T *service)
1909 +{
1910 + USER_SERVICE_T *user_service = (USER_SERVICE_T *)service->base.userdata;
1911 + char buf[80];
1912 + int len;
1913 +
1914 + len = vcos_snprintf(buf, sizeof(buf), " instance %x",
1915 + service->instance);
1916 +
1917 + if ((service->base.callback == service_callback) && user_service->is_vchi)
1918 + {
1919 + len += vcos_snprintf(buf + len, sizeof(buf) - len,
1920 + ", %d/%d messages",
1921 + user_service->msg_insert - user_service->msg_remove,
1922 + MSG_QUEUE_SIZE);
1923 +
1924 + if (user_service->dequeue_pending)
1925 + len += vcos_snprintf(buf + len, sizeof(buf) - len,
1926 + " (dequeue pending)");
1927 + }
1928 +
1929 + vchiq_dump(dump_context, buf, len + 1);
1930 +}
1931 +
1932 +/****************************************************************************
1933 +*
1934 +* vchiq_read
1935 +*
1936 +***************************************************************************/
1937 +
1938 +static ssize_t
1939 +vchiq_read(struct file * file, char __user * buf,
1940 + size_t count, loff_t *ppos)
1941 +{
1942 + DUMP_CONTEXT_T context;
1943 + context.buf = buf;
1944 + context.actual = 0;
1945 + context.space = count;
1946 + context.offset = *ppos;
1947 +
1948 + vchiq_dump_state(&context, &g_state);
1949 +
1950 + if (context.actual >= 0)
1951 + *ppos += context.actual;
1952 +
1953 + return context.actual;
1954 +}
1955 +
1956 +VCHIQ_STATE_T *
1957 +vchiq_get_state(void)
1958 +{
1959 +
1960 + if (g_state.remote == NULL)
1961 + {
1962 + printk( "%s: g_state.remote == NULL\n", __func__ );
1963 + }
1964 + else
1965 + {
1966 + if ( g_state.remote->initialised != 1)
1967 + {
1968 + printk( "%s: g_state.remote->initialised != 1 (%d)\n", __func__, g_state.remote->initialised );
1969 + }
1970 + }
1971 +
1972 + return ((g_state.remote != NULL) &&
1973 + (g_state.remote->initialised == 1)) ? &g_state : NULL;
1974 +}
1975 +
1976 +static const struct file_operations
1977 +vchiq_fops = {
1978 + .owner = THIS_MODULE,
1979 + .unlocked_ioctl = vchiq_ioctl,
1980 + .open = vchiq_open,
1981 + .release = vchiq_release,
1982 + .read = vchiq_read
1983 +};
1984 +
1985 +/****************************************************************************
1986 +*
1987 +* vchiq_init - called when the module is loaded.
1988 +*
1989 +***************************************************************************/
1990 +
1991 +static int __init
1992 +vchiq_init(void)
1993 +{
1994 + int err;
1995 + void *ptr_err;
1996 +
1997 + err = vchiq_platform_vcos_init();
1998 + if (err != 0)
1999 + goto failed_platform_vcos_init;
2000 +
2001 + vcos_log_set_level(VCOS_LOG_CATEGORY, vchiq_default_arm_log_level);
2002 + vcos_log_register("vchiq_arm", VCOS_LOG_CATEGORY);
2003 +
2004 + if ((err =
2005 + alloc_chrdev_region(&vchiq_devid, VCHIQ_MINOR, 1,
2006 + DEVICE_NAME)) != 0) {
2007 + vcos_log_error("Unable to allocate device number");
2008 + goto failed_alloc_chrdev;
2009 + }
2010 + cdev_init(&vchiq_cdev, &vchiq_fops);
2011 + vchiq_cdev.owner = THIS_MODULE;
2012 + if ((err = cdev_add(&vchiq_cdev, vchiq_devid, 1)) != 0) {
2013 + vcos_log_error("Unable to register device");
2014 + goto failed_cdev_add;
2015 + }
2016 +
2017 + /* create sysfs entries */
2018 + vchiq_class = class_create(THIS_MODULE, DEVICE_NAME);
2019 + if (IS_ERR(ptr_err = vchiq_class))
2020 + goto failed_class_create;
2021 +
2022 + vchiq_dev = device_create(vchiq_class, NULL,
2023 + vchiq_devid, NULL, "vchiq");
2024 + if (IS_ERR(ptr_err = vchiq_dev))
2025 + goto failed_device_create;
2026 +
2027 + err = vchiq_platform_init(&g_state);
2028 + if (err != 0)
2029 + goto failed_platform_init;
2030 +
2031 + vcos_log_error("vchiq: initialised - version %d (min %d), device %d.%d",
2032 + VCHIQ_VERSION, VCHIQ_VERSION_MIN,
2033 + MAJOR(vchiq_devid), MINOR(vchiq_devid));
2034 +
2035 + return 0;
2036 +
2037 +failed_platform_init:
2038 + device_destroy(vchiq_class, vchiq_devid);
2039 +failed_device_create:
2040 + class_destroy(vchiq_class);
2041 +failed_class_create:
2042 + cdev_del(&vchiq_cdev);
2043 + err = PTR_ERR(ptr_err);
2044 +failed_cdev_add:
2045 + unregister_chrdev_region(vchiq_devid, 1);
2046 +failed_alloc_chrdev:
2047 +failed_platform_vcos_init:
2048 + printk(KERN_WARNING "could not load vchiq\n");
2049 + return err;
2050 +}
2051 +/****************************************************************************
2052 +*
2053 +* vchiq_exit - called when the module is unloaded.
2054 +*
2055 +***************************************************************************/
2056 +
2057 +static void __exit
2058 +vchiq_exit(void)
2059 +{
2060 + vchiq_platform_exit(&g_state);
2061 + device_destroy(vchiq_class, vchiq_devid);
2062 + class_destroy(vchiq_class);
2063 + cdev_del(&vchiq_cdev);
2064 + unregister_chrdev_region(vchiq_devid, 1);
2065 + vcos_log_unregister(VCOS_LOG_CATEGORY);
2066 +}
2067 +
2068 +module_init(vchiq_init);
2069 +module_exit(vchiq_exit);
2070 +MODULE_LICENSE("GPL");
2071 +MODULE_AUTHOR("Broadcom Corporation");
2072 --- /dev/null
2073 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_arm.h
2074 @@ -0,0 +1,38 @@
2075 +/*
2076 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
2077 + *
2078 + * This program is free software; you can redistribute it and/or modify
2079 + * it under the terms of the GNU General Public License as published by
2080 + * the Free Software Foundation; either version 2 of the License, or
2081 + * (at your option) any later version.
2082 + *
2083 + * This program is distributed in the hope that it will be useful,
2084 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2085 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2086 + * GNU General Public License for more details.
2087 + *
2088 + * You should have received a copy of the GNU General Public License
2089 + * along with this program; if not, write to the Free Software
2090 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2091 + */
2092 +
2093 +#ifndef VCHIQ_ARM_H
2094 +#define VCHIQ_ARM_H
2095 +
2096 +#include "vchiq_core.h"
2097 +
2098 +extern VCOS_LOG_CAT_T vchiq_arm_log_category;
2099 +
2100 +extern int __init
2101 +vchiq_platform_vcos_init(void);
2102 +
2103 +extern int __init
2104 +vchiq_platform_init(VCHIQ_STATE_T *state);
2105 +
2106 +extern void __exit
2107 +vchiq_platform_exit(VCHIQ_STATE_T *state);
2108 +
2109 +extern VCHIQ_STATE_T *
2110 +vchiq_get_state(void);
2111 +
2112 +#endif /* VCHIQ_ARM_H */
2113 --- /dev/null
2114 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_cfg.h
2115 @@ -0,0 +1,43 @@
2116 +/*
2117 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
2118 + *
2119 + * This program is free software; you can redistribute it and/or modify
2120 + * it under the terms of the GNU General Public License as published by
2121 + * the Free Software Foundation; either version 2 of the License, or
2122 + * (at your option) any later version.
2123 + *
2124 + * This program is distributed in the hope that it will be useful,
2125 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2126 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2127 + * GNU General Public License for more details.
2128 + *
2129 + * You should have received a copy of the GNU General Public License
2130 + * along with this program; if not, write to the Free Software
2131 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2132 + */
2133 +
2134 +#ifndef VCHIQ_CFG_H
2135 +#define VCHIQ_CFG_H
2136 +
2137 +#define VCHIQ_MAGIC VCHIQ_MAKE_FOURCC('V','C','H','I')
2138 +/* The version of VCHIQ - change with any non-trivial change */
2139 +#define VCHIQ_VERSION 2
2140 +/* The minimum compatible version - update to match VCHIQ_VERSION with any incompatible change */
2141 +#define VCHIQ_VERSION_MIN 2
2142 +
2143 +#define VCHIQ_MAX_SERVICES 4096
2144 +#define VCHIQ_MAX_SLOTS 128
2145 +#define VCHIQ_MAX_SLOTS_PER_SIDE 64
2146 +
2147 +#define VCHIQ_NUM_CURRENT_BULKS 32
2148 +#define VCHIQ_NUM_SERVICE_BULKS 4
2149 +
2150 +#ifndef VCHIQ_ENABLE_DEBUG
2151 +#define VCHIQ_ENABLE_DEBUG 1
2152 +#endif
2153 +
2154 +#ifndef VCHIQ_ENABLE_STATS
2155 +#define VCHIQ_ENABLE_STATS 1
2156 +#endif
2157 +
2158 +#endif /* VCHIQ_CFG_H */
2159 --- /dev/null
2160 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_connected.c
2161 @@ -0,0 +1,101 @@
2162 +/*****************************************************************************
2163 +* Copyright 2001 - 2010 Broadcom Corporation. All rights reserved.
2164 +*
2165 +* Unless you and Broadcom execute a separate written software license
2166 +* agreement governing use of this software, this software is licensed to you
2167 +* under the terms of the GNU General Public License version 2, available at
2168 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
2169 +*
2170 +* Notwithstanding the above, under no circumstances may you combine this
2171 +* software in any way with any other Broadcom software provided under a
2172 +* license other than the GPL, without Broadcom's express prior written
2173 +* consent.
2174 +*****************************************************************************/
2175 +
2176 +#include "vcos.h"
2177 +#include "vchiq_connected.h"
2178 +#include <linux/module.h>
2179 +
2180 +#define MAX_CALLBACKS 10
2181 +
2182 +static int g_connected = 0;
2183 +static int g_num_deferred_callbacks;
2184 +static VCHIQ_CONNECTED_CALLBACK_T g_deferred_callback[ MAX_CALLBACKS ];
2185 +static VCOS_ONCE_T g_once_init;
2186 +static VCOS_MUTEX_T g_connected_mutex;
2187 +
2188 +extern VCOS_LOG_CAT_T vchiq_core_log_category;
2189 +#define VCOS_LOG_CATEGORY (&vchiq_core_log_category)
2190 +
2191 +/****************************************************************************
2192 +*
2193 +* Function to initialize our lock.
2194 +*
2195 +***************************************************************************/
2196 +
2197 +static void connected_init( void )
2198 +{
2199 + vcos_mutex_create( &g_connected_mutex, "connected_mutex");
2200 +}
2201 +
2202 +/****************************************************************************
2203 +*
2204 +* This function is used to defer initialization until the vchiq stack is
2205 +* initialized. If the stack is already initialized, then the callback will
2206 +* be made immediately, otherwise it will be deferred until
2207 +* vchiq_call_connected_callbacks is called.
2208 +*
2209 +***************************************************************************/
2210 +
2211 +void vchiq_add_connected_callback( VCHIQ_CONNECTED_CALLBACK_T callback )
2212 +{
2213 + vcos_once( &g_once_init, connected_init );
2214 +
2215 + vcos_mutex_lock( &g_connected_mutex );
2216 +
2217 + if ( g_connected )
2218 + {
2219 + // We're already connected. Call the callback immediately.
2220 +
2221 + callback();
2222 + }
2223 + else
2224 + {
2225 + if ( g_num_deferred_callbacks >= MAX_CALLBACKS )
2226 + {
2227 + vcos_log_error( "There already %d callback registered - please increase MAX_CALLBACKS",
2228 + g_num_deferred_callbacks );
2229 + }
2230 + else
2231 + {
2232 + g_deferred_callback[ g_num_deferred_callbacks ] = callback;
2233 + g_num_deferred_callbacks++;
2234 + }
2235 + }
2236 + vcos_mutex_unlock( &g_connected_mutex );
2237 +}
2238 +
2239 +/****************************************************************************
2240 +*
2241 +* This function is called by the vchiq stack once it has been connected to
2242 +* the videocore and clients can start to use the stack.
2243 +*
2244 +***************************************************************************/
2245 +
2246 +void vchiq_call_connected_callbacks( void )
2247 +{
2248 + int i;
2249 +
2250 + vcos_once( &g_once_init, connected_init );
2251 +
2252 + vcos_mutex_lock( &g_connected_mutex );
2253 + for ( i = 0; i < g_num_deferred_callbacks; i++ )\
2254 + {
2255 + g_deferred_callback[i]();
2256 + }
2257 + g_num_deferred_callbacks = 0;
2258 + g_connected = 1;
2259 + vcos_mutex_unlock( &g_connected_mutex );
2260 +}
2261 +
2262 +EXPORT_SYMBOL( vchiq_add_connected_callback );
2263 --- /dev/null
2264 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_connected.h
2265 @@ -0,0 +1,32 @@
2266 +/*****************************************************************************
2267 +* Copyright 2001 - 2010 Broadcom Corporation. All rights reserved.
2268 +*
2269 +* Unless you and Broadcom execute a separate written software license
2270 +* agreement governing use of this software, this software is licensed to you
2271 +* under the terms of the GNU General Public License version 2, available at
2272 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
2273 +*
2274 +* Notwithstanding the above, under no circumstances may you combine this
2275 +* software in any way with any other Broadcom software provided under a
2276 +* license other than the GPL, without Broadcom's express prior written
2277 +* consent.
2278 +*****************************************************************************/
2279 +
2280 +#ifndef VCHIQ_CONNECTED_H
2281 +#define VCHIQ_CONNECTED_H
2282 +
2283 +/* ---- Include Files ----------------------------------------------------- */
2284 +
2285 +/* ---- Constants and Types ---------------------------------------------- */
2286 +
2287 +typedef void (*VCHIQ_CONNECTED_CALLBACK_T)( void );
2288 +
2289 +/* ---- Variable Externs ------------------------------------------------- */
2290 +
2291 +/* ---- Function Prototypes ---------------------------------------------- */
2292 +
2293 +void vchiq_add_connected_callback( VCHIQ_CONNECTED_CALLBACK_T callback );
2294 +void vchiq_call_connected_callbacks( void );
2295 +
2296 +#endif /* VCHIQ_CONNECTED_H */
2297 +
2298 --- /dev/null
2299 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_core.c
2300 @@ -0,0 +1,2604 @@
2301 +/*
2302 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
2303 + *
2304 + * This program is free software; you can redistribute it and/or modify
2305 + * it under the terms of the GNU General Public License as published by
2306 + * the Free Software Foundation; either version 2 of the License, or
2307 + * (at your option) any later version.
2308 + *
2309 + * This program is distributed in the hope that it will be useful,
2310 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2311 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2312 + * GNU General Public License for more details.
2313 + *
2314 + * You should have received a copy of the GNU General Public License
2315 + * along with this program; if not, write to the Free Software
2316 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2317 + */
2318 +
2319 +#include "vchiq_core.h"
2320 +
2321 +#define VCHIQ_SLOT_HANDLER_STACK 8192
2322 +
2323 +#define SLOT_INFO_FROM_INDEX(state, index) (state->slot_info + (index))
2324 +#define SLOT_DATA_FROM_INDEX(state, index) (state->slot_data + (index))
2325 +#define SLOT_INDEX_FROM_DATA(state, data) (((unsigned int)((char *)data - (char *)state->slot_data)) / VCHIQ_SLOT_SIZE)
2326 +#define SLOT_INDEX_FROM_INFO(state, info) ((unsigned int)(info - state->slot_info))
2327 +#define SLOT_QUEUE_INDEX_FROM_POS(pos) ((int)((unsigned int)(pos) / VCHIQ_SLOT_SIZE))
2328 +
2329 +#define VCOS_LOG_CATEGORY (&vchiq_core_log_category)
2330 +
2331 +#define BULK_INDEX(x) (x & (VCHIQ_NUM_SERVICE_BULKS - 1))
2332 +
2333 +typedef struct bulk_waiter_struct
2334 +{
2335 + VCOS_EVENT_T event;
2336 + int actual;
2337 +} BULK_WAITER_T;
2338 +
2339 +typedef struct vchiq_open_payload_struct{
2340 + int fourcc;
2341 + int client_id;
2342 + short version;
2343 + short version_min;
2344 +} VCHIQ_OPEN_PAYLOAD_T;
2345 +
2346 +vcos_static_assert(sizeof(VCHIQ_HEADER_T) == 8); /* we require this for consistency between endpoints */
2347 +vcos_static_assert(IS_POW2(sizeof(VCHIQ_HEADER_T)));
2348 +vcos_static_assert(IS_POW2(VCHIQ_NUM_CURRENT_BULKS));
2349 +vcos_static_assert(IS_POW2(VCHIQ_NUM_SERVICE_BULKS));
2350 +
2351 +VCOS_LOG_CAT_T vchiq_core_log_category;
2352 +VCOS_LOG_CAT_T vchiq_core_msg_log_category;
2353 +VCOS_LOG_LEVEL_T vchiq_default_core_log_level = VCOS_LOG_WARN;
2354 +VCOS_LOG_LEVEL_T vchiq_default_core_msg_log_level = VCOS_LOG_WARN;
2355 +
2356 +static const char *const srvstate_names[] =
2357 +{
2358 + "FREE",
2359 + "HIDDEN",
2360 + "LISTENING",
2361 + "OPENING",
2362 + "OPEN",
2363 + "CLOSESENT",
2364 + "CLOSING",
2365 + "CLOSEWAIT"
2366 +};
2367 +
2368 +static const char *const reason_names[] =
2369 +{
2370 + "SERVICE_OPENED",
2371 + "SERVICE_CLOSED",
2372 + "MESSAGE_AVAILABLE",
2373 + "BULK_TRANSMIT_DONE",
2374 + "BULK_RECEIVE_DONE",
2375 + "BULK_TRANSMIT_ABORTED",
2376 + "BULK_RECEIVE_ABORTED"
2377 +};
2378 +
2379 +static const char *const conn_state_names[] =
2380 +{
2381 + "DISCONNECTED",
2382 + "CONNECTED",
2383 + "PAUSING",
2384 + "PAUSE_SENT",
2385 + "PAUSED",
2386 + "RESUMING"
2387 +};
2388 +
2389 +static const char *msg_type_str( unsigned int msg_type )
2390 +{
2391 + switch (msg_type) {
2392 + case VCHIQ_MSG_PADDING: return "PADDING";
2393 + case VCHIQ_MSG_CONNECT: return "CONNECT";
2394 + case VCHIQ_MSG_OPEN: return "OPEN";
2395 + case VCHIQ_MSG_OPENACK: return "OPENACK";
2396 + case VCHIQ_MSG_CLOSE: return "CLOSE";
2397 + case VCHIQ_MSG_DATA: return "DATA";
2398 + case VCHIQ_MSG_BULK_RX: return "BULK_RX";
2399 + case VCHIQ_MSG_BULK_TX: return "BULK_TX";
2400 + case VCHIQ_MSG_BULK_RX_DONE: return "BULK_RX_DONE";
2401 + case VCHIQ_MSG_BULK_TX_DONE: return "BULK_TX_DONE";
2402 + case VCHIQ_MSG_PAUSE: return "PAUSE";
2403 + case VCHIQ_MSG_RESUME: return "RESUME";
2404 + }
2405 + return "???";
2406 +}
2407 +
2408 +static inline void
2409 +vchiq_set_service_state(VCHIQ_SERVICE_T *service, int newstate)
2410 +{
2411 + vcos_log_info("%d: srv:%d %s->%s", service->state->id, service->localport,
2412 + srvstate_names[service->srvstate],
2413 + srvstate_names[newstate]);
2414 + service->srvstate = newstate;
2415 +}
2416 +
2417 +static inline VCHIQ_STATUS_T
2418 +make_service_callback(VCHIQ_SERVICE_T *service, VCHIQ_REASON_T reason,
2419 + VCHIQ_HEADER_T *header, void *bulk_userdata)
2420 +{
2421 + vcos_log_trace("%d: callback:%d (%s, %x, %x)", service->state->id,
2422 + service->localport, reason_names[reason],
2423 + (unsigned int)header, (unsigned int)bulk_userdata);
2424 + return service->base.callback(reason, header, &service->base, bulk_userdata);
2425 +}
2426 +
2427 +static inline void
2428 +vchiq_set_conn_state(VCHIQ_STATE_T *state, VCHIQ_CONNSTATE_T newstate)
2429 +{
2430 + vcos_log_info("%d: %s->%s", state->id,
2431 + conn_state_names[state->conn_state],
2432 + conn_state_names[newstate]);
2433 + state->conn_state = newstate;
2434 +}
2435 +
2436 +static inline void
2437 +remote_event_create(REMOTE_EVENT_T *event)
2438 +{
2439 + event->armed = 0;
2440 + /* Don't clear the 'fired' flag because it may already have been set by the other side */
2441 + vcos_event_create(event->event, "vchiq");
2442 +}
2443 +
2444 +static inline void
2445 +remote_event_destroy(REMOTE_EVENT_T *event)
2446 +{
2447 + vcos_event_delete(event->event);
2448 +}
2449 +
2450 +static inline int
2451 +remote_event_wait(REMOTE_EVENT_T *event)
2452 +{
2453 + if (!event->fired)
2454 + {
2455 + event->armed = 1;
2456 + if (event->fired) /* Also ensures the write has completed */
2457 + event->armed = 0;
2458 + else if (vcos_event_wait(event->event) != VCOS_SUCCESS)
2459 + return 0;
2460 + }
2461 +
2462 + event->fired = 0;
2463 + return 1;
2464 +}
2465 +
2466 +static inline void
2467 +remote_event_signal_local(REMOTE_EVENT_T *event)
2468 +{
2469 + event->armed = 0;
2470 + vcos_event_signal(event->event);
2471 +}
2472 +
2473 +static inline void
2474 +remote_event_poll(REMOTE_EVENT_T *event)
2475 +{
2476 + if (event->armed)
2477 + remote_event_signal_local(event);
2478 +}
2479 +
2480 +void
2481 +remote_event_pollall(VCHIQ_STATE_T *state)
2482 +{
2483 + remote_event_poll(&state->local->trigger);
2484 + remote_event_poll(&state->local->recycle);
2485 +}
2486 +
2487 +/* Round up message sizes so that any space at the end of a slot is always big
2488 + enough for a header. This relies on header size being a power of two, which
2489 + has been verified earlier by a static assertion. */
2490 +
2491 +static inline unsigned int
2492 +calc_stride(unsigned int size)
2493 +{
2494 + /* Allow room for the header */
2495 + size += sizeof(VCHIQ_HEADER_T);
2496 +
2497 + /* Round up */
2498 + return (size + sizeof(VCHIQ_HEADER_T) - 1) & ~(sizeof(VCHIQ_HEADER_T) - 1);
2499 +}
2500 +
2501 +static VCHIQ_SERVICE_T *
2502 +get_listening_service(VCHIQ_STATE_T *state, int fourcc)
2503 +{
2504 + int i;
2505 +
2506 + vcos_assert(fourcc != VCHIQ_FOURCC_INVALID);
2507 +
2508 + for (i = 0; i < state->unused_service; i++)
2509 + {
2510 + VCHIQ_SERVICE_T *service = state->services[i];
2511 + if (service &&
2512 + (service->public_fourcc == fourcc) &&
2513 + ((service->srvstate == VCHIQ_SRVSTATE_LISTENING) ||
2514 + ((service->srvstate == VCHIQ_SRVSTATE_OPEN) &&
2515 + (service->remoteport == VCHIQ_PORT_FREE))))
2516 + return service;
2517 + }
2518 +
2519 + return NULL;
2520 +}
2521 +
2522 +static VCHIQ_SERVICE_T *
2523 +get_connected_service(VCHIQ_STATE_T *state, unsigned int port)
2524 +{
2525 + int i;
2526 + for (i = 0; i < state->unused_service; i++) {
2527 + VCHIQ_SERVICE_T *service = state->services[i];
2528 + if (service && (service->srvstate == VCHIQ_SRVSTATE_OPEN)
2529 + && (service->remoteport == port)) {
2530 + return service;
2531 + }
2532 + }
2533 + return NULL;
2534 +}
2535 +
2536 +static inline void
2537 +request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type)
2538 +{
2539 + if (service)
2540 + {
2541 + vcos_atomic_flags_or(&service->poll_flags, (1 << poll_type));
2542 + vcos_atomic_flags_or(&state->poll_services[service->localport>>5],
2543 + (1 <<(service->localport & 0x1f)));
2544 + }
2545 +
2546 + state->poll_needed = 1;
2547 + vcos_wmb(&state->poll_needed);
2548 +
2549 + /* ... and ensure the slot handler runs. */
2550 + remote_event_signal_local(&state->local->trigger);
2551 +}
2552 +
2553 +/* Called from queue_message, by the slot handler and application threads,
2554 + with slot_mutex held */
2555 +static VCHIQ_HEADER_T *
2556 +reserve_space(VCHIQ_STATE_T *state, int space, int is_blocking)
2557 +{
2558 + VCHIQ_SHARED_STATE_T *local = state->local;
2559 + int tx_pos = state->local_tx_pos;
2560 + int slot_space = VCHIQ_SLOT_SIZE - (tx_pos & VCHIQ_SLOT_MASK);
2561 +
2562 + if (space > slot_space) {
2563 + VCHIQ_HEADER_T *header;
2564 + /* Fill the remaining space with padding */
2565 + vcos_assert(state->tx_data != NULL);
2566 + header = (VCHIQ_HEADER_T *) (state->tx_data + (tx_pos & VCHIQ_SLOT_MASK));
2567 + header->msgid = VCHIQ_MSGID_PADDING;
2568 + header->size = slot_space - sizeof(VCHIQ_HEADER_T);
2569 +
2570 + tx_pos += slot_space;
2571 + }
2572 +
2573 + /* If necessary, get the next slot. */
2574 + if ((tx_pos & VCHIQ_SLOT_MASK) == 0)
2575 + {
2576 + int slot_index;
2577 +
2578 + /* If there is no free slot... */
2579 + if (tx_pos == (state->slot_queue_available * VCHIQ_SLOT_SIZE))
2580 + {
2581 + /* ...wait for one. */
2582 + VCHIQ_STATS_INC(state, slot_stalls);
2583 +
2584 + /* But first, flush through the last slot. */
2585 + local->tx_pos = tx_pos;
2586 + remote_event_signal(&state->remote->trigger);
2587 +
2588 + do {
2589 + if (!is_blocking ||
2590 + (vcos_event_wait(&state->slot_available_event) != VCOS_SUCCESS))
2591 + {
2592 + return NULL; /* No space available now */
2593 + }
2594 + }
2595 + while (tx_pos == (state->slot_queue_available * VCHIQ_SLOT_SIZE));
2596 + }
2597 +
2598 + slot_index = local->slot_queue[SLOT_QUEUE_INDEX_FROM_POS(tx_pos) & VCHIQ_SLOT_QUEUE_MASK];
2599 + state->tx_data = (char *)SLOT_DATA_FROM_INDEX(state, slot_index);
2600 + }
2601 +
2602 + state->local_tx_pos = tx_pos + space;
2603 +
2604 + return (VCHIQ_HEADER_T *)(state->tx_data + (tx_pos & VCHIQ_SLOT_MASK));
2605 +}
2606 +
2607 +/* Called with slot_mutex held */
2608 +static void
2609 +process_free_queue(VCHIQ_STATE_T *state)
2610 +{
2611 + VCHIQ_SHARED_STATE_T *local = state->local;
2612 + BITSET_T service_found[BITSET_SIZE(VCHIQ_MAX_SERVICES)];
2613 + int slot_queue_available;
2614 +
2615 + /* Use a read memory barrier to ensure that any state that may have
2616 + been modified by another thread is not masked by stale prefetched
2617 + values. */
2618 + vcos_rmb();
2619 +
2620 + /* Find slots which have been freed by the other side, and return them to
2621 + the available queue. */
2622 + slot_queue_available = state->slot_queue_available;
2623 +
2624 + while (slot_queue_available != local->slot_queue_recycle)
2625 + {
2626 + int pos;
2627 + int slot_index = local->slot_queue[slot_queue_available++ & VCHIQ_SLOT_QUEUE_MASK];
2628 + char *data = (char *)SLOT_DATA_FROM_INDEX(state, slot_index);
2629 +
2630 + vcos_log_trace("%d: pfq %d=%x %x %x", state->id, slot_index,
2631 + (unsigned int)data, local->slot_queue_recycle,
2632 + slot_queue_available);
2633 +
2634 + /* Initialise the bitmask for services which have used this slot */
2635 + BITSET_ZERO(service_found);
2636 +
2637 + pos = 0;
2638 +
2639 + while (pos < VCHIQ_SLOT_SIZE)
2640 + {
2641 + VCHIQ_HEADER_T *header = (VCHIQ_HEADER_T *)(data + pos);
2642 + int msgid = header->msgid;
2643 + if (VCHIQ_MSG_TYPE(msgid) == VCHIQ_MSG_DATA)
2644 + {
2645 + int port = VCHIQ_MSG_SRCPORT(msgid);
2646 + if (!BITSET_IS_SET(service_found, port))
2647 + {
2648 + VCHIQ_SERVICE_QUOTA_T *service_quota =
2649 + &state->service_quotas[port];
2650 +
2651 + /* Set the found bit for this service */
2652 + BITSET_SET(service_found, port);
2653 +
2654 + if (service_quota->slot_use_count > 0)
2655 + {
2656 + service_quota->slot_use_count--;
2657 + /* Signal the service in case it has dropped below its quota */
2658 + vcos_event_signal(&service_quota->quota_event);
2659 + vcos_log_trace("%d: pfq:%d %x@%x - slot_use->%d",
2660 + state->id, port,
2661 + header->size, (unsigned int)header,
2662 + service_quota->slot_use_count);
2663 + }
2664 + else
2665 + {
2666 + vcos_log_error("service %d slot_use_count=%d (header %x,"
2667 + " msgid %x, header->msgid %x, header->size %x)",
2668 + port, service_quota->slot_use_count,
2669 + (unsigned int)header, msgid, header->msgid,
2670 + header->size);
2671 + vcos_assert(0);
2672 + }
2673 + }
2674 + }
2675 +
2676 + pos += calc_stride(header->size);
2677 + if (pos > VCHIQ_SLOT_SIZE)
2678 + {
2679 + vcos_log_error("pos %x: header %x, msgid %x, header->msgid %x, header->size %x",
2680 + pos, (unsigned int)header, msgid, header->msgid, header->size);
2681 + vcos_assert(0);
2682 + }
2683 + }
2684 + }
2685 +
2686 + if (slot_queue_available != state->slot_queue_available)
2687 + {
2688 + state->slot_queue_available = slot_queue_available;
2689 + vcos_wmb(&state->slot_queue_available);
2690 + vcos_event_signal(&state->slot_available_event);
2691 + }
2692 +}
2693 +
2694 +/* Called by the slot handler and application threads */
2695 +static VCHIQ_STATUS_T
2696 +queue_message(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
2697 + int msgid, const VCHIQ_ELEMENT_T *elements,
2698 + int count, int size, int is_blocking)
2699 +{
2700 + VCHIQ_SHARED_STATE_T *local;
2701 + VCHIQ_SERVICE_QUOTA_T *service_quota = NULL;
2702 + VCHIQ_HEADER_T *header;
2703 +
2704 + unsigned int stride;
2705 +
2706 + local = state->local;
2707 +
2708 + stride = calc_stride(size);
2709 +
2710 + vcos_assert(stride <= VCHIQ_SLOT_SIZE);
2711 +
2712 + /* On platforms where vcos_mutex_lock cannot fail, the return will never
2713 + be taken and the compiler may optimise out that code. Let Coverity
2714 + know this is intentional.
2715 + */
2716 + /* coverity[constant_expression_result] */
2717 + if ((VCHIQ_MSG_TYPE(msgid) != VCHIQ_MSG_RESUME) &&
2718 + (vcos_mutex_lock(&state->slot_mutex) != VCOS_SUCCESS))
2719 + return VCHIQ_RETRY;
2720 +
2721 + if (service)
2722 + {
2723 + int tx_end_index = SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos + stride - 1);
2724 +
2725 + if (service->srvstate != VCHIQ_SRVSTATE_OPEN)
2726 + {
2727 + /* The service has been closed, probably while waiting for the mutex */
2728 + vcos_mutex_unlock(&state->slot_mutex);
2729 + return VCHIQ_ERROR;
2730 + }
2731 +
2732 + service_quota = &state->service_quotas[service->localport];
2733 +
2734 + /* ...ensure it doesn't use more than its quota of slots */
2735 + while ((tx_end_index != service_quota->previous_tx_index) &&
2736 + (service_quota->slot_use_count == service_quota->slot_quota))
2737 + {
2738 + vcos_log_trace("%d: qm:%d %s,%x - quota stall",
2739 + state->id, service->localport,
2740 + msg_type_str(VCHIQ_MSG_TYPE(msgid)), size);
2741 + VCHIQ_SERVICE_STATS_INC(service, quota_stalls);
2742 + vcos_mutex_unlock(&state->slot_mutex);
2743 + if (vcos_event_wait(&service_quota->quota_event) != VCOS_SUCCESS)
2744 + return VCHIQ_RETRY;
2745 + if (vcos_mutex_lock(&state->slot_mutex) != VCOS_SUCCESS)
2746 + return VCHIQ_RETRY;
2747 + vcos_assert(service_quota->slot_use_count <= service_quota->slot_quota);
2748 + tx_end_index = SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos + stride - 1);
2749 + }
2750 + }
2751 +
2752 + header = reserve_space(state, stride, is_blocking);
2753 +
2754 + if (!header) {
2755 + if (service)
2756 + VCHIQ_SERVICE_STATS_INC(service, slot_stalls);
2757 + vcos_mutex_unlock(&state->slot_mutex);
2758 + return VCHIQ_RETRY;
2759 + }
2760 +
2761 + if (service) {
2762 + int i, pos;
2763 + int tx_end_index;
2764 +
2765 + vcos_log_info("%d: qm %s@%x,%x (%d->%d)", state->id,
2766 + msg_type_str(VCHIQ_MSG_TYPE(msgid)),
2767 + (unsigned int)header, size,
2768 + VCHIQ_MSG_SRCPORT(msgid),
2769 + VCHIQ_MSG_DSTPORT(msgid));
2770 +
2771 + for (i = 0, pos = 0; i < (unsigned int)count;
2772 + pos += elements[i++].size)
2773 + if (elements[i].size) {
2774 + if (vchiq_copy_from_user
2775 + (header->data + pos, elements[i].data,
2776 + (size_t) elements[i].size) !=
2777 + VCHIQ_SUCCESS) {
2778 + vcos_mutex_unlock(&state->slot_mutex);
2779 + VCHIQ_SERVICE_STATS_INC(service, error_count);
2780 + return VCHIQ_ERROR;
2781 + }
2782 + if (i == 0) {
2783 + vcos_log_dump_mem( &vchiq_core_msg_log_category,
2784 + "Sent", 0, header->data + pos,
2785 + vcos_min( 64, elements[0].size ));
2786 + }
2787 + }
2788 +
2789 + /* If this transmission can't fit in the last slot used by this service... */
2790 + tx_end_index = SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos - 1);
2791 + if (tx_end_index != service_quota->previous_tx_index)
2792 + {
2793 + service_quota->slot_use_count++;
2794 + vcos_log_trace("%d: qm:%d %s,%x - slot_use->%d",
2795 + state->id, service->localport,
2796 + msg_type_str(VCHIQ_MSG_TYPE(msgid)), size,
2797 + service_quota->slot_use_count);
2798 + }
2799 +
2800 + service_quota->previous_tx_index = tx_end_index;
2801 + VCHIQ_SERVICE_STATS_INC(service, ctrl_tx_count);
2802 + VCHIQ_SERVICE_STATS_ADD(service, ctrl_tx_bytes, size);
2803 + } else {
2804 + vcos_log_info("%d: qm %s@%x,%x (%d->%d)", state->id,
2805 + msg_type_str(VCHIQ_MSG_TYPE(msgid)),
2806 + (unsigned int)header, size,
2807 + VCHIQ_MSG_SRCPORT(msgid),
2808 + VCHIQ_MSG_DSTPORT(msgid));
2809 + if (size != 0)
2810 + {
2811 + vcos_assert((count == 1) && (size == elements[0].size));
2812 + memcpy(header->data, elements[0].data, elements[0].size);
2813 + }
2814 + VCHIQ_STATS_INC(state, ctrl_tx_count);
2815 + }
2816 +
2817 + header->msgid = msgid;
2818 + header->size = size;
2819 +
2820 + if (vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO))
2821 + {
2822 + int svc_fourcc;
2823 +
2824 + svc_fourcc = service
2825 + ? service->base.fourcc
2826 + : VCHIQ_MAKE_FOURCC('?','?','?','?');
2827 +
2828 + vcos_log_impl( &vchiq_core_msg_log_category,
2829 + VCOS_LOG_INFO,
2830 + "Sent Msg %s(%u) to %c%c%c%c s:%u d:%d len:%d",
2831 + msg_type_str(VCHIQ_MSG_TYPE(msgid)),
2832 + VCHIQ_MSG_TYPE(msgid),
2833 + VCHIQ_FOURCC_AS_4CHARS(svc_fourcc),
2834 + VCHIQ_MSG_SRCPORT(msgid),
2835 + VCHIQ_MSG_DSTPORT(msgid),
2836 + size );
2837 + }
2838 +
2839 + /* Make the new tx_pos visible to the peer. */
2840 + local->tx_pos = state->local_tx_pos;
2841 + vcos_wmb(&local->tx_pos);
2842 +
2843 + if (VCHIQ_MSG_TYPE(msgid) != VCHIQ_MSG_PAUSE)
2844 + vcos_mutex_unlock(&state->slot_mutex);
2845 +
2846 + remote_event_signal(&state->remote->trigger);
2847 +
2848 + return VCHIQ_SUCCESS;
2849 +}
2850 +
2851 +static inline void
2852 +claim_slot(VCHIQ_SLOT_INFO_T *slot)
2853 +{
2854 + slot->use_count++;
2855 +}
2856 +
2857 +static void
2858 +release_slot(VCHIQ_STATE_T *state, VCHIQ_SLOT_INFO_T *slot_info)
2859 +{
2860 + int release_count;
2861 + vcos_mutex_lock(&state->recycle_mutex);
2862 +
2863 + release_count = slot_info->release_count;
2864 + slot_info->release_count = ++release_count;
2865 +
2866 + if (release_count == slot_info->use_count)
2867 + {
2868 + int slot_queue_recycle;
2869 + /* Add to the freed queue */
2870 +
2871 + /* A read barrier is necessary here to prevent speculative fetches of
2872 + remote->slot_queue_recycle from overtaking the mutex. */
2873 + vcos_rmb();
2874 +
2875 + slot_queue_recycle = state->remote->slot_queue_recycle;
2876 + state->remote->slot_queue[slot_queue_recycle & VCHIQ_SLOT_QUEUE_MASK] =
2877 + SLOT_INDEX_FROM_INFO(state, slot_info);
2878 + state->remote->slot_queue_recycle = slot_queue_recycle + 1;
2879 + vcos_log_info("%d: release_slot %d - recycle->%x",
2880 + state->id, SLOT_INDEX_FROM_INFO(state, slot_info),
2881 + state->remote->slot_queue_recycle);
2882 +
2883 + /* A write barrier is necessary, but remote_event_signal contains one. */
2884 + remote_event_signal(&state->remote->recycle);
2885 + }
2886 +
2887 + vcos_mutex_unlock(&state->recycle_mutex);
2888 +}
2889 +
2890 +/* Called by the slot handler - don't hold the bulk mutex */
2891 +static VCHIQ_STATUS_T
2892 +notify_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue)
2893 +{
2894 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
2895 +
2896 + vcos_log_trace("%d: nb:%d %cx - p=%x rn=%x r=%x",
2897 + service->state->id, service->localport,
2898 + (queue == &service->bulk_tx) ? 't' : 'r',
2899 + queue->process, queue->remote_notify, queue->remove);
2900 +
2901 + if (service->state->is_master)
2902 + {
2903 + while (queue->remote_notify != queue->process)
2904 + {
2905 + VCHIQ_BULK_T *bulk = &queue->bulks[BULK_INDEX(queue->remote_notify)];
2906 + int msgtype = (bulk->dir == VCHIQ_BULK_TRANSMIT) ?
2907 + VCHIQ_MSG_BULK_RX_DONE : VCHIQ_MSG_BULK_TX_DONE;
2908 + int msgid = VCHIQ_MAKE_MSG(msgtype, service->localport, service->remoteport);
2909 + VCHIQ_ELEMENT_T element = { &bulk->actual, 4 };
2910 + /* Only reply to non-dummy bulk requests */
2911 + if (bulk->remote_data)
2912 + {
2913 + status = queue_message(service->state, NULL, msgid, &element, 1, 4, 0);
2914 + if (status != VCHIQ_SUCCESS)
2915 + break;
2916 + }
2917 + queue->remote_notify++;
2918 + }
2919 + }
2920 + else
2921 + {
2922 + queue->remote_notify = queue->process;
2923 + }
2924 +
2925 + if (status == VCHIQ_SUCCESS)
2926 + {
2927 + while (queue->remove != queue->remote_notify)
2928 + {
2929 + VCHIQ_BULK_T *bulk = &queue->bulks[BULK_INDEX(queue->remove)];
2930 +
2931 + /* Only generate callbacks for non-dummy bulk requests */
2932 + if (bulk->data)
2933 + {
2934 + if (bulk->actual != VCHIQ_BULK_ACTUAL_ABORTED)
2935 + {
2936 + if (bulk->dir == VCHIQ_BULK_TRANSMIT)
2937 + {
2938 + VCHIQ_SERVICE_STATS_INC(service, bulk_tx_count);
2939 + VCHIQ_SERVICE_STATS_ADD(service, bulk_tx_bytes, bulk->actual);
2940 + }
2941 + else
2942 + {
2943 + VCHIQ_SERVICE_STATS_INC(service, bulk_rx_count);
2944 + VCHIQ_SERVICE_STATS_ADD(service, bulk_rx_bytes, bulk->actual);
2945 + }
2946 + }
2947 + else
2948 + {
2949 + VCHIQ_SERVICE_STATS_INC(service, bulk_aborted_count);
2950 + }
2951 + if (bulk->mode == VCHIQ_BULK_MODE_BLOCKING)
2952 + {
2953 + BULK_WAITER_T *waiter = (BULK_WAITER_T *)bulk->userdata;
2954 + if (waiter)
2955 + {
2956 + waiter->actual = bulk->actual;
2957 + vcos_event_signal(&waiter->event);
2958 + }
2959 + }
2960 + else if (bulk->mode == VCHIQ_BULK_MODE_CALLBACK)
2961 + {
2962 + VCHIQ_REASON_T reason = (bulk->dir == VCHIQ_BULK_TRANSMIT) ?
2963 + ((bulk->actual == VCHIQ_BULK_ACTUAL_ABORTED) ?
2964 + VCHIQ_BULK_TRANSMIT_ABORTED : VCHIQ_BULK_TRANSMIT_DONE) :
2965 + ((bulk->actual == VCHIQ_BULK_ACTUAL_ABORTED) ?
2966 + VCHIQ_BULK_RECEIVE_ABORTED : VCHIQ_BULK_RECEIVE_DONE);
2967 + status = make_service_callback(service, reason,
2968 + NULL, bulk->userdata);
2969 + if (status == VCHIQ_RETRY)
2970 + break;
2971 + }
2972 + }
2973 +
2974 + queue->remove++;
2975 + vcos_event_signal(&service->bulk_remove_event);
2976 + }
2977 + }
2978 +
2979 + if (status != VCHIQ_SUCCESS)
2980 + request_poll(service->state, service, (queue == &service->bulk_tx) ?
2981 + VCHIQ_POLL_TXNOTIFY : VCHIQ_POLL_RXNOTIFY);
2982 +
2983 + return status;
2984 +}
2985 +
2986 +/* Called by the slot handler thread */
2987 +static void
2988 +poll_services(VCHIQ_STATE_T *state)
2989 +{
2990 + int group, i;
2991 +
2992 + for (group = 0; group < BITSET_SIZE(state->unused_service); group++)
2993 + {
2994 + uint32_t flags;
2995 + flags = vcos_atomic_flags_get_and_clear(&state->poll_services[group]);
2996 + for (i = 0; flags; i++)
2997 + {
2998 + if (flags & (1 << i))
2999 + {
3000 + VCHIQ_SERVICE_T *service = state->services[(group<<5) + i];
3001 + uint32_t service_flags =
3002 + vcos_atomic_flags_get_and_clear(&service->poll_flags);
3003 + if (service_flags & (1 << VCHIQ_POLL_TERMINATE))
3004 + {
3005 + vcos_log_info("%d: ps - terminate %d<->%d", state->id, service->localport, service->remoteport);
3006 + if (vchiq_close_service_internal(service, 0/*!close_recvd*/) != VCHIQ_SUCCESS)
3007 + request_poll(state, service, VCHIQ_POLL_TERMINATE);
3008 + }
3009 + if (service_flags & (1 << VCHIQ_POLL_TXNOTIFY))
3010 + notify_bulks(service, &service->bulk_tx);
3011 + if (service_flags & (1 << VCHIQ_POLL_RXNOTIFY))
3012 + notify_bulks(service, &service->bulk_rx);
3013 + flags &= ~(1 << i);
3014 + }
3015 + }
3016 + }
3017 +}
3018 +
3019 +/* Called by the slot handler or application threads, holding the bulk mutex. */
3020 +static int
3021 +resolve_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue)
3022 +{
3023 + VCHIQ_STATE_T *state = service->state;
3024 + int resolved = 0;
3025 +
3026 + while ((queue->process != queue->local_insert) &&
3027 + (queue->process != queue->remote_insert))
3028 + {
3029 + VCHIQ_BULK_T *bulk = &queue->bulks[BULK_INDEX(queue->process)];
3030 +
3031 + vcos_log_trace("%d: rb:%d %cx - li=%x ri=%x p=%x",
3032 + state->id, service->localport,
3033 + (queue == &service->bulk_tx) ? 't' : 'r',
3034 + queue->local_insert, queue->remote_insert,
3035 + queue->process);
3036 +
3037 + vcos_assert((int)(queue->local_insert - queue->process) > 0);
3038 + vcos_assert((int)(queue->remote_insert - queue->process) > 0);
3039 + vchiq_transfer_bulk(bulk);
3040 +
3041 + if (vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO))
3042 + {
3043 + const char *header = (queue == &service->bulk_tx) ?
3044 + "Send Bulk to" : "Recv Bulk from";
3045 + if (bulk->actual != VCHIQ_BULK_ACTUAL_ABORTED)
3046 + vcos_log_impl( &vchiq_core_msg_log_category,
3047 + VCOS_LOG_INFO,
3048 + "%s %c%c%c%c d:%d len:%d %x<->%x",
3049 + header,
3050 + VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
3051 + service->remoteport,
3052 + bulk->size,
3053 + (unsigned int)bulk->data,
3054 + (unsigned int)bulk->remote_data );
3055 + else
3056 + vcos_log_impl( &vchiq_core_msg_log_category,
3057 + VCOS_LOG_INFO,
3058 + "%s %c%c%c%c d:%d ABORTED - tx len:%d, rx len:%d %x<->%x",
3059 + header,
3060 + VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
3061 + service->remoteport,
3062 + bulk->size,
3063 + bulk->remote_size,
3064 + (unsigned int)bulk->data,
3065 + (unsigned int)bulk->remote_data );
3066 + }
3067 +
3068 + vchiq_complete_bulk(bulk);
3069 + queue->process++;
3070 + resolved++;
3071 + }
3072 + return resolved;
3073 +}
3074 +
3075 +/* Called with the bulk_mutex held */
3076 +static void
3077 +abort_outstanding_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue)
3078 +{
3079 + int is_tx = (queue == &service->bulk_tx);
3080 + vcos_log_trace("%d: aob:%d %cx - li=%x ri=%x p=%x",
3081 + service->state->id, service->localport, is_tx ? 't' : 'r',
3082 + queue->local_insert, queue->remote_insert, queue->process);
3083 +
3084 + vcos_assert((int)(queue->local_insert - queue->process) >= 0);
3085 + vcos_assert((int)(queue->remote_insert - queue->process) >= 0);
3086 +
3087 + while ((queue->process != queue->local_insert) ||
3088 + (queue->process != queue->remote_insert))
3089 + {
3090 + VCHIQ_BULK_T *bulk = &queue->bulks[BULK_INDEX(queue->process)];
3091 +
3092 + if (queue->process == queue->remote_insert)
3093 + {
3094 + /* fabricate a matching dummy bulk */
3095 + bulk->remote_data = NULL;
3096 + bulk->remote_size = 0;
3097 + queue->remote_insert++;
3098 + }
3099 +
3100 + if (queue->process != queue->local_insert)
3101 + {
3102 + vchiq_complete_bulk(bulk);
3103 +
3104 + if (vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO))
3105 + {
3106 + vcos_log_impl( &vchiq_core_msg_log_category,
3107 + VCOS_LOG_INFO,
3108 + "%s %c%c%c%c d:%d ABORTED - tx len:%d, rx len:%d",
3109 + is_tx ? "Send Bulk to" : "Recv Bulk from",
3110 + VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
3111 + service->remoteport,
3112 + bulk->size,
3113 + bulk->remote_size );
3114 + }
3115 + }
3116 + else
3117 + {
3118 + /* fabricate a matching dummy bulk */
3119 + bulk->data = NULL;
3120 + bulk->size = 0;
3121 + bulk->actual = VCHIQ_BULK_ACTUAL_ABORTED;
3122 + bulk->dir = is_tx ? VCHIQ_BULK_TRANSMIT : VCHIQ_BULK_RECEIVE;
3123 + queue->local_insert++;
3124 + }
3125 +
3126 + queue->process++;
3127 + }
3128 +}
3129 +
3130 +static void
3131 +pause_bulks(VCHIQ_STATE_T *state)
3132 +{
3133 + int i;
3134 +
3135 + /* Block bulk transfers from all services */
3136 + for (i = 0; i < state->unused_service; i++)
3137 + {
3138 + VCHIQ_SERVICE_T *service = state->services[i];
3139 + if (!service || (service->srvstate != VCHIQ_SRVSTATE_OPEN))
3140 + continue;
3141 +
3142 + vcos_log_trace("locking bulk_mutex for service %d", i);
3143 + vcos_mutex_lock(&service->bulk_mutex);
3144 + }
3145 +}
3146 +
3147 +static void
3148 +resume_bulks(VCHIQ_STATE_T *state)
3149 +{
3150 + int i;
3151 +
3152 + /* Poll all services in case any bulk transfers have been
3153 + deferred */
3154 + for (i = 0; i < state->unused_service; i++)
3155 + {
3156 + VCHIQ_SERVICE_T *service = state->services[i];
3157 + if (!service || (service->srvstate != VCHIQ_SRVSTATE_OPEN))
3158 + continue;
3159 +
3160 + if (resolve_bulks(service, &service->bulk_tx))
3161 + request_poll(state, service, VCHIQ_POLL_TXNOTIFY);
3162 + if (resolve_bulks(service, &service->bulk_rx))
3163 + request_poll(state, service, VCHIQ_POLL_RXNOTIFY);
3164 + vcos_log_trace("unlocking bulk_mutex for service %d", i);
3165 + vcos_mutex_unlock(&service->bulk_mutex);
3166 + }
3167 +}
3168 +
3169 +/* Called by the slot handler thread */
3170 +static void
3171 +parse_rx_slots(VCHIQ_STATE_T *state)
3172 +{
3173 + VCHIQ_SHARED_STATE_T *remote = state->remote;
3174 + int tx_pos;
3175 + DEBUG_INITIALISE(state->local)
3176 +
3177 + tx_pos = remote->tx_pos;
3178 +
3179 + while (state->rx_pos != tx_pos) {
3180 + VCHIQ_SERVICE_T *service = NULL;
3181 + VCHIQ_HEADER_T *header;
3182 + int msgid, size;
3183 + int type;
3184 + unsigned int localport, remoteport;
3185 +
3186 + DEBUG_TRACE(PARSE_LINE);
3187 + if (!state->rx_data)
3188 + {
3189 + int rx_index;
3190 + vcos_assert((state->rx_pos & VCHIQ_SLOT_MASK) == 0);
3191 + rx_index = remote->slot_queue[SLOT_QUEUE_INDEX_FROM_POS(state->rx_pos) & VCHIQ_SLOT_QUEUE_MASK];
3192 + state->rx_data = (char *)SLOT_DATA_FROM_INDEX(state, rx_index);
3193 + state->rx_info = SLOT_INFO_FROM_INDEX(state, rx_index);
3194 +
3195 + /* Initialise use_count to one, and increment release_count at the end
3196 + of the slot to avoid releasing the slot prematurely. */
3197 + state->rx_info->use_count = 1;
3198 + state->rx_info->release_count = 0;
3199 + }
3200 +
3201 + header = (VCHIQ_HEADER_T *)(state->rx_data + (state->rx_pos & VCHIQ_SLOT_MASK));
3202 + DEBUG_VALUE(PARSE_HEADER, (int)header);
3203 + msgid = header->msgid;
3204 + DEBUG_VALUE(PARSE_MSGID, msgid);
3205 + size = header->size;
3206 + type = VCHIQ_MSG_TYPE(msgid);
3207 + localport = VCHIQ_MSG_DSTPORT(msgid);
3208 + remoteport = VCHIQ_MSG_SRCPORT(msgid);
3209 +
3210 + if (type != VCHIQ_MSG_DATA)
3211 + {
3212 + VCHIQ_STATS_INC(state, ctrl_rx_count);
3213 + }
3214 +
3215 + switch (type)
3216 + {
3217 + case VCHIQ_MSG_OPENACK:
3218 + case VCHIQ_MSG_CLOSE:
3219 + case VCHIQ_MSG_DATA:
3220 + case VCHIQ_MSG_BULK_RX:
3221 + case VCHIQ_MSG_BULK_TX:
3222 + case VCHIQ_MSG_BULK_RX_DONE:
3223 + case VCHIQ_MSG_BULK_TX_DONE:
3224 + if (localport <= VCHIQ_PORT_MAX)
3225 + {
3226 + service = state->services[localport];
3227 + if (service && (service->srvstate == VCHIQ_SRVSTATE_FREE))
3228 + service = NULL;
3229 + }
3230 + if (!service)
3231 + {
3232 + vcos_log_error(
3233 + "%d: prs %s@%x (%d->%d) - invalid/closed service %d",
3234 + state->id, msg_type_str(type), (unsigned int)header,
3235 + remoteport, localport, localport);
3236 + goto skip_message;
3237 + }
3238 + default:
3239 + break;
3240 + }
3241 +
3242 + if ( vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO))
3243 + {
3244 + int svc_fourcc;
3245 +
3246 + svc_fourcc = service
3247 + ? service->base.fourcc
3248 + : VCHIQ_MAKE_FOURCC('?','?','?','?');
3249 + vcos_log_impl( &vchiq_core_msg_log_category,
3250 + VCOS_LOG_INFO,
3251 + "Rcvd Msg %s(%u) from %c%c%c%c s:%d d:%d len:%d",
3252 + msg_type_str(type), type,
3253 + VCHIQ_FOURCC_AS_4CHARS(svc_fourcc),
3254 + remoteport, localport, size );
3255 + if (size > 0) {
3256 + vcos_log_dump_mem( &vchiq_core_msg_log_category,
3257 + "Rcvd", 0, header->data,
3258 + vcos_min( 64, size ));
3259 + }
3260 + }
3261 +
3262 + if (((unsigned int)header & VCHIQ_SLOT_MASK) + calc_stride(size) > VCHIQ_SLOT_SIZE)
3263 + {
3264 + vcos_log_error("header %x (msgid %x) - size %x too big for slot",
3265 + (unsigned int)header, (unsigned int)msgid, (unsigned int)size);
3266 + vcos_assert(0);
3267 + }
3268 +
3269 + switch (type) {
3270 + case VCHIQ_MSG_OPEN:
3271 + vcos_assert(VCHIQ_MSG_DSTPORT(msgid) == 0);
3272 + if (vcos_verify(size == sizeof(VCHIQ_OPEN_PAYLOAD_T))) {
3273 + const VCHIQ_OPEN_PAYLOAD_T *payload = (VCHIQ_OPEN_PAYLOAD_T *)header->data;
3274 + unsigned int fourcc;
3275 +
3276 + fourcc = payload->fourcc;
3277 + vcos_log_info("%d: prs OPEN@%x (%d->'%c%c%c%c')",
3278 + state->id, (unsigned int)header,
3279 + localport,
3280 + VCHIQ_FOURCC_AS_4CHARS(fourcc));
3281 +
3282 + service = get_listening_service(state, fourcc);
3283 +
3284 + if (service)
3285 + {
3286 + /* A matching service exists */
3287 + short version = payload->version;
3288 + short version_min = payload->version_min;
3289 + if ((service->version < version_min) ||
3290 + (version < service->version_min))
3291 + {
3292 + /* Version mismatch */
3293 + vcos_log_error("%d: service %d (%c%c%c%c) version mismatch -"
3294 + " local (%d, min %d) vs. remote (%d, min %d)",
3295 + state->id, service->localport,
3296 + VCHIQ_FOURCC_AS_4CHARS(fourcc),
3297 + service->version, service->version_min,
3298 + version, version_min);
3299 + goto fail_open;
3300 + }
3301 + if (service->srvstate == VCHIQ_SRVSTATE_LISTENING)
3302 + {
3303 + /* Acknowledge the OPEN */
3304 + if (queue_message(state, NULL,
3305 + VCHIQ_MAKE_MSG(VCHIQ_MSG_OPENACK, service->localport, remoteport),
3306 + NULL, 0, 0, 0) == VCHIQ_RETRY)
3307 + return; /* Bail out if not ready */
3308 +
3309 + /* The service is now open */
3310 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_OPEN);
3311 + }
3312 +
3313 + service->remoteport = remoteport;
3314 + service->client_id = ((int *)header->data)[1];
3315 + if (make_service_callback(service, VCHIQ_SERVICE_OPENED,
3316 + NULL, NULL) == VCHIQ_RETRY)
3317 + {
3318 + /* Bail out if not ready */
3319 + service->remoteport = VCHIQ_PORT_FREE;
3320 + return;
3321 + }
3322 +
3323 + /* Break out, and skip the failure handling */
3324 + break;
3325 + }
3326 + }
3327 + fail_open:
3328 + /* No available service, or an invalid request - send a CLOSE */
3329 + if (queue_message(state, NULL,
3330 + VCHIQ_MAKE_MSG(VCHIQ_MSG_CLOSE, 0, VCHIQ_MSG_SRCPORT(msgid)),
3331 + NULL, 0, 0, 0) == VCHIQ_RETRY)
3332 + return; /* Bail out if not ready */
3333 + break;
3334 + case VCHIQ_MSG_OPENACK:
3335 + {
3336 + vcos_log_info("%d: prs OPENACK@%x (%d->%d)",
3337 + state->id, (unsigned int)header,
3338 + remoteport, localport);
3339 + if (service->srvstate == VCHIQ_SRVSTATE_OPENING) {
3340 + service->remoteport = remoteport;
3341 + vchiq_set_service_state(service,
3342 + VCHIQ_SRVSTATE_OPEN);
3343 + vcos_event_signal(&service->remove_event);
3344 + }
3345 + }
3346 + break;
3347 + case VCHIQ_MSG_CLOSE:
3348 + {
3349 + vcos_assert(size == 0); /* There should be no data */
3350 +
3351 + vcos_log_info("%d: prs CLOSE@%x (%d->%d)",
3352 + state->id, (unsigned int)header,
3353 + remoteport, localport);
3354 +
3355 + if ((service->remoteport != remoteport) &&
3356 + VCHIQ_PORT_IS_VALID(service->remoteport)) {
3357 + /* This could be from a client which hadn't yet received
3358 + the OPENACK - look for the connected service */
3359 + service = get_connected_service(state, remoteport);
3360 + if (!service)
3361 + break;
3362 + }
3363 +
3364 + if (vchiq_close_service_internal(service,
3365 + 1/*close_recvd*/) == VCHIQ_RETRY)
3366 + return; /* Bail out if not ready */
3367 +
3368 + if (vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO))
3369 + {
3370 + vcos_log_impl( &vchiq_core_msg_log_category,
3371 + VCOS_LOG_INFO,
3372 + "Close Service %c%c%c%c s:%u d:%d",
3373 + VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
3374 + service->localport,
3375 + service->remoteport );
3376 + }
3377 + }
3378 + break;
3379 + case VCHIQ_MSG_DATA:
3380 + {
3381 + vcos_log_trace("%d: prs DATA@%x,%x (%d->%d)",
3382 + state->id, (unsigned int)header, size,
3383 + remoteport, localport);
3384 +
3385 + if ((service->remoteport == remoteport)
3386 + && (service->srvstate ==
3387 + VCHIQ_SRVSTATE_OPEN)) {
3388 + header->msgid = msgid | VCHIQ_MSGID_CLAIMED;
3389 + claim_slot(state->rx_info);
3390 + DEBUG_TRACE(PARSE_LINE);
3391 + if (make_service_callback(service,
3392 + VCHIQ_MESSAGE_AVAILABLE, header,
3393 + NULL) == VCHIQ_RETRY)
3394 + {
3395 + DEBUG_TRACE(PARSE_LINE);
3396 + return; /* Bail out if not ready */
3397 + }
3398 + VCHIQ_SERVICE_STATS_INC(service, ctrl_rx_count);
3399 + VCHIQ_SERVICE_STATS_ADD(service, ctrl_rx_bytes, size);
3400 + }
3401 + else
3402 + {
3403 + VCHIQ_STATS_INC(state, error_count);
3404 + }
3405 + }
3406 + break;
3407 + case VCHIQ_MSG_CONNECT:
3408 + vcos_log_info("%d: prs CONNECT@%x",
3409 + state->id, (unsigned int)header);
3410 + vcos_event_signal(&state->connect);
3411 + break;
3412 + case VCHIQ_MSG_BULK_RX:
3413 + case VCHIQ_MSG_BULK_TX:
3414 + {
3415 + VCHIQ_BULK_QUEUE_T *queue;
3416 + vcos_assert(state->is_master);
3417 + queue = (type == VCHIQ_MSG_BULK_RX) ?
3418 + &service->bulk_tx : &service->bulk_rx;
3419 + if ((service->remoteport == remoteport)
3420 + && (service->srvstate ==
3421 + VCHIQ_SRVSTATE_OPEN))
3422 + {
3423 + VCHIQ_BULK_T *bulk;
3424 + int resolved;
3425 +
3426 + vcos_assert(queue->remote_insert < queue->remove +
3427 + VCHIQ_NUM_SERVICE_BULKS);
3428 + bulk = &queue->bulks[BULK_INDEX(queue->remote_insert)];
3429 + bulk->remote_data = (void *)((int *)header->data)[0];
3430 + bulk->remote_size = ((int *)header->data)[1];
3431 +
3432 + vcos_log_info("%d: prs %s@%x (%d->%d) %x@%x",
3433 + state->id, msg_type_str(type),
3434 + (unsigned int)header,
3435 + remoteport, localport,
3436 + bulk->remote_size,
3437 + (unsigned int)bulk->remote_data);
3438 +
3439 + queue->remote_insert++;
3440 +
3441 + if (state->conn_state != VCHIQ_CONNSTATE_CONNECTED)
3442 + break;
3443 +
3444 + DEBUG_TRACE(PARSE_LINE);
3445 + if (vcos_mutex_lock(&service->bulk_mutex) != VCOS_SUCCESS)
3446 + {
3447 + DEBUG_TRACE(PARSE_LINE);
3448 + return;
3449 + }
3450 + DEBUG_TRACE(PARSE_LINE);
3451 + resolved = resolve_bulks(service, queue);
3452 + vcos_mutex_unlock(&service->bulk_mutex);
3453 + if (resolved)
3454 + notify_bulks(service, queue);
3455 + }
3456 + }
3457 + break;
3458 + case VCHIQ_MSG_BULK_RX_DONE:
3459 + case VCHIQ_MSG_BULK_TX_DONE:
3460 + {
3461 + vcos_assert(!state->is_master);
3462 + if ((service->remoteport == remoteport)
3463 + && (service->srvstate !=
3464 + VCHIQ_SRVSTATE_FREE)) {
3465 + VCHIQ_BULK_QUEUE_T *queue;
3466 + VCHIQ_BULK_T *bulk;
3467 +
3468 + queue = (type == VCHIQ_MSG_BULK_RX_DONE) ?
3469 + &service->bulk_rx : &service->bulk_tx;
3470 +
3471 + bulk = &queue->bulks[BULK_INDEX(queue->process)];
3472 + bulk->actual = *(int *)header->data;
3473 +
3474 + vcos_log_info("%d: prs %s@%x (%d->%d) %x@%x",
3475 + state->id, msg_type_str(type),
3476 + (unsigned int)header,
3477 + remoteport, localport,
3478 + bulk->actual, (unsigned int)bulk->data);
3479 +
3480 + vcos_log_trace("%d: prs:%d %cx li=%x ri=%x p=%x",
3481 + state->id, localport,
3482 + (type == VCHIQ_MSG_BULK_RX_DONE) ? 'r' : 't',
3483 + queue->local_insert,
3484 + queue->remote_insert, queue->process);
3485 +
3486 + DEBUG_TRACE(PARSE_LINE);
3487 + if (vcos_mutex_lock(&service->bulk_mutex) != VCOS_SUCCESS)
3488 + {
3489 + DEBUG_TRACE(PARSE_LINE);
3490 + return;
3491 + }
3492 + DEBUG_TRACE(PARSE_LINE);
3493 + vcos_assert(queue->process != queue->local_insert);
3494 + vchiq_complete_bulk(bulk);
3495 + queue->process++;
3496 + vcos_mutex_unlock(&service->bulk_mutex);
3497 + DEBUG_TRACE(PARSE_LINE);
3498 + notify_bulks(service, queue);
3499 + DEBUG_TRACE(PARSE_LINE);
3500 + }
3501 + }
3502 + break;
3503 + case VCHIQ_MSG_PADDING:
3504 + vcos_log_trace("%d: prs PADDING@%x,%x",
3505 + state->id, (unsigned int)header, size);
3506 + break;
3507 + case VCHIQ_MSG_PAUSE:
3508 + /* If initiated, signal the application thread */
3509 + vcos_log_trace("%d: prs PAUSE@%x,%x",
3510 + state->id, (unsigned int)header, size);
3511 + if (state->conn_state != VCHIQ_CONNSTATE_PAUSE_SENT)
3512 + {
3513 + /* Send a PAUSE in response */
3514 + if (queue_message(state, NULL,
3515 + VCHIQ_MAKE_MSG(VCHIQ_MSG_PAUSE, 0, 0),
3516 + NULL, 0, 0, 0) == VCHIQ_RETRY)
3517 + return; /* Bail out if not ready */
3518 + if (state->is_master)
3519 + pause_bulks(state);
3520 + }
3521 + /* At this point slot_mutex is held */
3522 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_PAUSED);
3523 + vchiq_platform_paused(state);
3524 + break;
3525 + case VCHIQ_MSG_RESUME:
3526 + vcos_log_trace("%d: prs RESUME@%x,%x",
3527 + state->id, (unsigned int)header, size);
3528 + /* Release the slot mutex */
3529 + vcos_mutex_unlock(&state->slot_mutex);
3530 + if (state->is_master)
3531 + resume_bulks(state);
3532 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTED);
3533 + vchiq_platform_resumed(state);
3534 + break;
3535 + default:
3536 + vcos_log_error("%d: prs invalid msgid %x@%x,%x",
3537 + state->id, msgid, (unsigned int)header, size);
3538 + vcos_assert(0);
3539 + break;
3540 + }
3541 +
3542 + skip_message:
3543 + state->rx_pos += calc_stride(size);
3544 +
3545 + DEBUG_TRACE(PARSE_LINE);
3546 + /* Perform some housekeeping when the end of the slot is reached. */
3547 + if ((state->rx_pos & VCHIQ_SLOT_MASK) == 0)
3548 + {
3549 + /* Remove the extra reference count. */
3550 + release_slot(state, state->rx_info);
3551 + state->rx_data = NULL;
3552 + }
3553 + }
3554 +}
3555 +
3556 +/* Called by the slot handler thread */
3557 +static void *
3558 +slot_handler_func(void *v)
3559 +{
3560 + VCHIQ_STATE_T *state = (VCHIQ_STATE_T *) v;
3561 + VCHIQ_SHARED_STATE_T *local = state->local;
3562 + DEBUG_INITIALISE(local)
3563 +
3564 + while (1) {
3565 + DEBUG_COUNT(SLOT_HANDLER_COUNT);
3566 + DEBUG_TRACE(SLOT_HANDLER_LINE);
3567 + remote_event_wait(&local->trigger);
3568 +
3569 + vcos_rmb();
3570 +
3571 + DEBUG_TRACE(SLOT_HANDLER_LINE);
3572 + if (state->poll_needed)
3573 + {
3574 + state->poll_needed = 0;
3575 +
3576 + /* Handle service polling and other rare conditions here out
3577 + of the mainline code */
3578 + switch (state->conn_state)
3579 + {
3580 + case VCHIQ_CONNSTATE_CONNECTED:
3581 + /* Poll the services as requested */
3582 + poll_services(state);
3583 + break;
3584 +
3585 + case VCHIQ_CONNSTATE_PAUSING:
3586 + if (queue_message(state, NULL,
3587 + VCHIQ_MAKE_MSG(VCHIQ_MSG_PAUSE, 0, 0), NULL, 0, 0, 0)
3588 + != VCHIQ_RETRY)
3589 + {
3590 + if (state->is_master)
3591 + pause_bulks(state);
3592 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_PAUSE_SENT);
3593 + }
3594 + else
3595 + {
3596 + state->poll_needed = 1; /* Retry later */
3597 + }
3598 + break;
3599 +
3600 + case VCHIQ_CONNSTATE_RESUMING:
3601 + if (queue_message(state, NULL,
3602 + VCHIQ_MAKE_MSG(VCHIQ_MSG_RESUME, 0, 0), NULL, 0, 0, 0)
3603 + != VCHIQ_RETRY)
3604 + {
3605 + if (state->is_master)
3606 + resume_bulks(state);
3607 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTED);
3608 + vchiq_platform_resumed(state);
3609 + }
3610 + else
3611 + {
3612 + /* This should really be impossible, since the PAUSE should
3613 + have flushed through outstanding messages. */
3614 + vcos_log_error("Failed to send RESUME message");
3615 + vcos_demand(0);
3616 + }
3617 + break;
3618 + default:
3619 + break;
3620 + }
3621 + }
3622 +
3623 + DEBUG_TRACE(SLOT_HANDLER_LINE);
3624 + parse_rx_slots(state);
3625 + }
3626 + return NULL;
3627 +}
3628 +
3629 +extern VCHIQ_STATUS_T
3630 +vchiq_platform_suspend(VCHIQ_STATE_T *state);
3631 +
3632 +/* Called by the recycle thread */
3633 +static void *
3634 +recycle_func(void *v)
3635 +{
3636 + VCHIQ_STATE_T *state = (VCHIQ_STATE_T *) v;
3637 + VCHIQ_SHARED_STATE_T *local = state->local;
3638 +
3639 + while (1) {
3640 + remote_event_wait(&local->recycle);
3641 +
3642 + vcos_mutex_lock(&state->slot_mutex);
3643 +
3644 + process_free_queue(state);
3645 +
3646 + vcos_mutex_unlock(&state->slot_mutex);
3647 + }
3648 + return NULL;
3649 +}
3650 +
3651 +/* Called by the lp thread */
3652 +static void *
3653 +lp_func(void *v)
3654 +{
3655 + VCHIQ_STATE_T *state = (VCHIQ_STATE_T *) v;
3656 +
3657 + while (1) {
3658 + vcos_event_wait(&state->lp_evt);
3659 + vcos_mutex_lock(&state->use_count_mutex);
3660 + if (state->videocore_use_count == 0)
3661 + {
3662 + vchiq_platform_suspend(state);
3663 + }
3664 + vcos_mutex_unlock(&state->use_count_mutex);
3665 + }
3666 + return NULL;
3667 +}
3668 +
3669 +static void
3670 +init_bulk_queue(VCHIQ_BULK_QUEUE_T *queue)
3671 +{
3672 + queue->local_insert = 0;
3673 + queue->remote_insert = 0;
3674 + queue->process = 0;
3675 + queue->remote_notify = 0;
3676 + queue->remove = 0;
3677 +}
3678 +
3679 +VCHIQ_SLOT_ZERO_T *
3680 +vchiq_init_slots(void *mem_base, int mem_size)
3681 +{
3682 + int mem_align = (VCHIQ_SLOT_SIZE - (int)mem_base) & VCHIQ_SLOT_MASK;
3683 + VCHIQ_SLOT_ZERO_T *slot_zero = (VCHIQ_SLOT_ZERO_T *)((char *)mem_base + mem_align);
3684 + int num_slots = (mem_size - mem_align)/VCHIQ_SLOT_SIZE;
3685 + int first_data_slot = VCHIQ_SLOT_ZERO_SLOTS;
3686 +
3687 + /* Ensure there is enough memory to run an absolutely minimum system */
3688 + num_slots -= first_data_slot;
3689 +
3690 + if (num_slots < 4)
3691 + {
3692 + vcos_log_error("vchiq_init_slots - insufficient memory %x bytes", mem_size);
3693 + return NULL;
3694 + }
3695 +
3696 + memset(slot_zero, 0, sizeof(VCHIQ_SLOT_ZERO_T));
3697 +
3698 + slot_zero->magic = VCHIQ_MAGIC;
3699 + slot_zero->version = VCHIQ_VERSION;
3700 + slot_zero->version_min = VCHIQ_VERSION_MIN;
3701 + slot_zero->slot_zero_size = sizeof(VCHIQ_SLOT_ZERO_T);
3702 + slot_zero->slot_size = VCHIQ_SLOT_SIZE;
3703 + slot_zero->max_slots = VCHIQ_MAX_SLOTS;
3704 + slot_zero->max_slots_per_side = VCHIQ_MAX_SLOTS_PER_SIDE;
3705 +
3706 + slot_zero->master.slot_first = first_data_slot;
3707 + slot_zero->slave.slot_first = first_data_slot + (num_slots/2);
3708 + slot_zero->master.slot_last = slot_zero->slave.slot_first - 1;
3709 + slot_zero->slave.slot_last = first_data_slot + num_slots - 1;
3710 +
3711 + return slot_zero;
3712 +}
3713 +
3714 +VCHIQ_STATUS_T
3715 +vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero, int is_master)
3716 +{
3717 + VCHIQ_SHARED_STATE_T *local;
3718 + VCHIQ_SHARED_STATE_T *remote;
3719 + VCOS_THREAD_ATTR_T attrs;
3720 + char threadname[10];
3721 + static int id = 0;
3722 + int i;
3723 +
3724 + vcos_log_set_level(&vchiq_core_log_category, vchiq_default_core_log_level);
3725 + vcos_log_set_level(&vchiq_core_msg_log_category, vchiq_default_core_msg_log_level);
3726 + vcos_log_register("vchiq_core", &vchiq_core_log_category);
3727 + vcos_log_register("vchiq_core_msg", &vchiq_core_msg_log_category);
3728 +
3729 + vcos_log_warn( "%s: slot_zero = 0x%08lx, is_master = %d\n", __func__, (unsigned long)slot_zero, is_master );
3730 +
3731 + /* Check the input configuration */
3732 +
3733 + if (slot_zero->magic != VCHIQ_MAGIC)
3734 + {
3735 + vcos_log_error("slot_zero=%x: magic=%x (expected %x)",
3736 + (unsigned int)slot_zero, slot_zero->magic, VCHIQ_MAGIC);
3737 + return VCHIQ_ERROR;
3738 + }
3739 +
3740 + if (slot_zero->version < VCHIQ_VERSION_MIN)
3741 + {
3742 + vcos_log_error("slot_zero=%x: peer_version=%x (minimum %x)",
3743 + (unsigned int)slot_zero, slot_zero->version, VCHIQ_VERSION_MIN);
3744 + return VCHIQ_ERROR;
3745 + }
3746 +
3747 + if (VCHIQ_VERSION < slot_zero->version_min)
3748 + {
3749 + vcos_log_error("slot_zero=%x: version=%x (peer minimum %x)",
3750 + (unsigned int)slot_zero, VCHIQ_VERSION, slot_zero->version_min);
3751 + return VCHIQ_ERROR;
3752 + }
3753 +
3754 + if (slot_zero->slot_zero_size != sizeof(VCHIQ_SLOT_ZERO_T))
3755 + {
3756 + vcos_log_error("slot_zero=%x: slot_zero_size=%x (expected %x)",
3757 + (unsigned int)slot_zero, slot_zero->slot_zero_size, sizeof(VCHIQ_SLOT_ZERO_T));
3758 + return VCHIQ_ERROR;
3759 + }
3760 +
3761 + if (slot_zero->slot_size != VCHIQ_SLOT_SIZE)
3762 + {
3763 + vcos_log_error("slot_zero=%x: slot_size=%d (expected %d",
3764 + (unsigned int)slot_zero, slot_zero->slot_size, VCHIQ_SLOT_SIZE);
3765 + return VCHIQ_ERROR;
3766 + }
3767 +
3768 + if (slot_zero->max_slots != VCHIQ_MAX_SLOTS)
3769 + {
3770 + vcos_log_error("slot_zero=%x: max_slots=%d (expected %d)",
3771 + (unsigned int)slot_zero, slot_zero->max_slots, VCHIQ_MAX_SLOTS);
3772 + return VCHIQ_ERROR;
3773 + }
3774 +
3775 + if (slot_zero->max_slots_per_side != VCHIQ_MAX_SLOTS_PER_SIDE)
3776 + {
3777 + vcos_log_error("slot_zero=%x: max_slots_per_side=%d (expected %d)",
3778 + (unsigned int)slot_zero, slot_zero->max_slots_per_side,
3779 + VCHIQ_MAX_SLOTS_PER_SIDE);
3780 + return VCHIQ_ERROR;
3781 + }
3782 +
3783 + if (is_master)
3784 + {
3785 + local = &slot_zero->master;
3786 + remote = &slot_zero->slave;
3787 + }
3788 + else
3789 + {
3790 + local = &slot_zero->slave;
3791 + remote = &slot_zero->master;
3792 + }
3793 +
3794 + if (local->initialised)
3795 + {
3796 + if (remote->initialised)
3797 + vcos_log_error("vchiq: FATAL: local state has already been initialised");
3798 + else
3799 + vcos_log_error("vchiq: FATAL: master/slave mismatch - two %ss", is_master ? "master" : "slave");
3800 + return VCHIQ_ERROR;
3801 + }
3802 +
3803 + memset(state, 0, sizeof(VCHIQ_STATE_T));
3804 + state->id = id++;
3805 + state->is_master = is_master;
3806 +
3807 + /*
3808 + initialize shared state pointers
3809 + */
3810 +
3811 + state->local = local;
3812 + state->remote = remote;
3813 + state->slot_data = (VCHIQ_SLOT_T *)slot_zero;
3814 +
3815 + /*
3816 + initialize events and mutexes
3817 + */
3818 +
3819 + vcos_event_create(&state->connect, "v.connect");
3820 + vcos_mutex_create(&state->mutex, "v.mutex");
3821 + vcos_event_create(&state->trigger_event, "v.trigger_event");
3822 + vcos_event_create(&state->recycle_event, "v.recycle_event");
3823 +
3824 + vcos_mutex_create(&state->slot_mutex, "v.slot_mutex");
3825 + vcos_mutex_create(&state->recycle_mutex, "v.recycle_mutex");
3826 + vcos_mutex_create(&state->use_count_mutex, "v.use_count_mutex");
3827 + vcos_mutex_create(&state->suspend_resume_mutex, "v.susp_res_mutex");
3828 +
3829 + vcos_event_create(&state->slot_available_event, "v.slot_available_event");
3830 + vcos_event_create(&state->slot_remove_event, "v.slot_remove_event");
3831 +
3832 + state->slot_queue_available = 0;
3833 +
3834 + for (i = 0; i < VCHIQ_MAX_SERVICES; i++)
3835 + {
3836 + VCHIQ_SERVICE_QUOTA_T *service_quota = &state->service_quotas[i];
3837 + vcos_event_create(&service_quota->quota_event, "v.quota_event");
3838 + }
3839 +
3840 + for (i = local->slot_first; i <= local->slot_last; i++)
3841 + {
3842 + local->slot_queue[state->slot_queue_available++] = i;
3843 + }
3844 +
3845 + state->default_slot_quota = state->slot_queue_available/2;
3846 +
3847 + local->trigger.event = &state->trigger_event;
3848 + remote_event_create(&local->trigger);
3849 + local->tx_pos = 0;
3850 +
3851 + local->recycle.event = &state->recycle_event;
3852 + remote_event_create(&local->recycle);
3853 + local->slot_queue_recycle = state->slot_queue_available;
3854 +
3855 + vcos_event_create(&state->lp_evt, "LP_EVT");
3856 +
3857 + local->debug[DEBUG_ENTRIES] = DEBUG_MAX;
3858 +
3859 + /*
3860 + bring up slot handler thread
3861 + */
3862 +
3863 + vcos_thread_attr_init(&attrs);
3864 + vcos_thread_attr_setstacksize(&attrs, VCHIQ_SLOT_HANDLER_STACK);
3865 + vcos_thread_attr_setpriority(&attrs, VCOS_THREAD_PRI_REALTIME);
3866 + vcos_snprintf(threadname, sizeof(threadname), "VCHIQ-%d", state->id);
3867 + if (vcos_thread_create(&state->slot_handler_thread, threadname,
3868 + &attrs, slot_handler_func, state) != VCOS_SUCCESS)
3869 + return VCHIQ_ERROR;
3870 +
3871 + vcos_thread_attr_init(&attrs);
3872 + vcos_thread_attr_setstacksize(&attrs, VCHIQ_SLOT_HANDLER_STACK);
3873 + vcos_thread_attr_setpriority(&attrs, VCOS_THREAD_PRI_REALTIME);
3874 + vcos_snprintf(threadname, sizeof(threadname), "VCHIQr-%d", state->id);
3875 + if (vcos_thread_create(&state->recycle_thread, threadname,
3876 + &attrs, recycle_func, state) != VCOS_SUCCESS)
3877 + return VCHIQ_ERROR;
3878 +
3879 + vcos_thread_attr_init(&attrs);
3880 + vcos_thread_attr_setstacksize(&attrs, VCHIQ_SLOT_HANDLER_STACK);
3881 + vcos_thread_attr_setpriority(&attrs, VCOS_THREAD_PRI_LOWEST);
3882 + vcos_snprintf(threadname, sizeof(threadname), "VCHIQl-%d", state->id);
3883 + if (vcos_thread_create(&state->lp_thread, threadname,
3884 + &attrs, lp_func, state) != VCOS_SUCCESS)
3885 + return VCHIQ_ERROR;
3886 +
3887 + /* Indicate readiness to the other side */
3888 + local->initialised = 1;
3889 +
3890 + return VCHIQ_SUCCESS;
3891 +}
3892 +
3893 +/* Called from application thread when a client or server service is created. */
3894 +VCHIQ_SERVICE_T *
3895 +vchiq_add_service_internal(VCHIQ_STATE_T *state,
3896 + const VCHIQ_SERVICE_PARAMS_T *params, int srvstate,
3897 + VCHIQ_INSTANCE_T instance)
3898 +{
3899 + VCHIQ_SERVICE_T **pservice = NULL;
3900 + VCHIQ_SERVICE_T *service = NULL;
3901 + int i;
3902 +
3903 + /* Prepare to use a previously unused service */
3904 + if (state->unused_service < VCHIQ_MAX_SERVICES)
3905 + {
3906 + pservice = &state->services[state->unused_service];
3907 + }
3908 +
3909 + if (srvstate == VCHIQ_SRVSTATE_OPENING) {
3910 + for (i = 0; i < state->unused_service; i++) {
3911 + VCHIQ_SERVICE_T *srv = state->services[i];
3912 + if (!srv)
3913 + {
3914 + pservice = &state->services[i];
3915 + break;
3916 + }
3917 + if (srv->srvstate == VCHIQ_SRVSTATE_FREE) {
3918 + service = srv;
3919 + break;
3920 + }
3921 + }
3922 + } else {
3923 + for (i = (state->unused_service - 1); i >= 0; i--) {
3924 + VCHIQ_SERVICE_T *srv = state->services[i];
3925 + if (!srv)
3926 + pservice = &state->services[i];
3927 + else if (srv->srvstate == VCHIQ_SRVSTATE_FREE) {
3928 + service = srv;
3929 + } else if ((srv->public_fourcc == params->fourcc) &&
3930 + ((srv->instance != instance)
3931 + || (srv->base.callback != params->callback))) {
3932 + /* There is another server using this fourcc which doesn't match */
3933 + pservice = NULL;
3934 + service = NULL;
3935 + }
3936 + }
3937 + }
3938 +
3939 + if (pservice && !service)
3940 + {
3941 + service = vcos_malloc(sizeof(VCHIQ_SERVICE_T), "VCHIQ service");
3942 + if (service)
3943 + {
3944 + service->srvstate = VCHIQ_SRVSTATE_FREE;
3945 + service->localport = (pservice - state->services);
3946 + vcos_event_create(&service->remove_event, "v.remove_event");
3947 + vcos_event_create(&service->bulk_remove_event, "v.bulk_remove_event");
3948 + vcos_mutex_create(&service->bulk_mutex, "v.bulk_mutex");
3949 + *pservice = service;
3950 + }
3951 + else
3952 + {
3953 + vcos_log_error("vchiq: Out of memory");
3954 + }
3955 + }
3956 +
3957 + if (service) {
3958 + VCHIQ_SERVICE_QUOTA_T *service_quota =
3959 + &state->service_quotas[service->localport];
3960 + if (vcos_is_log_enabled( &vchiq_core_msg_log_category, VCOS_LOG_INFO)) {
3961 + vcos_log_impl( &vchiq_core_msg_log_category,
3962 + VCOS_LOG_INFO,
3963 + "%s Service %c%c%c%c SrcPort:%d",
3964 + ( srvstate == VCHIQ_SRVSTATE_OPENING )
3965 + ? "Open" : "Add",
3966 + VCHIQ_FOURCC_AS_4CHARS(params->fourcc),
3967 + service->localport );
3968 + }
3969 + service->state = state;
3970 + service->base.fourcc = params->fourcc;
3971 + service->base.callback = params->callback;
3972 + service->base.userdata = params->userdata;
3973 + service->version = params->version;
3974 + service->version_min = params->version_min;
3975 + vchiq_set_service_state(service, srvstate);
3976 + service->public_fourcc =
3977 + (srvstate ==
3978 + VCHIQ_SRVSTATE_OPENING) ? VCHIQ_FOURCC_INVALID : params->fourcc;
3979 + service->instance = instance;
3980 + service->remoteport = VCHIQ_PORT_FREE;
3981 + service->client_id = 0;
3982 + service->auto_close = 1;
3983 + service->service_use_count = 0;
3984 + init_bulk_queue(&service->bulk_tx);
3985 + init_bulk_queue(&service->bulk_rx);
3986 + service_quota->slot_quota = state->default_slot_quota;
3987 + if (service_quota->slot_use_count == 0)
3988 + service_quota->previous_tx_index =
3989 + SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos) - 1;
3990 + memset(&service->stats, 0, sizeof(service->stats));
3991 + vcos_atomic_flags_create(&service->poll_flags);
3992 +
3993 + /* Ensure the events are unsignalled */
3994 + while (vcos_event_try(&service->remove_event) == VCOS_SUCCESS)
3995 + continue;
3996 + while (vcos_event_try(&service_quota->quota_event) == VCOS_SUCCESS)
3997 + continue;
3998 +
3999 + if (pservice == &state->services[state->unused_service])
4000 + state->unused_service++;
4001 + }
4002 +
4003 + return service;
4004 +}
4005 +
4006 +VCHIQ_STATUS_T
4007 +vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id)
4008 +{
4009 + VCHIQ_OPEN_PAYLOAD_T payload = {
4010 + service->base.fourcc,
4011 + client_id,
4012 + service->version,
4013 + service->version_min
4014 + };
4015 + VCHIQ_ELEMENT_T body = { &payload, sizeof(payload) };
4016 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4017 +
4018 + service->client_id = client_id;
4019 + vchiq_use_service(&service->base);
4020 + status = queue_message(service->state, NULL,
4021 + VCHIQ_MAKE_MSG(VCHIQ_MSG_OPEN, service->localport, 0),
4022 + &body, 1, sizeof(payload), 1);
4023 + if (status == VCHIQ_SUCCESS) {
4024 + if (vcos_event_wait(&service->remove_event) != VCOS_SUCCESS) {
4025 + status = VCHIQ_RETRY;
4026 + vchiq_release_service(&service->base);
4027 + } else if (service->srvstate != VCHIQ_SRVSTATE_OPEN) {
4028 + vcos_log_info("%d: osi - srvstate = %d", service->state->id, service->srvstate);
4029 + vcos_assert(service->srvstate == VCHIQ_SRVSTATE_CLOSEWAIT);
4030 + status = VCHIQ_ERROR;
4031 + VCHIQ_SERVICE_STATS_INC(service, error_count);
4032 + vchiq_release_service(&service->base);
4033 + }
4034 + }
4035 + return status;
4036 +}
4037 +
4038 +/* Called by the slot handler */
4039 +VCHIQ_STATUS_T
4040 +vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd)
4041 +{
4042 + VCHIQ_STATE_T *state = service->state;
4043 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4044 +
4045 + vcos_log_trace("%d: csi:%d (%s)",
4046 + service->state->id, service->localport,
4047 + srvstate_names[service->srvstate]);
4048 +
4049 + switch (service->srvstate)
4050 + {
4051 + case VCHIQ_SRVSTATE_OPENING:
4052 + if (close_recvd)
4053 + {
4054 + /* The open was rejected - tell the user */
4055 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSEWAIT);
4056 + vcos_event_signal(&service->remove_event);
4057 + }
4058 + else
4059 + {
4060 + /* Shutdown mid-open - let the other side know */
4061 + status = queue_message(state, NULL,
4062 + VCHIQ_MAKE_MSG
4063 + (VCHIQ_MSG_CLOSE,
4064 + service->localport,
4065 + VCHIQ_MSG_DSTPORT(service->remoteport)),
4066 + NULL, 0, 0, 0);
4067 +
4068 + if (status == VCHIQ_SUCCESS)
4069 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSESENT);
4070 + }
4071 + break;
4072 +
4073 + case VCHIQ_SRVSTATE_OPEN:
4074 + if (state->is_master)
4075 + {
4076 + /* Abort any outstanding bulk transfers */
4077 + vcos_mutex_lock(&service->bulk_mutex);
4078 + abort_outstanding_bulks(service, &service->bulk_tx);
4079 + abort_outstanding_bulks(service, &service->bulk_rx);
4080 + status = notify_bulks(service, &service->bulk_tx);
4081 + if (status == VCHIQ_SUCCESS)
4082 + status = notify_bulks(service, &service->bulk_rx);
4083 + vcos_mutex_unlock(&service->bulk_mutex);
4084 + }
4085 +
4086 + if (status == VCHIQ_SUCCESS)
4087 + status = queue_message(state, NULL,
4088 + VCHIQ_MAKE_MSG
4089 + (VCHIQ_MSG_CLOSE,
4090 + service->localport,
4091 + VCHIQ_MSG_DSTPORT(service->remoteport)),
4092 + NULL, 0, 0, 0);
4093 +
4094 + if (status == VCHIQ_SUCCESS)
4095 + {
4096 + if (close_recvd)
4097 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSING);
4098 + else
4099 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSESENT);
4100 + }
4101 + break;
4102 +
4103 + case VCHIQ_SRVSTATE_CLOSESENT:
4104 + vcos_assert(close_recvd);
4105 +
4106 + if (!state->is_master)
4107 + {
4108 + /* Abort any outstanding bulk transfers */
4109 + vcos_mutex_lock(&service->bulk_mutex);
4110 + abort_outstanding_bulks(service, &service->bulk_tx);
4111 + abort_outstanding_bulks(service, &service->bulk_rx);
4112 + status = notify_bulks(service, &service->bulk_tx);
4113 + if (status == VCHIQ_SUCCESS)
4114 + status = notify_bulks(service, &service->bulk_rx);
4115 + vcos_mutex_unlock(&service->bulk_mutex);
4116 + }
4117 +
4118 + if (status == VCHIQ_SUCCESS)
4119 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSING);
4120 + break;
4121 +
4122 + case VCHIQ_SRVSTATE_CLOSING:
4123 + /* We may come here after a retry */
4124 + vcos_assert(!close_recvd);
4125 + break;
4126 +
4127 + default:
4128 + vcos_log_error("vchiq_close_service_internal(%d) called in state %s",
4129 + close_recvd, srvstate_names[service->srvstate]);
4130 + vcos_assert(0);
4131 + break;
4132 + }
4133 +
4134 + if (service->srvstate == VCHIQ_SRVSTATE_CLOSING)
4135 + {
4136 + /* Complete the close process */
4137 + vchiq_release_service(&service->base);
4138 +
4139 + service->client_id = 0;
4140 +
4141 + /* Now tell the client that the services is closed */
4142 + if (service->instance)
4143 + {
4144 + int oldstate = service->srvstate;
4145 +
4146 + /* Change the service state now for the benefit of the callback */
4147 + vchiq_set_service_state(service,
4148 + ((service->public_fourcc == VCHIQ_FOURCC_INVALID) ||
4149 + !service->auto_close) ?
4150 + VCHIQ_SRVSTATE_CLOSEWAIT :
4151 + VCHIQ_SRVSTATE_LISTENING);
4152 +
4153 + status = make_service_callback(service, VCHIQ_SERVICE_CLOSED, NULL, NULL);
4154 +
4155 + if (status == VCHIQ_RETRY)
4156 + {
4157 + /* Restore the old state, to be retried later */
4158 + vchiq_set_service_state(service, oldstate);
4159 + }
4160 + else
4161 + {
4162 + if (status == VCHIQ_ERROR) {
4163 + /* Signal an error (fatal, since the other end will probably have closed) */
4164 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_OPEN);
4165 + }
4166 + }
4167 + }
4168 +
4169 + if (status != VCHIQ_RETRY)
4170 + {
4171 + if (service->srvstate == VCHIQ_SRVSTATE_CLOSING)
4172 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSEWAIT);
4173 + vcos_event_signal(&service->remove_event);
4174 + }
4175 + }
4176 +
4177 + return status;
4178 +}
4179 +
4180 +/* Called from the application process upon process death */
4181 +void
4182 +vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service)
4183 +{
4184 + VCHIQ_STATE_T *state = service->state;
4185 +
4186 + vcos_log_info("%d: tsi - (%d<->%d)", state->id, service->localport, service->remoteport);
4187 +
4188 + /* Disconnect from the instance, to prevent any callbacks */
4189 + service->instance = NULL;
4190 +
4191 + /* Mark the service for termination by the slot handler */
4192 + request_poll(state, service, VCHIQ_POLL_TERMINATE);
4193 +}
4194 +
4195 +/* Called from the application process upon process death, and from
4196 + vchiq_remove_service */
4197 +void
4198 +vchiq_free_service_internal(VCHIQ_SERVICE_T *service)
4199 +{
4200 + VCHIQ_STATE_T *state = service->state;
4201 + int slot_last = state->remote->slot_last;
4202 + int i;
4203 +
4204 + vcos_log_info("%d: fsi - (%d)", state->id, service->localport);
4205 +
4206 + vcos_mutex_lock(&state->mutex);
4207 +
4208 + /* Release any claimed messages */
4209 + for (i = state->remote->slot_first; i <= slot_last; i++)
4210 + {
4211 + VCHIQ_SLOT_INFO_T *slot_info = SLOT_INFO_FROM_INDEX(state, i);
4212 + if (slot_info->release_count != slot_info->use_count)
4213 + {
4214 + char *data = (char *)SLOT_DATA_FROM_INDEX(state, i);
4215 + int pos, end;
4216 +
4217 + end = VCHIQ_SLOT_SIZE;
4218 + if (data == state->rx_data)
4219 + {
4220 + /* This buffer is still being read from - stop at the current read position */
4221 + end = state->rx_pos & VCHIQ_SLOT_MASK;
4222 + }
4223 +
4224 + pos = 0;
4225 +
4226 + while (pos < end)
4227 + {
4228 + VCHIQ_HEADER_T *header = (VCHIQ_HEADER_T *)(data + pos);
4229 + int msgid = header->msgid;
4230 + int port = VCHIQ_MSG_DSTPORT(msgid);
4231 + if (port == service->localport)
4232 + {
4233 + if (msgid & VCHIQ_MSGID_CLAIMED)
4234 + {
4235 + header->msgid = msgid & ~VCHIQ_MSGID_CLAIMED;
4236 + vcos_log_info(" fsi - hdr %x", (unsigned int)header);
4237 + release_slot(state, slot_info);
4238 + }
4239 + }
4240 + pos += calc_stride(header->size);
4241 + }
4242 + }
4243 + }
4244 +
4245 + vcos_assert(state->services[service->localport] == service);
4246 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_FREE);
4247 + state->services[service->localport] = NULL;
4248 + vcos_free(service);
4249 + vcos_mutex_unlock(&state->mutex);
4250 +}
4251 +
4252 +VCHIQ_STATUS_T
4253 +vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance)
4254 +{
4255 + int i;
4256 +
4257 + /* Find all services registered to this client and enable them. */
4258 + for (i = 0; i < state->unused_service; i++)
4259 + {
4260 + VCHIQ_SERVICE_T *service = state->services[i];
4261 + if (service && (service->instance == instance)) {
4262 + if (service->srvstate == VCHIQ_SRVSTATE_HIDDEN)
4263 + vchiq_set_service_state(service,
4264 + VCHIQ_SRVSTATE_LISTENING);
4265 + }
4266 + }
4267 +
4268 + if (state->conn_state == VCHIQ_CONNSTATE_DISCONNECTED) {
4269 + if (queue_message(state, NULL,
4270 + VCHIQ_MAKE_MSG(VCHIQ_MSG_CONNECT, 0, 0), NULL, 0,
4271 + 0, 1) == VCHIQ_RETRY)
4272 + return VCHIQ_RETRY;
4273 + vcos_event_wait(&state->connect);
4274 +
4275 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTED);
4276 + }
4277 +
4278 + return VCHIQ_SUCCESS;
4279 +}
4280 +
4281 +VCHIQ_STATUS_T
4282 +vchiq_shutdown_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance)
4283 +{
4284 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4285 + int i;
4286 +
4287 + /* Find all services registered to this client and close them. */
4288 + for (i = 0; i < state->unused_service; i++)
4289 + {
4290 + VCHIQ_SERVICE_T *service = state->services[i];
4291 + if (service && (service->instance == instance) &&
4292 + ((service->srvstate == VCHIQ_SRVSTATE_OPEN) ||
4293 + (service->srvstate == VCHIQ_SRVSTATE_LISTENING)))
4294 + {
4295 + status = vchiq_remove_service(&service->base);
4296 + if (status != VCHIQ_SUCCESS)
4297 + break;
4298 + }
4299 + }
4300 +
4301 + return status;
4302 +}
4303 +
4304 +VCHIQ_STATUS_T
4305 +vchiq_pause_internal(VCHIQ_STATE_T *state)
4306 +{
4307 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4308 +
4309 + switch (state->conn_state)
4310 + {
4311 + case VCHIQ_CONNSTATE_CONNECTED:
4312 + /* Request a pause */
4313 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_PAUSING);
4314 + request_poll(state, NULL, 0);
4315 + break;
4316 + case VCHIQ_CONNSTATE_PAUSED:
4317 + break;
4318 + default:
4319 + status = VCHIQ_ERROR;
4320 + VCHIQ_STATS_INC(state, error_count);
4321 + break;
4322 + }
4323 +
4324 + return status;
4325 +}
4326 +
4327 +VCHIQ_STATUS_T
4328 +vchiq_resume_internal(VCHIQ_STATE_T *state)
4329 +{
4330 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4331 +
4332 + if (state->conn_state == VCHIQ_CONNSTATE_PAUSED)
4333 + {
4334 + vchiq_set_conn_state(state, VCHIQ_CONNSTATE_RESUMING);
4335 + request_poll(state, NULL, 0);
4336 + }
4337 + else
4338 + {
4339 + status = VCHIQ_ERROR;
4340 + VCHIQ_STATS_INC(state, error_count);
4341 + }
4342 +
4343 + return status;
4344 +}
4345 +
4346 +VCHIQ_STATUS_T
4347 +vchiq_close_service(VCHIQ_SERVICE_HANDLE_T handle)
4348 +{
4349 + /* Unregister the service */
4350 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *) handle;
4351 + VCHIQ_STATUS_T status = VCHIQ_ERROR;
4352 +
4353 + if (service == NULL)
4354 + return VCHIQ_ERROR;
4355 +
4356 + vcos_log_info("%d: close_service:%d", service->state->id, service->localport);
4357 +
4358 + if (service->public_fourcc != VCHIQ_FOURCC_INVALID)
4359 + {
4360 + if (service->srvstate == VCHIQ_SRVSTATE_CLOSEWAIT)
4361 + {
4362 + /* This is a non-auto-close server */
4363 + vchiq_set_service_state(service, VCHIQ_SRVSTATE_LISTENING);
4364 + status = VCHIQ_SUCCESS;
4365 + }
4366 + }
4367 + else
4368 + {
4369 + /* For clients, make it an alias of vchiq_remove_service */
4370 + status = vchiq_remove_service(handle);
4371 + }
4372 +
4373 + return status;
4374 +}
4375 +
4376 +VCHIQ_STATUS_T
4377 +vchiq_remove_service(VCHIQ_SERVICE_HANDLE_T handle)
4378 +{
4379 + /* Unregister the service */
4380 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *) handle;
4381 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
4382 +
4383 + if (service == NULL)
4384 + return VCHIQ_ERROR;
4385 +
4386 + vcos_log_info("%d: remove_service:%d", service->state->id, service->localport);
4387 +
4388 + switch (service->srvstate)
4389 + {
4390 + case VCHIQ_SRVSTATE_OPENING:
4391 + case VCHIQ_SRVSTATE_OPEN:
4392 + /* Mark the service for termination by the slot handler */
4393 + request_poll(service->state, service, VCHIQ_POLL_TERMINATE);
4394 +
4395 + /* Drop through... */
4396 + case VCHIQ_SRVSTATE_CLOSESENT:
4397 + case VCHIQ_SRVSTATE_CLOSING:
4398 + while ((service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT) &&
4399 + (service->srvstate != VCHIQ_SRVSTATE_LISTENING))
4400 + {
4401 + if (vcos_event_wait(&service->remove_event) != VCOS_SUCCESS) {
4402 + status = VCHIQ_RETRY;
4403 + break;
4404 + }
4405 + }
4406 + break;
4407 +
4408 + default:
4409 + break;
4410 + }
4411 +
4412 + if (status == VCHIQ_SUCCESS) {
4413 + if (service->srvstate == VCHIQ_SRVSTATE_OPEN)
4414 + status = VCHIQ_ERROR;
4415 + else
4416 + {
4417 + service->instance = NULL;
4418 + vchiq_free_service_internal(service);
4419 + }
4420 + }
4421 +
4422 + return status;
4423 +}
4424 +
4425 +
4426 +VCHIQ_STATUS_T
4427 +vchiq_bulk_transfer(VCHIQ_SERVICE_T *service,
4428 + VCHI_MEM_HANDLE_T memhandle, void *offset, int size, void *userdata,
4429 + VCHIQ_BULK_MODE_T mode, VCHIQ_BULK_DIR_T dir)
4430 +{
4431 + VCHIQ_BULK_QUEUE_T *queue = (dir == VCHIQ_BULK_TRANSMIT) ?
4432 + &service->bulk_tx : &service->bulk_rx;
4433 + VCHIQ_BULK_T *bulk;
4434 + VCHIQ_STATE_T *state;
4435 + BULK_WAITER_T bulk_waiter;
4436 + const char dir_char = (dir == VCHIQ_BULK_TRANSMIT) ? 't' : 'r';
4437 + const int dir_msgtype = (dir == VCHIQ_BULK_TRANSMIT) ? VCHIQ_MSG_BULK_TX : VCHIQ_MSG_BULK_RX;
4438 + VCHIQ_STATUS_T status = VCHIQ_ERROR;
4439 +
4440 + if ((service == NULL) ||
4441 + ((memhandle == VCHI_MEM_HANDLE_INVALID) && (offset == NULL)))
4442 + return VCHIQ_ERROR;
4443 +
4444 + state = service->state;
4445 +
4446 + if (service->srvstate != VCHIQ_SRVSTATE_OPEN)
4447 + return VCHIQ_ERROR; /* Must be connected */
4448 +
4449 + if (vcos_mutex_lock(&service->bulk_mutex) != VCOS_SUCCESS)
4450 + return VCHIQ_RETRY;
4451 +
4452 + if (queue->local_insert == queue->remove + VCHIQ_NUM_SERVICE_BULKS)
4453 + {
4454 + VCHIQ_SERVICE_STATS_INC(service, bulk_stalls);
4455 + do {
4456 + vcos_mutex_unlock(&service->bulk_mutex);
4457 + if (vcos_event_wait(&service->bulk_remove_event) != VCOS_SUCCESS)
4458 + return VCHIQ_RETRY;
4459 + if (vcos_mutex_lock(&service->bulk_mutex) != VCOS_SUCCESS)
4460 + return VCHIQ_RETRY;
4461 + } while (queue->local_insert == queue->remove + VCHIQ_NUM_SERVICE_BULKS);
4462 + }
4463 +
4464 + bulk = &queue->bulks[BULK_INDEX(queue->local_insert)];
4465 +
4466 + if (mode == VCHIQ_BULK_MODE_BLOCKING)
4467 + {
4468 + vcos_event_create(&bulk_waiter.event, "bulk_waiter");
4469 + bulk_waiter.actual = 0;
4470 + userdata = &bulk_waiter;
4471 + }
4472 +
4473 + bulk->mode = mode;
4474 + bulk->dir = dir;
4475 + bulk->userdata = userdata;
4476 + bulk->size = size;
4477 + bulk->actual = VCHIQ_BULK_ACTUAL_ABORTED;
4478 +
4479 + if (vchiq_prepare_bulk_data(bulk, memhandle, offset, size, dir) != VCHIQ_SUCCESS)
4480 + {
4481 + goto error_exit;
4482 + }
4483 +
4484 + vcos_log_info("%d: bt (%d->%d) %cx %x@%x %x", state->id,
4485 + service->localport, service->remoteport, dir_char,
4486 + size, (unsigned int)bulk->data, (unsigned int)userdata);
4487 +
4488 + if (state->is_master)
4489 + {
4490 + queue->local_insert++;
4491 + if (resolve_bulks(service, queue))
4492 + request_poll(state, service, (dir == VCHIQ_BULK_TRANSMIT) ?
4493 + VCHIQ_POLL_TXNOTIFY : VCHIQ_POLL_RXNOTIFY);
4494 + }
4495 + else
4496 + {
4497 + int payload[2] = { (int)bulk->data, bulk->size };
4498 + VCHIQ_ELEMENT_T element = { payload, sizeof(payload) };
4499 +
4500 + if (queue_message(state, NULL,
4501 + VCHIQ_MAKE_MSG(dir_msgtype,
4502 + service->localport, service->remoteport),
4503 + &element, 1, sizeof(payload), 1) != VCHIQ_SUCCESS)
4504 + {
4505 + vchiq_complete_bulk(bulk);
4506 + goto error_exit;
4507 + }
4508 + queue->local_insert++;
4509 + queue->remote_insert++;
4510 + }
4511 +
4512 + vcos_mutex_unlock(&service->bulk_mutex);
4513 +
4514 + vcos_log_trace("%d: bt:%d %cx li=%x ri=%x p=%x", state->id,
4515 + service->localport, dir_char,
4516 + queue->local_insert, queue->remote_insert, queue->process);
4517 +
4518 + status = VCHIQ_SUCCESS;
4519 +
4520 + if (mode == VCHIQ_BULK_MODE_BLOCKING)
4521 + {
4522 + if (vcos_event_wait(&bulk_waiter.event) != VCOS_SUCCESS)
4523 + {
4524 + vcos_log_info("bulk wait interrupted");
4525 + /* Stop notify_bulks signalling a non-existent waiter */
4526 + bulk->userdata = NULL;
4527 + status = VCHIQ_ERROR;
4528 + }
4529 + else if (bulk_waiter.actual == VCHIQ_BULK_ACTUAL_ABORTED)
4530 + status = VCHIQ_ERROR;
4531 +
4532 + vcos_event_delete(&bulk_waiter.event);
4533 + }
4534 +
4535 + return status;
4536 +
4537 +error_exit:
4538 + if (mode == VCHIQ_BULK_MODE_BLOCKING)
4539 + vcos_event_delete(&bulk_waiter.event);
4540 + vcos_mutex_unlock(&service->bulk_mutex);
4541 +
4542 + return status;
4543 +}
4544 +
4545 +VCHIQ_STATUS_T
4546 +vchiq_queue_bulk_transmit(VCHIQ_SERVICE_HANDLE_T handle,
4547 + const void *data, int size, void *userdata)
4548 +{
4549 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4550 + VCHI_MEM_HANDLE_INVALID, (void *)data, size, userdata,
4551 + VCHIQ_BULK_MODE_CALLBACK, VCHIQ_BULK_TRANSMIT);
4552 +}
4553 +
4554 +VCHIQ_STATUS_T
4555 +vchiq_queue_bulk_receive(VCHIQ_SERVICE_HANDLE_T handle, void *data, int size,
4556 + void *userdata)
4557 +{
4558 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4559 + VCHI_MEM_HANDLE_INVALID, data, size, userdata,
4560 + VCHIQ_BULK_MODE_CALLBACK, VCHIQ_BULK_RECEIVE);
4561 +}
4562 +
4563 +VCHIQ_STATUS_T
4564 +vchiq_queue_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T handle,
4565 + VCHI_MEM_HANDLE_T memhandle, const void *offset, int size, void *userdata)
4566 +{
4567 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4568 + memhandle, (void *)offset, size, userdata,
4569 + VCHIQ_BULK_MODE_CALLBACK, VCHIQ_BULK_TRANSMIT);
4570 +}
4571 +
4572 +VCHIQ_STATUS_T
4573 +vchiq_queue_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T handle,
4574 + VCHI_MEM_HANDLE_T memhandle, void *offset, int size, void *userdata)
4575 +{
4576 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4577 + memhandle, offset, size, userdata,
4578 + VCHIQ_BULK_MODE_CALLBACK, VCHIQ_BULK_RECEIVE);
4579 +}
4580 +
4581 +VCHIQ_STATUS_T
4582 +vchiq_bulk_transmit(VCHIQ_SERVICE_HANDLE_T handle, const void *data, int size,
4583 + void *userdata, VCHIQ_BULK_MODE_T mode)
4584 +{
4585 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4586 + VCHI_MEM_HANDLE_INVALID, (void *)data, size, userdata,
4587 + mode, VCHIQ_BULK_TRANSMIT);
4588 +}
4589 +
4590 +VCHIQ_STATUS_T
4591 +vchiq_bulk_receive(VCHIQ_SERVICE_HANDLE_T handle, void *data, int size,
4592 + void *userdata, VCHIQ_BULK_MODE_T mode)
4593 +{
4594 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4595 + VCHI_MEM_HANDLE_INVALID, data, size, userdata,
4596 + mode, VCHIQ_BULK_RECEIVE);
4597 +}
4598 +
4599 +VCHIQ_STATUS_T
4600 +vchiq_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T handle,
4601 + VCHI_MEM_HANDLE_T memhandle, const void *offset, int size, void *userdata,
4602 + VCHIQ_BULK_MODE_T mode)
4603 +{
4604 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4605 + memhandle, (void *)offset, size, userdata,
4606 + mode, VCHIQ_BULK_TRANSMIT);
4607 +}
4608 +
4609 +VCHIQ_STATUS_T
4610 +vchiq_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T handle,
4611 + VCHI_MEM_HANDLE_T memhandle, void *offset, int size, void *userdata,
4612 + VCHIQ_BULK_MODE_T mode)
4613 +{
4614 + return vchiq_bulk_transfer((VCHIQ_SERVICE_T *)handle,
4615 + memhandle, offset, size, userdata,
4616 + mode, VCHIQ_BULK_RECEIVE);
4617 +}
4618 +
4619 +VCHIQ_STATUS_T
4620 +vchiq_queue_message(VCHIQ_SERVICE_HANDLE_T handle,
4621 + const VCHIQ_ELEMENT_T *elements, int count)
4622 +{
4623 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *) handle;
4624 +
4625 + unsigned int size = 0;
4626 + unsigned int i;
4627 +
4628 + if ((service == NULL) ||
4629 + (service->srvstate != VCHIQ_SRVSTATE_OPEN))
4630 + return VCHIQ_ERROR;
4631 +
4632 + for (i = 0; i < (unsigned int)count; i++)
4633 + {
4634 + if (elements[i].size)
4635 + {
4636 + if (elements[i].data == NULL)
4637 + {
4638 + VCHIQ_SERVICE_STATS_INC(service, error_count);
4639 + return VCHIQ_ERROR;
4640 + }
4641 + size += elements[i].size;
4642 + }
4643 + }
4644 +
4645 + if (size > VCHIQ_MAX_MSG_SIZE)
4646 + {
4647 + VCHIQ_SERVICE_STATS_INC(service, error_count);
4648 + return VCHIQ_ERROR;
4649 + }
4650 +
4651 + return queue_message(service->state, service,
4652 + VCHIQ_MAKE_MSG(VCHIQ_MSG_DATA, service->localport,
4653 + service->remoteport), elements, count, size, 1);
4654 +}
4655 +
4656 +void
4657 +vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle, VCHIQ_HEADER_T *header)
4658 +{
4659 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
4660 + VCHIQ_STATE_T *state;
4661 + int slot_index;
4662 + int msgid;
4663 +
4664 + if (service == NULL)
4665 + return;
4666 +
4667 + state = service->state;
4668 +
4669 + slot_index = SLOT_INDEX_FROM_DATA(state, (void *)header);
4670 +
4671 + if ((slot_index >= state->remote->slot_first) &&
4672 + (slot_index <= state->remote->slot_last) &&
4673 + ((msgid = header->msgid) & VCHIQ_MSGID_CLAIMED))
4674 + {
4675 + VCHIQ_SLOT_INFO_T *slot_info = SLOT_INFO_FROM_INDEX(state, slot_index);
4676 +
4677 + /* Rewrite the message header to prevent a double release */
4678 + header->msgid = msgid & ~VCHIQ_MSGID_CLAIMED;
4679 +
4680 + release_slot(state, slot_info);
4681 + }
4682 +}
4683 +
4684 +int
4685 +vchiq_get_client_id(VCHIQ_SERVICE_HANDLE_T handle)
4686 +{
4687 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
4688 + return service ? service->client_id : 0;
4689 +}
4690 +
4691 +VCHIQ_STATUS_T
4692 +vchiq_get_config(VCHIQ_INSTANCE_T instance,
4693 + int config_size, VCHIQ_CONFIG_T *pconfig)
4694 +{
4695 + VCHIQ_CONFIG_T config;
4696 +
4697 + vcos_unused(instance);
4698 +
4699 + config.max_msg_size = VCHIQ_MAX_MSG_SIZE;
4700 + config.bulk_threshold = VCHIQ_MAX_MSG_SIZE;
4701 + config.max_outstanding_bulks = VCHIQ_NUM_SERVICE_BULKS;
4702 + config.max_services = VCHIQ_MAX_SERVICES;
4703 + config.version = VCHIQ_VERSION;
4704 + config.version_min = VCHIQ_VERSION_MIN;
4705 +
4706 + if (config_size > sizeof(VCHIQ_CONFIG_T))
4707 + return VCHIQ_ERROR;
4708 +
4709 + memcpy(pconfig, &config, vcos_min(config_size, sizeof(VCHIQ_CONFIG_T)));
4710 +
4711 + return VCHIQ_SUCCESS;
4712 +}
4713 +
4714 +VCHIQ_STATUS_T
4715 +vchiq_set_service_option(VCHIQ_SERVICE_HANDLE_T handle,
4716 + VCHIQ_SERVICE_OPTION_T option, int value)
4717 +{
4718 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
4719 + VCHIQ_STATUS_T status = VCHIQ_ERROR;
4720 +
4721 + if (service)
4722 + {
4723 + switch (option)
4724 + {
4725 + case VCHIQ_SERVICE_OPTION_AUTOCLOSE:
4726 + service->auto_close = value;
4727 + status = VCHIQ_SUCCESS;
4728 + break;
4729 +
4730 + default:
4731 + break;
4732 + }
4733 + }
4734 +
4735 + return status;
4736 +}
4737 +
4738 +void
4739 +vchiq_dump_shared_state(void *dump_context, VCHIQ_STATE_T *state,
4740 + VCHIQ_SHARED_STATE_T *shared, const char *label)
4741 +{
4742 + static const char *const debug_names[] =
4743 + {
4744 + "<entries>",
4745 + "SLOT_HANDLER_COUNT",
4746 + "SLOT_HANDLER_LINE",
4747 + "PARSE_LINE",
4748 + "PARSE_HEADER",
4749 + "PARSE_MSGID",
4750 + "AWAIT_COMPLETION_LINE",
4751 + "DEQUEUE_MESSAGE_LINE",
4752 + "SERVICE_CALLBACK_LINE",
4753 + "MSG_QUEUE_FULL_COUNT",
4754 + "COMPLETION_QUEUE_FULL_COUNT"
4755 + };
4756 + int i;
4757 +
4758 + char buf[80];
4759 + int len;
4760 + len = vcos_snprintf(buf, sizeof(buf),
4761 + " %s: slots %d-%d tx_pos=%x recycle=%x",
4762 + label, shared->slot_first, shared->slot_last,
4763 + shared->tx_pos, shared->slot_queue_recycle);
4764 + vchiq_dump(dump_context, buf, len + 1);
4765 +
4766 + len = vcos_snprintf(buf, sizeof(buf),
4767 + " Slots claimed:");
4768 + vchiq_dump(dump_context, buf, len + 1);
4769 +
4770 + for (i = shared->slot_first; i <= shared->slot_last; i++)
4771 + {
4772 + VCHIQ_SLOT_INFO_T slot_info = *SLOT_INFO_FROM_INDEX(state, i);
4773 + if (slot_info.use_count != slot_info.release_count)
4774 + {
4775 + len = vcos_snprintf(buf, sizeof(buf),
4776 + " %d: %d/%d", i, slot_info.use_count, slot_info.release_count);
4777 + vchiq_dump(dump_context, buf, len + 1);
4778 + }
4779 + }
4780 +
4781 + for (i = 1; i < shared->debug[DEBUG_ENTRIES]; i++)
4782 + {
4783 + len = vcos_snprintf(buf, sizeof(buf), " DEBUG: %s = %d(%x)",
4784 + debug_names[i], shared->debug[i], shared->debug[i]);
4785 + vchiq_dump(dump_context, buf, len + 1);
4786 + }
4787 +}
4788 +
4789 +void
4790 +vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state)
4791 +{
4792 + char buf[80];
4793 + int len;
4794 + int i;
4795 +
4796 + len = vcos_snprintf(buf, sizeof(buf), "State %d: %s", state->id,
4797 + conn_state_names[state->conn_state]);
4798 + vchiq_dump(dump_context, buf, len + 1);
4799 +
4800 + len = vcos_snprintf(buf, sizeof(buf),
4801 + " tx_pos=%x(@%x), rx_pos=%x(@%x)",
4802 + state->id, state->local->tx_pos,
4803 + (uint32_t)state->tx_data + (state->local_tx_pos & VCHIQ_SLOT_MASK),
4804 + state->rx_pos,
4805 + (uint32_t)state->rx_data + (state->rx_pos & VCHIQ_SLOT_MASK));
4806 + vchiq_dump(dump_context, buf, len + 1);
4807 +
4808 + len = vcos_snprintf(buf, sizeof(buf),
4809 + " Version: %d (min %d)",
4810 + VCHIQ_VERSION, VCHIQ_VERSION_MIN);
4811 + vchiq_dump(dump_context, buf, len + 1);
4812 +
4813 + if (VCHIQ_ENABLE_STATS)
4814 + {
4815 + len = vcos_snprintf(buf, sizeof(buf),
4816 + " Stats: ctrl_tx_count=%d, ctrl_rx_count=%d, error_count=%d",
4817 + state->stats.ctrl_tx_count, state->stats.ctrl_rx_count,
4818 + state->stats.slot_stalls);
4819 + vchiq_dump(dump_context, buf, len + 1);
4820 + }
4821 +
4822 + len = vcos_snprintf(buf, sizeof(buf),
4823 + " Slots: %d available, %d recyclable, %d stalls",
4824 + state->slot_queue_available - SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos),
4825 + state->local->slot_queue_recycle - state->slot_queue_available,
4826 + state->stats.slot_stalls);
4827 + vchiq_dump(dump_context, buf, len + 1);
4828 +
4829 + vchiq_dump_platform_state(dump_context);
4830 +
4831 + vchiq_dump_shared_state(dump_context, state, state->local, "Local");
4832 + vchiq_dump_shared_state(dump_context, state, state->remote, "Remote");
4833 +
4834 + vchiq_dump_platform_instances(dump_context);
4835 +
4836 + for (i = 0; i < state->unused_service; i++) {
4837 + VCHIQ_SERVICE_T *service = state->services[i];
4838 +
4839 + if (service && (service->srvstate != VCHIQ_SRVSTATE_FREE))
4840 + vchiq_dump_service_state(dump_context, service);
4841 + }
4842 +}
4843 +
4844 +void
4845 +vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service)
4846 +{
4847 + char buf[80];
4848 + int len;
4849 +
4850 + len = vcos_snprintf(buf, sizeof(buf), "Service %d: %s",
4851 + service->localport, srvstate_names[service->srvstate]);
4852 +
4853 + if (service->srvstate != VCHIQ_SRVSTATE_FREE)
4854 + {
4855 + char remoteport[30];
4856 + VCHIQ_SERVICE_QUOTA_T *service_quota =
4857 + &service->state->service_quotas[service->localport];
4858 + int fourcc = service->base.fourcc;
4859 + if (service->remoteport != VCHIQ_PORT_FREE)
4860 + {
4861 + int len2 = vcos_snprintf(remoteport, sizeof(remoteport), "%d",
4862 + service->remoteport);
4863 + if (service->public_fourcc != VCHIQ_FOURCC_INVALID)
4864 + vcos_snprintf(remoteport + len2, sizeof(remoteport) - len2,
4865 + " (client %x)", service->client_id);
4866 + }
4867 + else
4868 + vcos_strcpy(remoteport, "n/a");
4869 +
4870 + len += vcos_snprintf(buf + len, sizeof(buf) - len,
4871 + " '%c%c%c%c' remote %s (slot use %d/%d)",
4872 + VCHIQ_FOURCC_AS_4CHARS(fourcc),
4873 + remoteport,
4874 + service_quota->slot_use_count,
4875 + service_quota->slot_quota);
4876 +
4877 + if (VCHIQ_ENABLE_STATS)
4878 + {
4879 + vchiq_dump(dump_context, buf, len + 1);
4880 +
4881 + len = vcos_snprintf(buf, sizeof(buf),
4882 + " Ctrl: tx_count=%d, tx_bytes=%" PRIu64 ", rx_count=%d, rx_bytes=%" PRIu64,
4883 + service->stats.ctrl_tx_count, service->stats.ctrl_tx_bytes,
4884 + service->stats.ctrl_rx_count, service->stats.ctrl_rx_bytes);
4885 + vchiq_dump(dump_context, buf, len + 1);
4886 +
4887 + len = vcos_snprintf(buf, sizeof(buf),
4888 + " Bulk: tx_count=%d, tx_bytes=%" PRIu64 ", rx_count=%d, rx_bytes=%" PRIu64,
4889 + service->stats.bulk_tx_count, service->stats.bulk_tx_bytes,
4890 + service->stats.bulk_rx_count, service->stats.bulk_rx_bytes);
4891 + vchiq_dump(dump_context, buf, len + 1);
4892 +
4893 + len = vcos_snprintf(buf, sizeof(buf),
4894 + " %d quota stalls, %d slot stalls, %d bulk stalls, %d aborted, %d errors",
4895 + service->stats.quota_stalls, service->stats.slot_stalls,
4896 + service->stats.bulk_stalls, service->stats.bulk_aborted_count,
4897 + service->stats.error_count);
4898 + }
4899 + }
4900 +
4901 + vchiq_dump(dump_context, buf, len + 1);
4902 +
4903 + vchiq_dump_platform_service_state(dump_context, service);
4904 +}
4905 --- /dev/null
4906 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_core.h
4907 @@ -0,0 +1,480 @@
4908 +/*
4909 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
4910 + *
4911 + * This program is free software; you can redistribute it and/or modify
4912 + * it under the terms of the GNU General Public License as published by
4913 + * the Free Software Foundation; either version 2 of the License, or
4914 + * (at your option) any later version.
4915 + *
4916 + * This program is distributed in the hope that it will be useful,
4917 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4918 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4919 + * GNU General Public License for more details.
4920 + *
4921 + * You should have received a copy of the GNU General Public License
4922 + * along with this program; if not, write to the Free Software
4923 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4924 + */
4925 +
4926 +#ifndef VCHIQ_CORE_H
4927 +#define VCHIQ_CORE_H
4928 +
4929 +#include "vchiq_cfg.h"
4930 +
4931 +#include "vchiq.h"
4932 +
4933 +#define IS_POW2(x) (x && ((x & (x - 1)) == 0))
4934 +
4935 +/* Ensure that the slot size and maximum number of slots are powers of 2 */
4936 +vcos_static_assert(IS_POW2(VCHIQ_SLOT_SIZE));
4937 +vcos_static_assert(IS_POW2(VCHIQ_MAX_SLOTS));
4938 +vcos_static_assert(IS_POW2(VCHIQ_MAX_SLOTS_PER_SIDE));
4939 +
4940 +#define VCHIQ_SLOT_MASK (VCHIQ_SLOT_SIZE - 1)
4941 +#define VCHIQ_SLOT_QUEUE_MASK (VCHIQ_MAX_SLOTS_PER_SIDE - 1)
4942 +#define VCHIQ_SLOT_ZERO_SLOTS ((sizeof(VCHIQ_SLOT_ZERO_T) + \
4943 + VCHIQ_SLOT_SIZE - 1) / VCHIQ_SLOT_SIZE)
4944 +
4945 +#define VCHIQ_MSG_PADDING 0 // -
4946 +#define VCHIQ_MSG_CONNECT 1 // -
4947 +#define VCHIQ_MSG_OPEN 2 // + (srcport, -), fourcc, client_id
4948 +#define VCHIQ_MSG_OPENACK 3 // + (srcport, dstport)
4949 +#define VCHIQ_MSG_CLOSE 4 // + (srcport, dstport)
4950 +#define VCHIQ_MSG_DATA 5 // + (srcport, dstport)
4951 +#define VCHIQ_MSG_BULK_RX 6 // + (srcport, dstport), data, size
4952 +#define VCHIQ_MSG_BULK_TX 7 // + (srcport, dstport), data, size
4953 +#define VCHIQ_MSG_BULK_RX_DONE 8 // + (srcport, dstport), actual
4954 +#define VCHIQ_MSG_BULK_TX_DONE 9 // + (srcport, dstport), actual
4955 +#define VCHIQ_MSG_PAUSE 10 // -
4956 +#define VCHIQ_MSG_RESUME 11 // -
4957 +
4958 +#define VCHIQ_PORT_MAX (VCHIQ_MAX_SERVICES - 1)
4959 +#define VCHIQ_PORT_FREE 0x1000
4960 +#define VCHIQ_PORT_IS_VALID(port) (port < VCHIQ_PORT_FREE)
4961 +#define VCHIQ_MAKE_MSG(type,srcport,dstport) ((type<<24) | (srcport<<12) | (dstport<<0))
4962 +#define VCHIQ_MSG_TYPE(msgid) ((unsigned int)msgid >> 24)
4963 +#define VCHIQ_MSG_SRCPORT(msgid) (unsigned short)(((unsigned int)msgid >> 12) & 0xfff)
4964 +#define VCHIQ_MSG_DSTPORT(msgid) ((unsigned short)msgid & 0xfff)
4965 +
4966 +#define VCHIQ_FOURCC_AS_4CHARS(fourcc) \
4967 + ((fourcc) >> 24) & 0xff, \
4968 + ((fourcc) >> 16) & 0xff, \
4969 + ((fourcc) >> 8) & 0xff, \
4970 + ((fourcc) ) & 0xff
4971 +
4972 +/* Ensure the fields are wide enough */
4973 +vcos_static_assert(VCHIQ_MSG_SRCPORT(VCHIQ_MAKE_MSG(0,0,VCHIQ_PORT_MAX)) == 0);
4974 +vcos_static_assert(VCHIQ_MSG_TYPE(VCHIQ_MAKE_MSG(0,VCHIQ_PORT_MAX,0)) == 0);
4975 +vcos_static_assert((unsigned int)VCHIQ_PORT_MAX < (unsigned int)VCHIQ_PORT_FREE);
4976 +
4977 +#define VCHIQ_MSGID_PADDING VCHIQ_MAKE_MSG(VCHIQ_MSG_PADDING,0,0)
4978 +#define VCHIQ_MSGID_CLAIMED 0x40000000
4979 +
4980 +#define VCHIQ_FOURCC_INVALID 0x00000000
4981 +#define VCHIQ_FOURCC_IS_LEGAL(fourcc) (fourcc != VCHIQ_FOURCC_INVALID)
4982 +
4983 +#define VCHIQ_BULK_ACTUAL_ABORTED -1
4984 +
4985 +typedef uint32_t BITSET_T;
4986 +
4987 +vcos_static_assert((sizeof(BITSET_T) * 8) == 32);
4988 +
4989 +#define BITSET_SIZE(b) ((b + 31) >> 5)
4990 +#define BITSET_WORD(b) (b >> 5)
4991 +#define BITSET_BIT(b) (1 << (b & 31))
4992 +#define BITSET_ZERO(bs) memset(bs, 0, sizeof(bs))
4993 +#define BITSET_IS_SET(bs, b) (bs[BITSET_WORD(b)] & BITSET_BIT(b))
4994 +#define BITSET_SET(bs, b) (bs[BITSET_WORD(b)] |= BITSET_BIT(b))
4995 +#define BITSET_CLR(bs, b) (bs[BITSET_WORD(b)] &= ~BITSET_BIT(b))
4996 +
4997 +#if VCHIQ_ENABLE_STATS
4998 +#define VCHIQ_STATS_INC(state, stat) (state->stats. stat ++)
4999 +#define VCHIQ_SERVICE_STATS_INC(service, stat) (service->stats. stat ++)
5000 +#define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) (service->stats. stat += addend)
5001 +#else
5002 +#define VCHIQ_STATS_INC(state, stat) ((void)0)
5003 +#define VCHIQ_SERVICE_STATS_INC(service, stat) ((void)0)
5004 +#define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) ((void)0)
5005 +#endif
5006 +
5007 +enum
5008 +{
5009 + DEBUG_ENTRIES,
5010 +#if VCHIQ_ENABLE_DEBUG
5011 + DEBUG_SLOT_HANDLER_COUNT,
5012 + DEBUG_SLOT_HANDLER_LINE,
5013 + DEBUG_PARSE_LINE,
5014 + DEBUG_PARSE_HEADER,
5015 + DEBUG_PARSE_MSGID,
5016 + DEBUG_AWAIT_COMPLETION_LINE,
5017 + DEBUG_DEQUEUE_MESSAGE_LINE,
5018 + DEBUG_SERVICE_CALLBACK_LINE,
5019 + DEBUG_MSG_QUEUE_FULL_COUNT,
5020 + DEBUG_COMPLETION_QUEUE_FULL_COUNT,
5021 +#endif
5022 + DEBUG_MAX
5023 +};
5024 +
5025 +#if VCHIQ_ENABLE_DEBUG
5026 +
5027 +#define DEBUG_INITIALISE(local) volatile int *debug_ptr = (local)->debug;
5028 +#define DEBUG_TRACE(d) debug_ptr[DEBUG_ ## d] = __LINE__
5029 +#define DEBUG_VALUE(d,v) debug_ptr[DEBUG_ ## d] = (v)
5030 +#define DEBUG_COUNT(d) debug_ptr[DEBUG_ ## d]++
5031 +
5032 +#else /* VCHIQ_ENABLE_DEBUG */
5033 +
5034 +#define DEBUG_INITIALISE(local)
5035 +#define DEBUG_TRACE(d)
5036 +#define DEBUG_VALUE(d,v)
5037 +#define DEBUG_COUNT(d)
5038 +
5039 +#endif /* VCHIQ_ENABLE_DEBUG */
5040 +
5041 +typedef enum
5042 +{
5043 + VCHIQ_CONNSTATE_DISCONNECTED,
5044 + VCHIQ_CONNSTATE_CONNECTED,
5045 + VCHIQ_CONNSTATE_PAUSING,
5046 + VCHIQ_CONNSTATE_PAUSE_SENT,
5047 + VCHIQ_CONNSTATE_PAUSED,
5048 + VCHIQ_CONNSTATE_RESUMING
5049 +} VCHIQ_CONNSTATE_T;
5050 +
5051 +enum
5052 +{
5053 + VCHIQ_SRVSTATE_FREE,
5054 + VCHIQ_SRVSTATE_HIDDEN,
5055 + VCHIQ_SRVSTATE_LISTENING,
5056 + VCHIQ_SRVSTATE_OPENING,
5057 + VCHIQ_SRVSTATE_OPEN,
5058 + VCHIQ_SRVSTATE_CLOSESENT,
5059 + VCHIQ_SRVSTATE_CLOSING,
5060 + VCHIQ_SRVSTATE_CLOSEWAIT
5061 +};
5062 +
5063 +enum
5064 +{
5065 + VCHIQ_POLL_TERMINATE,
5066 + VCHIQ_POLL_TXNOTIFY,
5067 + VCHIQ_POLL_RXNOTIFY,
5068 + VCHIQ_POLL_COUNT
5069 +};
5070 +
5071 +typedef enum
5072 +{
5073 + VCHIQ_BULK_TRANSMIT,
5074 + VCHIQ_BULK_RECEIVE
5075 +} VCHIQ_BULK_DIR_T;
5076 +
5077 +typedef struct vchiq_bulk_struct {
5078 + short mode;
5079 + short dir;
5080 + void *userdata;
5081 + VCHI_MEM_HANDLE_T handle;
5082 + void *data;
5083 + int size;
5084 + void *remote_data;
5085 + int remote_size;
5086 + int actual;
5087 +} VCHIQ_BULK_T;
5088 +
5089 +typedef struct vchiq_bulk_queue_struct {
5090 + int local_insert; /* Where to insert the next local bulk */
5091 + int remote_insert; /* Where to insert the next remote bulk (master) */
5092 + int process; /* Bulk to transfer next */
5093 + int remote_notify; /* Bulk to notify the remote client of next (master) */
5094 + int remove; /* Bulk to notify the local client of, and remove, next */
5095 + VCHIQ_BULK_T bulks[VCHIQ_NUM_SERVICE_BULKS];
5096 +} VCHIQ_BULK_QUEUE_T;
5097 +
5098 +typedef struct remote_event_struct {
5099 + volatile int armed;
5100 + volatile int fired;
5101 + VCOS_EVENT_T * event;
5102 +} REMOTE_EVENT_T;
5103 +
5104 +typedef struct vchiq_state_struct VCHIQ_STATE_T;
5105 +
5106 +typedef struct vchiq_slot_struct {
5107 + char data[VCHIQ_SLOT_SIZE];
5108 +} VCHIQ_SLOT_T;
5109 +
5110 +typedef struct vchiq_slot_info_struct {
5111 + /* Use two counters rather than one to avoid the need for a mutex. */
5112 + volatile short use_count;
5113 + volatile short release_count;
5114 +} VCHIQ_SLOT_INFO_T;
5115 +
5116 +typedef struct vchiq_service_struct {
5117 + VCHIQ_SERVICE_BASE_T base;
5118 + volatile int srvstate;
5119 + unsigned int localport;
5120 + unsigned int remoteport;
5121 + int public_fourcc;
5122 + int client_id;
5123 + int auto_close;
5124 + VCOS_ATOMIC_FLAGS_T poll_flags;
5125 + short version;
5126 + short version_min;
5127 +
5128 + VCHIQ_STATE_T *state;
5129 + VCHIQ_INSTANCE_T instance;
5130 +
5131 + int service_use_count;
5132 +
5133 + VCHIQ_BULK_QUEUE_T bulk_tx;
5134 + VCHIQ_BULK_QUEUE_T bulk_rx;
5135 +
5136 + VCOS_EVENT_T remove_event;
5137 + VCOS_EVENT_T bulk_remove_event;
5138 + VCOS_MUTEX_T bulk_mutex;
5139 +
5140 + struct service_stats_struct
5141 + {
5142 + int quota_stalls;
5143 + int slot_stalls;
5144 + int bulk_stalls;
5145 + int error_count;
5146 + int ctrl_tx_count;
5147 + int ctrl_rx_count;
5148 + int bulk_tx_count;
5149 + int bulk_rx_count;
5150 + int bulk_aborted_count;
5151 + uint64_t ctrl_tx_bytes;
5152 + uint64_t ctrl_rx_bytes;
5153 + uint64_t bulk_tx_bytes;
5154 + uint64_t bulk_rx_bytes;
5155 + } stats;
5156 +} VCHIQ_SERVICE_T;
5157 +
5158 +/* The quota information is outside VCHIQ_SERVICE_T so that it can be
5159 + statically allocated, since for accounting reasons a service's slot
5160 + usage is carried over between users of the same port number.
5161 + */
5162 +typedef struct vchiq_service_quota_struct {
5163 + int slot_quota;
5164 + int slot_use_count;
5165 + VCOS_EVENT_T quota_event;
5166 + int previous_tx_index;
5167 +} VCHIQ_SERVICE_QUOTA_T;
5168 +
5169 +typedef struct vchiq_shared_state_struct {
5170 +
5171 + /* A non-zero value here indicates that the content is valid. */
5172 + int initialised;
5173 +
5174 + /* The first and last (inclusive) slots allocated to the owner. */
5175 + int slot_first;
5176 + int slot_last;
5177 +
5178 + /* Signalling this event indicates that owner's slot handler thread should
5179 + run. */
5180 + REMOTE_EVENT_T trigger;
5181 +
5182 + /* Indicates the byte position within the stream where the next message
5183 + will be written. The least significant bits are an index into the slot.
5184 + The next bits are the index of the slot in slot_queue. */
5185 + volatile int tx_pos;
5186 +
5187 + /* This event should be signalled when a slot is recycled. */
5188 + REMOTE_EVENT_T recycle;
5189 +
5190 + /* The slot_queue index where the next recycled slot will be written. */
5191 + volatile int slot_queue_recycle;
5192 +
5193 + /* A circular buffer of slot indexes. */
5194 + int slot_queue[VCHIQ_MAX_SLOTS_PER_SIDE];
5195 +
5196 + /* Debugging state */
5197 + volatile int debug[DEBUG_MAX];
5198 +} VCHIQ_SHARED_STATE_T;
5199 +
5200 +typedef struct vchiq_slot_zero_struct {
5201 + int magic;
5202 + short version;
5203 + short version_min;
5204 + int slot_zero_size;
5205 + int slot_size;
5206 + int max_slots;
5207 + int max_slots_per_side;
5208 + int platform_data[2];
5209 + VCHIQ_SHARED_STATE_T master;
5210 + VCHIQ_SHARED_STATE_T slave;
5211 + VCHIQ_SLOT_INFO_T slots[VCHIQ_MAX_SLOTS];
5212 +} VCHIQ_SLOT_ZERO_T;
5213 +
5214 +struct vchiq_state_struct {
5215 + int id;
5216 + int initialised;
5217 + VCHIQ_CONNSTATE_T conn_state;
5218 + int is_master;
5219 +
5220 + VCHIQ_SHARED_STATE_T *local;
5221 + VCHIQ_SHARED_STATE_T *remote;
5222 + VCHIQ_SLOT_T *slot_data;
5223 +
5224 + int default_slot_quota;
5225 +
5226 + VCOS_EVENT_T connect; // event indicating connect message received
5227 + VCOS_MUTEX_T mutex; // mutex protecting services
5228 + VCHIQ_INSTANCE_T *instance;
5229 +
5230 + VCOS_THREAD_T slot_handler_thread; // processes incoming messages
5231 + VCOS_THREAD_T recycle_thread; // processes recycled slots
5232 + VCOS_THREAD_T lp_thread; // processes low priority messages (eg suspend)
5233 +
5234 + /* Local implementation of the trigger remote event */
5235 + VCOS_EVENT_T trigger_event;
5236 +
5237 + /* Local implementation of the recycle remote event */
5238 + VCOS_EVENT_T recycle_event;
5239 +
5240 + VCOS_EVENT_T lp_evt;
5241 +
5242 + char *tx_data;
5243 + char *rx_data;
5244 + VCHIQ_SLOT_INFO_T *rx_info;
5245 +
5246 + VCOS_MUTEX_T slot_mutex;
5247 +
5248 + VCOS_MUTEX_T recycle_mutex;
5249 +
5250 + VCOS_MUTEX_T suspend_resume_mutex;
5251 + VCOS_MUTEX_T use_count_mutex;
5252 +
5253 + /* Global use count for videocore.
5254 + * This is equal to the sum of the use counts for all services. When this hits
5255 + * zero the videocore suspend procedure will be initiated. */
5256 + int videocore_use_count;
5257 +
5258 + /* Flag to indicate whether videocore is currently suspended */
5259 + int videocore_suspended;
5260 +
5261 + /* Indicates the byte position within the stream from where the next message
5262 + will be read. The least significant bits are an index into the slot.
5263 + The next bits are the index of the slot in remote->slot_queue. */
5264 + int rx_pos;
5265 +
5266 + /* A cached copy of local->tx_pos. Only write to local->tx_pos, and read
5267 + from remote->tx_pos. */
5268 + int local_tx_pos;
5269 +
5270 + /* The slot_queue index of the slot to become available next. */
5271 + int slot_queue_available;
5272 +
5273 + /* A flag to indicate if any poll has been requested */
5274 + int poll_needed;
5275 +
5276 + /* An array of bit sets indicating which services must be polled. */
5277 + VCOS_ATOMIC_FLAGS_T poll_services[BITSET_SIZE(VCHIQ_MAX_SERVICES)];
5278 +
5279 + /* The number of the first unused service */
5280 + int unused_service;
5281 +
5282 + /* Signalled when a free slot becomes available. */
5283 + VCOS_EVENT_T slot_available_event;
5284 +
5285 + VCOS_EVENT_T slot_remove_event;
5286 +
5287 + struct state_stats_struct
5288 + {
5289 + int slot_stalls;
5290 + int ctrl_tx_count;
5291 + int ctrl_rx_count;
5292 + int error_count;
5293 + } stats;
5294 +
5295 + VCHIQ_SERVICE_T *services[VCHIQ_MAX_SERVICES];
5296 + VCHIQ_SERVICE_QUOTA_T service_quotas[VCHIQ_MAX_SERVICES];
5297 + VCHIQ_SLOT_INFO_T slot_info[VCHIQ_MAX_SLOTS];
5298 +};
5299 +
5300 +extern VCHIQ_SLOT_ZERO_T *
5301 +vchiq_init_slots(void *mem_base, int mem_size);
5302 +
5303 +extern VCHIQ_STATUS_T
5304 +vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero, int is_master);
5305 +
5306 +extern VCHIQ_STATUS_T
5307 +vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);
5308 +
5309 +extern VCHIQ_SERVICE_T *
5310 +vchiq_add_service_internal(VCHIQ_STATE_T *state,
5311 + const VCHIQ_SERVICE_PARAMS_T *params, int srvstate,
5312 + VCHIQ_INSTANCE_T instance);
5313 +
5314 +extern VCHIQ_STATUS_T
5315 +vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id);
5316 +
5317 +extern VCHIQ_STATUS_T
5318 +vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd);
5319 +
5320 +extern void
5321 +vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service);
5322 +
5323 +extern void
5324 +vchiq_free_service_internal(VCHIQ_SERVICE_T *service);
5325 +
5326 +extern VCHIQ_STATUS_T
5327 +vchiq_shutdown_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);
5328 +
5329 +extern VCHIQ_STATUS_T
5330 +vchiq_pause_internal(VCHIQ_STATE_T *state);
5331 +
5332 +extern VCHIQ_STATUS_T
5333 +vchiq_resume_internal(VCHIQ_STATE_T *state);
5334 +
5335 +extern void
5336 +remote_event_pollall(VCHIQ_STATE_T *state);
5337 +
5338 +extern VCHIQ_STATUS_T
5339 +vchiq_bulk_transfer(VCHIQ_SERVICE_T *service,
5340 + VCHI_MEM_HANDLE_T memhandle, void *offset, int size, void *userdata,
5341 + VCHIQ_BULK_MODE_T mode, VCHIQ_BULK_DIR_T dir);
5342 +
5343 +extern void
5344 +vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state);
5345 +
5346 +extern void
5347 +vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service);
5348 +
5349 +/* The following functions are called from vchiq_core, and external
5350 + implementations must be provided. */
5351 +
5352 +extern VCHIQ_STATUS_T
5353 +vchiq_prepare_bulk_data(VCHIQ_BULK_T *bulk,
5354 + VCHI_MEM_HANDLE_T memhandle, void *offset, int size, int dir);
5355 +
5356 +extern void
5357 +vchiq_transfer_bulk(VCHIQ_BULK_T *bulk);
5358 +
5359 +extern void
5360 +vchiq_complete_bulk(VCHIQ_BULK_T *bulk);
5361 +
5362 +extern VCHIQ_STATUS_T
5363 +vchiq_copy_from_user(void *dst, const void *src, int size);
5364 +
5365 +extern void
5366 +remote_event_signal(REMOTE_EVENT_T *event);
5367 +
5368 +extern void
5369 +vchiq_platform_paused(VCHIQ_STATE_T *state);
5370 +
5371 +extern void
5372 +vchiq_platform_resumed(VCHIQ_STATE_T *state);
5373 +
5374 +extern void
5375 +vchiq_dump(void *dump_context, const char *str, int len);
5376 +
5377 +extern void
5378 +vchiq_dump_platform_state(void *dump_context);
5379 +
5380 +extern void
5381 +vchiq_dump_platform_instances(void *dump_context);
5382 +
5383 +extern void
5384 +vchiq_dump_platform_service_state(void *dump_context,
5385 + VCHIQ_SERVICE_T *service);
5386 +
5387 +#endif
5388 --- /dev/null
5389 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_if.h
5390 @@ -0,0 +1,148 @@
5391 +/*
5392 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
5393 + *
5394 + * This program is free software; you can redistribute it and/or modify
5395 + * it under the terms of the GNU General Public License as published by
5396 + * the Free Software Foundation; either version 2 of the License, or
5397 + * (at your option) any later version.
5398 + *
5399 + * This program is distributed in the hope that it will be useful,
5400 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
5401 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
5402 + * GNU General Public License for more details.
5403 + *
5404 + * You should have received a copy of the GNU General Public License
5405 + * along with this program; if not, write to the Free Software
5406 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
5407 + */
5408 +
5409 +#ifndef VCHIQ_IF_H
5410 +#define VCHIQ_IF_H
5411 +
5412 +#include "interface/vchi/vchi_mh.h"
5413 +
5414 +#define VCHIQ_SLOT_SIZE 4096
5415 +#define VCHIQ_MAX_MSG_SIZE (VCHIQ_SLOT_SIZE - sizeof(VCHIQ_HEADER_T))
5416 +#define VCHIQ_CHANNEL_SIZE VCHIQ_MAX_MSG_SIZE /* For backwards compatibility */
5417 +
5418 +#define VCHIQ_MAKE_FOURCC(x0, x1, x2, x3) (((x0) << 24) | ((x1) << 16) | ((x2) << 8) | (x3))
5419 +#define VCHIQ_GET_SERVICE_USERDATA(service) (service->userdata)
5420 +#define VCHIQ_GET_SERVICE_FOURCC(service) (service->fourcc)
5421 +
5422 +typedef enum {
5423 + VCHIQ_SERVICE_OPENED, // service, -, -
5424 + VCHIQ_SERVICE_CLOSED, // service, -, -
5425 + VCHIQ_MESSAGE_AVAILABLE, // service, header, -
5426 + VCHIQ_BULK_TRANSMIT_DONE, // service, -, bulk_userdata
5427 + VCHIQ_BULK_RECEIVE_DONE, // service, -, bulk_userdata
5428 + VCHIQ_BULK_TRANSMIT_ABORTED, // service, -, bulk_userdata
5429 + VCHIQ_BULK_RECEIVE_ABORTED // service, -, bulk_userdata
5430 +} VCHIQ_REASON_T;
5431 +
5432 +typedef enum
5433 +{
5434 + VCHIQ_ERROR = -1,
5435 + VCHIQ_SUCCESS = 0,
5436 + VCHIQ_RETRY = 1
5437 +} VCHIQ_STATUS_T;
5438 +
5439 +typedef enum
5440 +{
5441 + VCHIQ_BULK_MODE_CALLBACK,
5442 + VCHIQ_BULK_MODE_BLOCKING,
5443 + VCHIQ_BULK_MODE_NOCALLBACK
5444 +} VCHIQ_BULK_MODE_T;
5445 +
5446 +typedef enum
5447 +{
5448 + VCHIQ_SERVICE_OPTION_AUTOCLOSE
5449 +} VCHIQ_SERVICE_OPTION_T;
5450 +
5451 +#ifdef __HIGHC__
5452 +/* Allow zero-sized arrays without warnings */
5453 +#pragma warning (push)
5454 +#pragma warning (disable : 4200)
5455 +#endif
5456 +
5457 +typedef struct vchiq_header_struct {
5458 + /* The message identifier - opaque to applications. */
5459 + int msgid;
5460 +
5461 + /* Size of message data. */
5462 + unsigned int size;
5463 +
5464 + char data[0]; /* message */
5465 +} VCHIQ_HEADER_T;
5466 +
5467 +#ifdef __HIGHC__
5468 +#pragma warning (pop)
5469 +#endif
5470 +
5471 +typedef struct {
5472 + const void *data;
5473 + int size;
5474 +} VCHIQ_ELEMENT_T;
5475 +
5476 +typedef const struct vchiq_service_base_struct *VCHIQ_SERVICE_HANDLE_T;
5477 +
5478 +typedef VCHIQ_STATUS_T (*VCHIQ_CALLBACK_T)(VCHIQ_REASON_T, VCHIQ_HEADER_T *, VCHIQ_SERVICE_HANDLE_T, void *);
5479 +
5480 +typedef struct vchiq_service_base_struct {
5481 + int fourcc;
5482 + VCHIQ_CALLBACK_T callback;
5483 + void *userdata;
5484 +} VCHIQ_SERVICE_BASE_T;
5485 +
5486 +typedef struct vchiq_service_params_struct {
5487 + int fourcc;
5488 + VCHIQ_CALLBACK_T callback;
5489 + void *userdata;
5490 + short version; /* Increment for non-trivial changes */
5491 + short version_min; /* Update for incompatible changes */
5492 +} VCHIQ_SERVICE_PARAMS_T;
5493 +
5494 +typedef struct vchiq_config_struct {
5495 + int max_msg_size;
5496 + int bulk_threshold; /* The message size aboce which it is better to use
5497 + a bulk transfer (<= max_msg_size) */
5498 + int max_outstanding_bulks;
5499 + int max_services;
5500 + short version; /* The version of VCHIQ */
5501 + short version_min; /* The minimum compatible version of VCHIQ */
5502 +} VCHIQ_CONFIG_T;
5503 +
5504 +typedef struct vchiq_instance_struct *VCHIQ_INSTANCE_T;
5505 +
5506 +extern VCHIQ_STATUS_T vchiq_initialise(VCHIQ_INSTANCE_T *pinstance);
5507 +extern VCHIQ_STATUS_T vchiq_shutdown(VCHIQ_INSTANCE_T instance);
5508 +extern VCHIQ_STATUS_T vchiq_connect(VCHIQ_INSTANCE_T instance);
5509 +extern VCHIQ_STATUS_T vchiq_add_service(VCHIQ_INSTANCE_T instance, int fourcc, VCHIQ_CALLBACK_T callback, void *userdata, VCHIQ_SERVICE_HANDLE_T *pservice);
5510 +extern VCHIQ_STATUS_T vchiq_open_service(VCHIQ_INSTANCE_T instance, int fourcc, VCHIQ_CALLBACK_T callback, void *userdata, VCHIQ_SERVICE_HANDLE_T *pservice);
5511 +extern VCHIQ_STATUS_T vchiq_add_service_params(VCHIQ_INSTANCE_T instance,
5512 + const VCHIQ_SERVICE_PARAMS_T *params,
5513 + VCHIQ_SERVICE_HANDLE_T *pservice);
5514 +extern VCHIQ_STATUS_T vchiq_open_service_params(VCHIQ_INSTANCE_T instance,
5515 + const VCHIQ_SERVICE_PARAMS_T *params,
5516 + VCHIQ_SERVICE_HANDLE_T *pservice);
5517 +extern VCHIQ_STATUS_T vchiq_close_service(VCHIQ_SERVICE_HANDLE_T service);
5518 +extern VCHIQ_STATUS_T vchiq_remove_service(VCHIQ_SERVICE_HANDLE_T service);
5519 +extern VCHIQ_STATUS_T vchiq_use_service(VCHIQ_SERVICE_HANDLE_T service);
5520 +extern VCHIQ_STATUS_T vchiq_release_service(VCHIQ_SERVICE_HANDLE_T service);
5521 +
5522 +extern VCHIQ_STATUS_T vchiq_queue_message(VCHIQ_SERVICE_HANDLE_T service, const VCHIQ_ELEMENT_T *elements, int count);
5523 +extern void vchiq_release_message(VCHIQ_SERVICE_HANDLE_T service, VCHIQ_HEADER_T *header);
5524 +extern VCHIQ_STATUS_T vchiq_queue_bulk_transmit(VCHIQ_SERVICE_HANDLE_T service, const void *data, int size, void *userdata);
5525 +extern VCHIQ_STATUS_T vchiq_queue_bulk_receive(VCHIQ_SERVICE_HANDLE_T service, void *data, int size, void *userdata);
5526 +extern VCHIQ_STATUS_T vchiq_queue_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T service, VCHI_MEM_HANDLE_T handle, const void *offset, int size, void *userdata);
5527 +extern VCHIQ_STATUS_T vchiq_queue_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T service, VCHI_MEM_HANDLE_T handle, void *offset, int size, void *userdata);
5528 +extern VCHIQ_STATUS_T vchiq_bulk_transmit(VCHIQ_SERVICE_HANDLE_T service, const void *data, int size, void *userdata, VCHIQ_BULK_MODE_T mode);
5529 +extern VCHIQ_STATUS_T vchiq_bulk_receive(VCHIQ_SERVICE_HANDLE_T service, void *data, int size, void *userdata, VCHIQ_BULK_MODE_T mode);
5530 +extern VCHIQ_STATUS_T vchiq_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T service, VCHI_MEM_HANDLE_T handle, const void *offset, int size, void *userdata, VCHIQ_BULK_MODE_T mode);
5531 +extern VCHIQ_STATUS_T vchiq_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T service, VCHI_MEM_HANDLE_T handle, void *offset, int size, void *userdata, VCHIQ_BULK_MODE_T mode);
5532 +extern int vchiq_get_client_id(VCHIQ_SERVICE_HANDLE_T service);
5533 +extern VCHIQ_STATUS_T vchiq_get_config(VCHIQ_INSTANCE_T instance, int config_size, VCHIQ_CONFIG_T *pconfig);
5534 +extern VCHIQ_STATUS_T vchiq_set_service_option(VCHIQ_SERVICE_HANDLE_T service, VCHIQ_SERVICE_OPTION_T option, int value);
5535 +
5536 +extern VCHIQ_STATUS_T vchiq_dump_phys_mem( VCHIQ_SERVICE_HANDLE_T service, void *ptr, size_t num_bytes );
5537 +
5538 +#endif /* VCHIQ_IF_H */
5539 --- /dev/null
5540 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
5541 @@ -0,0 +1,105 @@
5542 +/*
5543 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
5544 + *
5545 + * This program is free software; you can redistribute it and/or modify
5546 + * it under the terms of the GNU General Public License as published by
5547 + * the Free Software Foundation; either version 2 of the License, or
5548 + * (at your option) any later version.
5549 + *
5550 + * This program is distributed in the hope that it will be useful,
5551 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
5552 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
5553 + * GNU General Public License for more details.
5554 + *
5555 + * You should have received a copy of the GNU General Public License
5556 + * along with this program; if not, write to the Free Software
5557 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
5558 + */
5559 +
5560 +#ifndef VCHIQ_IOCTLS_H
5561 +#define VCHIQ_IOCTLS_H
5562 +
5563 +#include <linux/ioctl.h>
5564 +#include "vchiq_if.h"
5565 +
5566 +#define VCHIQ_IOC_MAGIC 0xc4
5567 +#define VCHIQ_INVALID_HANDLE -1
5568 +
5569 +typedef struct {
5570 + VCHIQ_SERVICE_PARAMS_T params;
5571 + int is_open;
5572 + int is_vchi;
5573 + int handle; /* OUT */
5574 +} VCHIQ_CREATE_SERVICE_T;
5575 +
5576 +typedef struct {
5577 + int handle;
5578 + int count;
5579 + const VCHIQ_ELEMENT_T *elements;
5580 +} VCHIQ_QUEUE_MESSAGE_T;
5581 +
5582 +typedef struct {
5583 + int handle;
5584 + void *data;
5585 + int size;
5586 + void *userdata;
5587 + VCHIQ_BULK_MODE_T mode;
5588 +} VCHIQ_QUEUE_BULK_TRANSFER_T;
5589 +
5590 +typedef struct {
5591 + VCHIQ_REASON_T reason;
5592 + VCHIQ_HEADER_T *header;
5593 + void *service_userdata;
5594 + void *bulk_userdata;
5595 +} VCHIQ_COMPLETION_DATA_T;
5596 +
5597 +typedef struct {
5598 + int count;
5599 + VCHIQ_COMPLETION_DATA_T *buf;
5600 + int msgbufsize;
5601 + int msgbufcount; /* IN/OUT */
5602 + void **msgbufs;
5603 +} VCHIQ_AWAIT_COMPLETION_T;
5604 +
5605 +typedef struct {
5606 + int handle;
5607 + int blocking;
5608 + int bufsize;
5609 + void *buf;
5610 +} VCHIQ_DEQUEUE_MESSAGE_T;
5611 +
5612 +typedef struct {
5613 + int config_size;
5614 + VCHIQ_CONFIG_T *pconfig;
5615 +} VCHIQ_GET_CONFIG_T;
5616 +
5617 +typedef struct {
5618 + int handle;
5619 + VCHIQ_SERVICE_OPTION_T option;
5620 + int value;
5621 +} VCHIQ_SET_SERVICE_OPTION_T;
5622 +
5623 +typedef struct {
5624 + void *virt_addr;
5625 + size_t num_bytes;
5626 +} VCHIQ_DUMP_MEM_T;
5627 +
5628 +#define VCHIQ_IOC_CONNECT _IO(VCHIQ_IOC_MAGIC, 0)
5629 +#define VCHIQ_IOC_SHUTDOWN _IO(VCHIQ_IOC_MAGIC, 1)
5630 +#define VCHIQ_IOC_CREATE_SERVICE _IOWR(VCHIQ_IOC_MAGIC, 2, VCHIQ_CREATE_SERVICE_T)
5631 +#define VCHIQ_IOC_REMOVE_SERVICE _IO(VCHIQ_IOC_MAGIC, 3)
5632 +#define VCHIQ_IOC_QUEUE_MESSAGE _IOW(VCHIQ_IOC_MAGIC, 4, VCHIQ_QUEUE_MESSAGE_T)
5633 +#define VCHIQ_IOC_QUEUE_BULK_TRANSMIT _IOW(VCHIQ_IOC_MAGIC, 5, VCHIQ_QUEUE_BULK_TRANSFER_T)
5634 +#define VCHIQ_IOC_QUEUE_BULK_RECEIVE _IOW(VCHIQ_IOC_MAGIC, 6, VCHIQ_QUEUE_BULK_TRANSFER_T)
5635 +#define VCHIQ_IOC_AWAIT_COMPLETION _IOW(VCHIQ_IOC_MAGIC, 7, VCHIQ_AWAIT_COMPLETION_T)
5636 +#define VCHIQ_IOC_DEQUEUE_MESSAGE _IOW(VCHIQ_IOC_MAGIC, 8, VCHIQ_DEQUEUE_MESSAGE_T)
5637 +#define VCHIQ_IOC_GET_CLIENT_ID _IO(VCHIQ_IOC_MAGIC, 9)
5638 +#define VCHIQ_IOC_GET_CONFIG _IOW(VCHIQ_IOC_MAGIC, 10, VCHIQ_GET_CONFIG_T)
5639 +#define VCHIQ_IOC_CLOSE_SERVICE _IO(VCHIQ_IOC_MAGIC, 11)
5640 +#define VCHIQ_IOC_USE_SERVICE _IO(VCHIQ_IOC_MAGIC, 12)
5641 +#define VCHIQ_IOC_RELEASE_SERVICE _IO(VCHIQ_IOC_MAGIC, 13)
5642 +#define VCHIQ_IOC_SET_SERVICE_OPTION _IOW(VCHIQ_IOC_MAGIC, 14, VCHIQ_SET_SERVICE_OPTION_T)
5643 +#define VCHIQ_IOC_DUMP_PHYS_MEM _IOW(VCHIQ_IOC_MAGIC, 15, VCHIQ_DUMP_MEM_T)
5644 +#define VCHIQ_IOC_MAX 15
5645 +
5646 +#endif
5647 --- /dev/null
5648 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_kern_lib.c
5649 @@ -0,0 +1,297 @@
5650 +/*****************************************************************************
5651 +* Copyright 2001 - 2011 Broadcom Corporation. All rights reserved.
5652 +*
5653 +* Unless you and Broadcom execute a separate written software license
5654 +* agreement governing use of this software, this software is licensed to you
5655 +* under the terms of the GNU General Public License version 2, available at
5656 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
5657 +*
5658 +* Notwithstanding the above, under no circumstances may you combine this
5659 +* software in any way with any other Broadcom software provided under a
5660 +* license other than the GPL, without Broadcom's express prior written
5661 +* consent.
5662 +*****************************************************************************/
5663 +
5664 +/* ---- Include Files ---------------------------------------------------- */
5665 +
5666 +#include <linux/kernel.h>
5667 +#include <linux/module.h>
5668 +
5669 +#include "vchiq_core.h"
5670 +#include "vchiq_arm.h"
5671 +#include "interface/vcos/vcos_logging.h"
5672 +
5673 +/* ---- Public Variables ------------------------------------------------- */
5674 +
5675 +extern VCOS_LOG_CAT_T vchiq_core_log_category;
5676 +#define VCOS_LOG_CATEGORY (&vchiq_core_log_category)
5677 +
5678 +/* ---- Private Constants and Types -------------------------------------- */
5679 +
5680 +struct vchiq_instance_struct {
5681 + VCHIQ_STATE_T *state;
5682 +
5683 + int connected;
5684 +};
5685 +
5686 +/****************************************************************************
5687 +*
5688 +* vchiq_initialise
5689 +*
5690 +***************************************************************************/
5691 +
5692 +VCHIQ_STATUS_T vchiq_initialise( VCHIQ_INSTANCE_T *instanceOut )
5693 +{
5694 + VCHIQ_STATUS_T status = VCHIQ_ERROR;
5695 + VCHIQ_STATE_T *state;
5696 + VCHIQ_INSTANCE_T instance = NULL;
5697 +
5698 + vcos_log_trace( "%s called", __func__ );
5699 +
5700 + state = vchiq_get_state();
5701 + if (!state)
5702 + {
5703 + printk( KERN_ERR "%s: videocore not initialized\n", __func__ );
5704 + goto failed;
5705 + }
5706 +
5707 + instance = kzalloc( sizeof(*instance), GFP_KERNEL );
5708 + if( !instance )
5709 + {
5710 + printk( KERN_ERR "%s: error allocating vchiq instance\n", __func__ );
5711 + goto failed;
5712 + }
5713 +
5714 + instance->connected = 0;
5715 + instance->state = state;
5716 +
5717 + *instanceOut = instance;
5718 +
5719 + status = VCHIQ_SUCCESS;
5720 +
5721 +failed:
5722 + vcos_log_trace( "%s(%p): returning %d", __func__, instance, status );
5723 +
5724 + return status;
5725 +}
5726 +
5727 +/****************************************************************************
5728 +*
5729 +* vchiq_shutdown
5730 +*
5731 +***************************************************************************/
5732 +
5733 +VCHIQ_STATUS_T vchiq_shutdown( VCHIQ_INSTANCE_T instance )
5734 +{
5735 + VCHIQ_STATUS_T status;
5736 + VCHIQ_STATE_T *state = instance->state;
5737 +
5738 + vcos_log_trace( "%s(%p) called", __func__, instance );
5739 +
5740 + vcos_mutex_lock(&state->mutex);
5741 +
5742 + /* Remove all services */
5743 + status = vchiq_shutdown_internal(state, instance);
5744 +
5745 + vcos_mutex_unlock(&state->mutex);
5746 +
5747 + if (status == VCHIQ_SUCCESS)
5748 + kfree(instance);
5749 +
5750 + vcos_log_trace( "%s(%p): returning %d", __func__, instance, status );
5751 +
5752 + return status;
5753 +}
5754 +
5755 +/****************************************************************************
5756 +*
5757 +* vchiq_is_connected
5758 +*
5759 +***************************************************************************/
5760 +
5761 +int vchiq_is_connected(VCHIQ_INSTANCE_T instance)
5762 +{
5763 + return instance->connected;
5764 +}
5765 +
5766 +/****************************************************************************
5767 +*
5768 +* vchiq_connect
5769 +*
5770 +***************************************************************************/
5771 +
5772 +VCHIQ_STATUS_T vchiq_connect(VCHIQ_INSTANCE_T instance)
5773 +{
5774 + VCHIQ_STATUS_T status;
5775 + VCHIQ_STATE_T *state = instance->state;
5776 +
5777 + vcos_log_trace( "%s(%p) called", __func__, instance );
5778 +
5779 + if (vcos_mutex_lock(&state->mutex) != VCOS_SUCCESS) {
5780 + vcos_log_trace( "%s: call to vcos_mutex_lock failed", __func__ );
5781 + status = VCHIQ_RETRY;
5782 + goto failed;
5783 + }
5784 + status = vchiq_connect_internal(state, instance);
5785 +
5786 + if (status == VCHIQ_SUCCESS)
5787 + instance->connected = 1;
5788 +
5789 + vcos_mutex_unlock(&state->mutex);
5790 +
5791 +failed:
5792 + vcos_log_trace( "%s(%p): returning %d", __func__, instance, status );
5793 +
5794 + return status;
5795 +}
5796 +
5797 +/****************************************************************************
5798 +*
5799 +* vchiq_add_service
5800 +*
5801 +***************************************************************************/
5802 +
5803 +VCHIQ_STATUS_T vchiq_add_service(
5804 + VCHIQ_INSTANCE_T instance,
5805 + int fourcc,
5806 + VCHIQ_CALLBACK_T callback,
5807 + void *userdata,
5808 + VCHIQ_SERVICE_HANDLE_T *pservice)
5809 +{
5810 + VCHIQ_SERVICE_PARAMS_T params;
5811 +
5812 + params.fourcc = fourcc;
5813 + params.callback = callback;
5814 + params.userdata = userdata;
5815 + params.version = 0;
5816 + params.version_min = 0;
5817 +
5818 + return vchiq_add_service_params(instance, &params, pservice);
5819 +}
5820 +
5821 +/****************************************************************************
5822 +*
5823 +* vchiq_open_service
5824 +*
5825 +***************************************************************************/
5826 +
5827 +VCHIQ_STATUS_T vchiq_open_service(
5828 + VCHIQ_INSTANCE_T instance,
5829 + int fourcc,
5830 + VCHIQ_CALLBACK_T callback,
5831 + void *userdata,
5832 + VCHIQ_SERVICE_HANDLE_T *pservice)
5833 +{
5834 + VCHIQ_SERVICE_PARAMS_T params;
5835 +
5836 + params.fourcc = fourcc;
5837 + params.callback = callback;
5838 + params.userdata = userdata;
5839 + params.version = 0;
5840 + params.version_min = 0;
5841 +
5842 + return vchiq_open_service_params(instance, &params, pservice);
5843 +}
5844 +
5845 +/****************************************************************************
5846 +*
5847 +* vchiq_add_service_params
5848 +*
5849 +***************************************************************************/
5850 +
5851 +VCHIQ_STATUS_T vchiq_add_service_params(
5852 + VCHIQ_INSTANCE_T instance,
5853 + const VCHIQ_SERVICE_PARAMS_T *params,
5854 + VCHIQ_SERVICE_HANDLE_T *pservice)
5855 +{
5856 + VCHIQ_STATUS_T status;
5857 + VCHIQ_STATE_T *state = instance->state;
5858 + VCHIQ_SERVICE_T *service;
5859 + int srvstate;
5860 +
5861 + vcos_log_trace( "%s(%p) called", __func__, instance );
5862 +
5863 + *pservice = NULL;
5864 +
5865 + srvstate = vchiq_is_connected( instance )
5866 + ? VCHIQ_SRVSTATE_LISTENING
5867 + : VCHIQ_SRVSTATE_HIDDEN;
5868 +
5869 + vcos_mutex_lock(&state->mutex);
5870 +
5871 + service = vchiq_add_service_internal(
5872 + state,
5873 + params,
5874 + srvstate,
5875 + instance);
5876 +
5877 + vcos_mutex_unlock(&state->mutex);
5878 +
5879 + if ( service )
5880 + {
5881 + *pservice = &service->base;
5882 + status = VCHIQ_SUCCESS;
5883 + }
5884 + else
5885 + {
5886 + status = VCHIQ_ERROR;
5887 + }
5888 +
5889 + vcos_log_trace( "%s(%p): returning %d", __func__, instance, status );
5890 +
5891 + return status;
5892 +}
5893 +
5894 +/****************************************************************************
5895 +*
5896 +* vchiq_open_service_params
5897 +*
5898 +***************************************************************************/
5899 +
5900 +VCHIQ_STATUS_T vchiq_open_service_params(
5901 + VCHIQ_INSTANCE_T instance,
5902 + const VCHIQ_SERVICE_PARAMS_T *params,
5903 + VCHIQ_SERVICE_HANDLE_T *pservice)
5904 +{
5905 + VCHIQ_STATUS_T status = VCHIQ_ERROR;
5906 + VCHIQ_STATE_T *state = instance->state;
5907 + VCHIQ_SERVICE_T *service;
5908 +
5909 + vcos_log_trace( "%s(%p) called", __func__, instance );
5910 +
5911 + *pservice = NULL;
5912 +
5913 + if (!vchiq_is_connected(instance))
5914 + goto failed;
5915 +
5916 + vcos_mutex_lock(&state->mutex);
5917 +
5918 + service = vchiq_add_service_internal(state,
5919 + params,
5920 + VCHIQ_SRVSTATE_OPENING,
5921 + instance);
5922 +
5923 + vcos_mutex_unlock(&state->mutex);
5924 +
5925 + if ( service )
5926 + {
5927 + status = vchiq_open_service_internal(service, current->pid);
5928 + if ( status == VCHIQ_SUCCESS )
5929 + *pservice = &service->base;
5930 + else
5931 + vchiq_remove_service(&service->base);
5932 + }
5933 +
5934 +failed:
5935 + vcos_log_trace( "%s(%p): returning %d", __func__, instance, status );
5936 +
5937 + return status;
5938 +}
5939 +
5940 +EXPORT_SYMBOL(vchiq_initialise);
5941 +EXPORT_SYMBOL(vchiq_shutdown);
5942 +EXPORT_SYMBOL(vchiq_connect);
5943 +EXPORT_SYMBOL(vchiq_add_service);
5944 +EXPORT_SYMBOL(vchiq_open_service);
5945 +EXPORT_SYMBOL(vchiq_add_service_params);
5946 +EXPORT_SYMBOL(vchiq_open_service_params);
5947 --- /dev/null
5948 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_lib.c
5949 @@ -0,0 +1,1518 @@
5950 +/*
5951 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
5952 + *
5953 + * This program is free software; you can redistribute it and/or modify
5954 + * it under the terms of the GNU General Public License as published by
5955 + * the Free Software Foundation; either version 2 of the License, or
5956 + * (at your option) any later version.
5957 + *
5958 + * This program is distributed in the hope that it will be useful,
5959 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
5960 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
5961 + * GNU General Public License for more details.
5962 + *
5963 + * You should have received a copy of the GNU General Public License
5964 + * along with this program; if not, write to the Free Software
5965 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
5966 + */
5967 +
5968 +#include <unistd.h>
5969 +#include <fcntl.h>
5970 +#include <sys/ioctl.h>
5971 +#include <stdio.h>
5972 +
5973 +#include "vchiq.h"
5974 +#include "vchiq_cfg.h"
5975 +#include "vchiq_ioctl.h"
5976 +#include "interface/vchi/vchi.h"
5977 +#include "interface/vchi/common/endian.h"
5978 +#include "interface/vcos/vcos.h"
5979 +
5980 +#define VCHIQ_MAX_INSTANCE_SERVICES 32
5981 +#define MSGBUF_SIZE (VCHIQ_MAX_MSG_SIZE + sizeof(VCHIQ_HEADER_T))
5982 +
5983 +#define RETRY(r,x) do { r = x; } while ((r == -1) && (errno == EINTR))
5984 +
5985 +#define VCOS_LOG_CATEGORY (&vchiq_lib_log_category)
5986 +
5987 +typedef struct vchiq_service_struct
5988 +{
5989 + VCHIQ_SERVICE_BASE_T base;
5990 + int handle;
5991 + int fd;
5992 + VCHI_CALLBACK_T vchi_callback;
5993 + void *peek_buf;
5994 + int peek_size;
5995 + int client_id;
5996 +} VCHIQ_SERVICE_T;
5997 +
5998 +typedef struct vchiq_service_struct VCHI_SERVICE_T;
5999 +
6000 +struct vchiq_instance_struct
6001 +{
6002 + int fd;
6003 + int initialised;
6004 + int connected;
6005 + VCOS_THREAD_T completion_thread;
6006 + VCOS_MUTEX_T mutex;
6007 + int used_services;
6008 + VCHIQ_SERVICE_T services[VCHIQ_MAX_INSTANCE_SERVICES];
6009 +} vchiq_instance;
6010 +
6011 +typedef struct vchiq_instance_struct VCHI_STATE_T;
6012 +
6013 +/* Local data */
6014 +static VCOS_LOG_LEVEL_T vchiq_default_lib_log_level = VCOS_LOG_WARN;
6015 +static VCOS_LOG_CAT_T vchiq_lib_log_category;
6016 +static VCOS_MUTEX_T vchiq_lib_mutex;
6017 +static void *free_msgbufs;
6018 +
6019 +
6020 +/* Local utility functions */
6021 +static VCHIQ_INSTANCE_T
6022 +vchiq_lib_init(void);
6023 +
6024 +static void *completion_thread(void *);
6025 +
6026 +static VCHIQ_STATUS_T
6027 +create_service(VCHIQ_INSTANCE_T instance,
6028 + const VCHIQ_SERVICE_PARAMS_T *params,
6029 + VCHI_CALLBACK_T vchi_callback,
6030 + int is_open,
6031 + VCHIQ_SERVICE_HANDLE_T *pservice);
6032 +
6033 +static int
6034 +fill_peek_buf(VCHI_SERVICE_T *service,
6035 + VCHI_FLAGS_T flags);
6036 +
6037 +static void *
6038 +alloc_msgbuf(void);
6039 +
6040 +static void
6041 +free_msgbuf(void *buf);
6042 +
6043 +static __inline int
6044 +is_valid_instance(VCHIQ_INSTANCE_T instance)
6045 +{
6046 + return (instance == &vchiq_instance) && (instance->initialised > 0);
6047 +}
6048 +
6049 +/*
6050 + * VCHIQ API
6051 + */
6052 +
6053 +VCHIQ_STATUS_T
6054 +vchiq_initialise(VCHIQ_INSTANCE_T *pinstance)
6055 +{
6056 + VCHIQ_INSTANCE_T instance;
6057 +
6058 + instance = vchiq_lib_init();
6059 +
6060 + vcos_log_trace( "%s: returning instance handle %p", __func__, instance );
6061 +
6062 + *pinstance = instance;
6063 +
6064 + return (instance != NULL) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6065 +}
6066 +
6067 +VCHIQ_STATUS_T
6068 +vchiq_shutdown(VCHIQ_INSTANCE_T instance)
6069 +{
6070 + vcos_log_trace( "%s called", __func__ );
6071 +
6072 + if (!is_valid_instance(instance))
6073 + return VCHIQ_ERROR;
6074 +
6075 + vcos_mutex_lock(&instance->mutex);
6076 +
6077 + if (instance->initialised == 1)
6078 + {
6079 + int i;
6080 +
6081 + instance->initialised = -1; /* Enter limbo */
6082 +
6083 + /* Remove all services */
6084 +
6085 + for (i = 0; i < instance->used_services; i++)
6086 + {
6087 + if (instance->services[i].handle != VCHIQ_INVALID_HANDLE)
6088 + {
6089 + vchiq_remove_service(&instance->services[i].base);
6090 + instance->services[i].handle = VCHIQ_INVALID_HANDLE;
6091 + }
6092 + }
6093 +
6094 + if (instance->connected)
6095 + {
6096 + int ret;
6097 + RETRY(ret, ioctl(instance->fd, VCHIQ_IOC_SHUTDOWN, 0));
6098 + vcos_assert(ret == 0);
6099 + vcos_thread_join(&instance->completion_thread, NULL);
6100 + instance->connected = 0;
6101 + }
6102 +
6103 + close(instance->fd);
6104 + instance->fd = -1;
6105 + }
6106 + else if (instance->initialised > 1)
6107 + {
6108 + instance->initialised--;
6109 + }
6110 +
6111 + vcos_mutex_unlock(&instance->mutex);
6112 +
6113 + vcos_global_lock();
6114 +
6115 + if (instance->initialised == -1)
6116 + {
6117 + vcos_mutex_delete(&instance->mutex);
6118 + instance->initialised = 0;
6119 + }
6120 +
6121 + vcos_global_unlock();
6122 +
6123 + vcos_log_trace( "%s returning", __func__ );
6124 +
6125 + return VCHIQ_SUCCESS;
6126 +}
6127 +
6128 +VCHIQ_STATUS_T
6129 +vchiq_connect(VCHIQ_INSTANCE_T instance)
6130 +{
6131 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
6132 +
6133 + vcos_log_trace( "%s called", __func__ );
6134 +
6135 + if (!is_valid_instance(instance))
6136 + return VCHIQ_ERROR;
6137 +
6138 + vcos_mutex_lock(&instance->mutex);
6139 +
6140 + if (!instance->connected)
6141 + {
6142 + int ret = ioctl(instance->fd, VCHIQ_IOC_CONNECT, 0);
6143 + if (ret == 0)
6144 + {
6145 + VCOS_THREAD_ATTR_T attrs;
6146 + instance->connected = 1;
6147 + vcos_thread_attr_init(&attrs);
6148 + vcos_thread_create(&instance->completion_thread, "VCHIQ completion",
6149 + &attrs, completion_thread, instance);
6150 + }
6151 + else
6152 + {
6153 + status = VCHIQ_ERROR;
6154 + }
6155 + }
6156 +
6157 + vcos_mutex_unlock(&instance->mutex);
6158 +
6159 + return status;
6160 +}
6161 +
6162 +VCHIQ_STATUS_T
6163 +vchiq_add_service(VCHIQ_INSTANCE_T instance,
6164 + int fourcc,
6165 + VCHIQ_CALLBACK_T callback,
6166 + void *userdata,
6167 + VCHIQ_SERVICE_HANDLE_T *pservice)
6168 +{
6169 + VCHIQ_SERVICE_PARAMS_T params;
6170 +
6171 + params.fourcc = fourcc;
6172 + params.callback = callback;
6173 + params.userdata = userdata;
6174 + params.version = 0;
6175 + params.version_min = 0;
6176 +
6177 + return vchiq_add_service_params(instance, &params, pservice);
6178 +}
6179 +
6180 +VCHIQ_STATUS_T
6181 +vchiq_open_service(VCHIQ_INSTANCE_T instance,
6182 + int fourcc,
6183 + VCHIQ_CALLBACK_T callback,
6184 + void *userdata,
6185 + VCHIQ_SERVICE_HANDLE_T *pservice)
6186 +{
6187 + VCHIQ_SERVICE_PARAMS_T params;
6188 +
6189 + params.fourcc = fourcc;
6190 + params.callback = callback;
6191 + params.userdata = userdata;
6192 + params.version = 0;
6193 + params.version_min = 0;
6194 +
6195 + return vchiq_open_service_params(instance, &params, pservice);
6196 +}
6197 +
6198 +VCHIQ_STATUS_T
6199 +vchiq_add_service_params(VCHIQ_INSTANCE_T instance,
6200 + const VCHIQ_SERVICE_PARAMS_T *params,
6201 + VCHIQ_SERVICE_HANDLE_T *pservice)
6202 +{
6203 + VCHIQ_STATUS_T status;
6204 +
6205 + vcos_log_trace( "%s called fourcc = 0x%08x (%c%c%c%c)",
6206 + __func__,
6207 + params->fourcc,
6208 + (params->fourcc >> 24) & 0xff,
6209 + (params->fourcc >> 16) & 0xff,
6210 + (params->fourcc >> 8) & 0xff,
6211 + (params->fourcc ) & 0xff );
6212 +
6213 + if (!params->callback)
6214 + return VCHIQ_ERROR;
6215 +
6216 + if (!is_valid_instance(instance))
6217 + return VCHIQ_ERROR;
6218 +
6219 + status = create_service(instance,
6220 + params,
6221 + NULL/*vchi_callback*/,
6222 + 0/*!open*/,
6223 + pservice);
6224 +
6225 + vcos_log_trace( "%s returning service handle = 0x%08x", __func__, (uint32_t)*pservice );
6226 +
6227 + return status;
6228 +}
6229 +
6230 +VCHIQ_STATUS_T
6231 +vchiq_open_service_params(VCHIQ_INSTANCE_T instance,
6232 + const VCHIQ_SERVICE_PARAMS_T *params,
6233 + VCHIQ_SERVICE_HANDLE_T *pservice)
6234 +{
6235 + VCHIQ_STATUS_T status;
6236 +
6237 + vcos_log_trace( "%s called fourcc = 0x%08x (%c%c%c%c)",
6238 + __func__,
6239 + params->fourcc,
6240 + (params->fourcc >> 24) & 0xff,
6241 + (params->fourcc >> 16) & 0xff,
6242 + (params->fourcc >> 8) & 0xff,
6243 + (params->fourcc ) & 0xff );
6244 +
6245 + if (!params->callback)
6246 + return VCHIQ_ERROR;
6247 +
6248 + if (!is_valid_instance(instance))
6249 + return VCHIQ_ERROR;
6250 +
6251 + status = create_service(instance,
6252 + params,
6253 + NULL/*vchi_callback*/,
6254 + 1/*open*/,
6255 + pservice);
6256 +
6257 + vcos_log_trace( "%s returning service handle = 0x%08x", __func__, (uint32_t)*pservice );
6258 +
6259 + return status;
6260 +}
6261 +
6262 +VCHIQ_STATUS_T
6263 +vchiq_close_service(VCHIQ_SERVICE_HANDLE_T handle)
6264 +{
6265 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6266 + int ret;
6267 +
6268 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6269 +
6270 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_CLOSE_SERVICE, service->handle));
6271 +
6272 + if (ret != 0)
6273 + return VCHIQ_ERROR;
6274 +
6275 + service->handle = VCHIQ_INVALID_HANDLE;
6276 + return VCHIQ_SUCCESS;
6277 +}
6278 +
6279 +VCHIQ_STATUS_T
6280 +vchiq_remove_service(VCHIQ_SERVICE_HANDLE_T handle)
6281 +{
6282 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6283 + int ret;
6284 +
6285 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6286 +
6287 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_REMOVE_SERVICE, service->handle));
6288 +
6289 + if (ret != 0)
6290 + return VCHIQ_ERROR;
6291 +
6292 + service->handle = VCHIQ_INVALID_HANDLE;
6293 + return VCHIQ_SUCCESS;
6294 +}
6295 +
6296 +VCHIQ_STATUS_T
6297 +vchiq_queue_message(VCHIQ_SERVICE_HANDLE_T handle,
6298 + const VCHIQ_ELEMENT_T *elements,
6299 + int count)
6300 +{
6301 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6302 + VCHIQ_QUEUE_MESSAGE_T args;
6303 + int ret;
6304 +
6305 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6306 +
6307 + args.handle = service->handle;
6308 + args.elements = elements;
6309 + args.count = count;
6310 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_MESSAGE, &args));
6311 +
6312 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6313 +}
6314 +
6315 +void
6316 +vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle,
6317 + VCHIQ_HEADER_T *header)
6318 +{
6319 + vcos_log_trace( "%s handle=%08x, header=%x", __func__, (uint32_t)handle, (uint32_t)header );
6320 +
6321 + free_msgbuf(header);
6322 +}
6323 +
6324 +VCHIQ_STATUS_T
6325 +vchiq_queue_bulk_transmit(VCHIQ_SERVICE_HANDLE_T handle,
6326 + const void *data,
6327 + int size,
6328 + void *userdata)
6329 +{
6330 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6331 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6332 + int ret;
6333 +
6334 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6335 +
6336 + args.handle = service->handle;
6337 + args.data = (void *)data;
6338 + args.size = size;
6339 + args.userdata = userdata;
6340 + args.mode = VCHIQ_BULK_MODE_CALLBACK;
6341 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_TRANSMIT, &args));
6342 +
6343 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6344 +}
6345 +
6346 +VCHIQ_STATUS_T
6347 +vchiq_queue_bulk_receive(VCHIQ_SERVICE_HANDLE_T handle,
6348 + void *data,
6349 + int size,
6350 + void *userdata)
6351 +{
6352 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6353 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6354 + int ret;
6355 +
6356 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6357 +
6358 + args.handle = service->handle;
6359 + args.data = data;
6360 + args.size = size;
6361 + args.userdata = userdata;
6362 + args.mode = VCHIQ_BULK_MODE_CALLBACK;
6363 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_RECEIVE, &args));
6364 +
6365 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6366 +}
6367 +
6368 +VCHIQ_STATUS_T
6369 +vchiq_queue_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T handle,
6370 + VCHI_MEM_HANDLE_T memhandle,
6371 + const void *offset,
6372 + int size,
6373 + void *userdata)
6374 +{
6375 + vcos_assert(memhandle == VCHI_MEM_HANDLE_INVALID);
6376 +
6377 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6378 +
6379 + return vchiq_queue_bulk_transmit(handle, offset, size, userdata);
6380 +}
6381 +
6382 +VCHIQ_STATUS_T
6383 +vchiq_queue_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T handle,
6384 + VCHI_MEM_HANDLE_T memhandle,
6385 + void *offset,
6386 + int size,
6387 + void *userdata)
6388 +{
6389 + vcos_assert(memhandle == VCHI_MEM_HANDLE_INVALID);
6390 +
6391 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6392 +
6393 + return vchiq_queue_bulk_receive(handle, offset, size, userdata);
6394 +}
6395 +
6396 +VCHIQ_STATUS_T
6397 +vchiq_bulk_transmit(VCHIQ_SERVICE_HANDLE_T handle,
6398 + const void *data,
6399 + int size,
6400 + void *userdata,
6401 + VCHIQ_BULK_MODE_T mode)
6402 +{
6403 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6404 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6405 + int ret;
6406 +
6407 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6408 +
6409 + args.handle = service->handle;
6410 + args.data = (void *)data;
6411 + args.size = size;
6412 + args.userdata = userdata;
6413 + args.mode = mode;
6414 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_TRANSMIT, &args));
6415 +
6416 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6417 +}
6418 +
6419 +VCHIQ_STATUS_T
6420 +vchiq_bulk_receive(VCHIQ_SERVICE_HANDLE_T handle,
6421 + void *data,
6422 + int size,
6423 + void *userdata,
6424 + VCHIQ_BULK_MODE_T mode)
6425 +{
6426 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6427 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6428 + int ret;
6429 +
6430 + vcos_log_trace( "%s called service handle = 0x%08x", __func__, (uint32_t)handle );
6431 +
6432 + args.handle = service->handle;
6433 + args.data = data;
6434 + args.size = size;
6435 + args.userdata = userdata;
6436 + args.mode = mode;
6437 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_RECEIVE, &args));
6438 +
6439 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6440 +}
6441 +
6442 +VCHIQ_STATUS_T
6443 +vchiq_bulk_transmit_handle(VCHIQ_SERVICE_HANDLE_T handle,
6444 + VCHI_MEM_HANDLE_T memhandle,
6445 + const void *offset,
6446 + int size,
6447 + void *userdata,
6448 + VCHIQ_BULK_MODE_T mode)
6449 +{
6450 + vcos_assert(memhandle == VCHI_MEM_HANDLE_INVALID);
6451 +
6452 + return vchiq_bulk_transmit(handle, offset, size, userdata, mode);
6453 +}
6454 +
6455 +VCHIQ_STATUS_T
6456 +vchiq_bulk_receive_handle(VCHIQ_SERVICE_HANDLE_T handle,
6457 + VCHI_MEM_HANDLE_T memhandle,
6458 + void *offset,
6459 + int size,
6460 + void *userdata,
6461 + VCHIQ_BULK_MODE_T mode)
6462 +{
6463 + vcos_assert(memhandle == VCHI_MEM_HANDLE_INVALID);
6464 +
6465 + return vchiq_bulk_receive(handle, offset, size, userdata, mode);
6466 +}
6467 +
6468 +int
6469 +vchiq_get_client_id(VCHIQ_SERVICE_HANDLE_T handle)
6470 +{
6471 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6472 +
6473 + return ioctl(service->fd, VCHIQ_IOC_GET_CLIENT_ID, service->handle);
6474 +}
6475 +
6476 +VCHIQ_STATUS_T
6477 +vchiq_get_config(VCHIQ_INSTANCE_T instance,
6478 + int config_size,
6479 + VCHIQ_CONFIG_T *pconfig)
6480 +{
6481 + VCHIQ_GET_CONFIG_T args;
6482 + int ret;
6483 +
6484 + if (!is_valid_instance(instance))
6485 + return VCHIQ_ERROR;
6486 +
6487 + args.config_size = config_size;
6488 + args.pconfig = pconfig;
6489 +
6490 + RETRY(ret, ioctl(instance->fd, VCHIQ_IOC_GET_CONFIG, &args));
6491 +
6492 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6493 +}
6494 +
6495 +int32_t
6496 +vchiq_use_service( const VCHIQ_SERVICE_HANDLE_T handle )
6497 +{
6498 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6499 + int ret;
6500 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_USE_SERVICE, service->handle));
6501 + return ret;
6502 +}
6503 +
6504 +int32_t
6505 +vchiq_release_service( const VCHIQ_SERVICE_HANDLE_T handle )
6506 +{
6507 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6508 + int ret;
6509 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_RELEASE_SERVICE, service->handle));
6510 + return ret;
6511 +}
6512 +
6513 +VCHIQ_STATUS_T
6514 +vchiq_set_service_option(VCHIQ_SERVICE_HANDLE_T handle,
6515 + VCHIQ_SERVICE_OPTION_T option, int value)
6516 +{
6517 + VCHIQ_SET_SERVICE_OPTION_T args;
6518 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)handle;
6519 + int ret;
6520 +
6521 + args.handle = service->handle;
6522 + args.option = option;
6523 + args.value = value;
6524 +
6525 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_SET_SERVICE_OPTION, &args));
6526 +
6527 + return (ret >= 0) ? VCHIQ_SUCCESS : VCHIQ_ERROR;
6528 +}
6529 +
6530 +/*
6531 + * VCHI API
6532 + */
6533 +
6534 +/* ----------------------------------------------------------------------
6535 + * return pointer to the mphi message driver function table
6536 + * -------------------------------------------------------------------- */
6537 +const VCHI_MESSAGE_DRIVER_T *
6538 +vchi_mphi_message_driver_func_table( void )
6539 +{
6540 + return NULL;
6541 +}
6542 +
6543 +/* ----------------------------------------------------------------------
6544 + * return a pointer to the 'single' connection driver fops
6545 + * -------------------------------------------------------------------- */
6546 +const VCHI_CONNECTION_API_T *
6547 +single_get_func_table( void )
6548 +{
6549 + return NULL;
6550 +}
6551 +
6552 +VCHI_CONNECTION_T *
6553 +vchi_create_connection( const VCHI_CONNECTION_API_T * function_table,
6554 + const VCHI_MESSAGE_DRIVER_T * low_level )
6555 +{
6556 + vcos_unused(function_table);
6557 + vcos_unused(low_level);
6558 +
6559 + return NULL;
6560 +}
6561 +
6562 +/***********************************************************
6563 + * Name: vchi_msg_peek
6564 + *
6565 + * Arguments: const VCHI_SERVICE_HANDLE_T handle,
6566 + * void **data,
6567 + * uint32_t *msg_size,
6568 + * VCHI_FLAGS_T flags
6569 + *
6570 + * Description: Routine to return a pointer to the current message (to allow in place processing)
6571 + * The message can be removed using vchi_msg_remove when you're finished
6572 + *
6573 + * Returns: int32_t - success == 0
6574 + *
6575 + ***********************************************************/
6576 +int32_t
6577 +vchi_msg_peek( VCHI_SERVICE_HANDLE_T handle,
6578 + void **data,
6579 + uint32_t *msg_size,
6580 + VCHI_FLAGS_T flags )
6581 +{
6582 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6583 + int ret;
6584 +
6585 + ret = fill_peek_buf(service, flags);
6586 +
6587 + if (ret == 0)
6588 + {
6589 + *data = service->peek_buf;
6590 + *msg_size = service->peek_size;
6591 + }
6592 +
6593 + return ret;
6594 +}
6595 +
6596 +/***********************************************************
6597 + * Name: vchi_msg_remove
6598 + *
6599 + * Arguments: const VCHI_SERVICE_HANDLE_T handle,
6600 + *
6601 + * Description: Routine to remove a message (after it has been read with vchi_msg_peek)
6602 + *
6603 + * Returns: int32_t - success == 0
6604 + *
6605 + ***********************************************************/
6606 +int32_t
6607 +vchi_msg_remove( VCHI_SERVICE_HANDLE_T handle )
6608 +{
6609 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6610 +
6611 + /* Why would you call vchi_msg_remove without calling vchi_msg_peek first? */
6612 + vcos_assert(service->peek_size >= 0);
6613 +
6614 + /* Invalidate the content but reuse the buffer */
6615 + service->peek_size = -1;
6616 +
6617 + return 0;
6618 +}
6619 +
6620 +/***********************************************************
6621 + * Name: vchi_msg_queue
6622 + *
6623 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
6624 + * const void *data,
6625 + * uint32_t data_size,
6626 + * VCHI_FLAGS_T flags,
6627 + * void *msg_handle,
6628 + *
6629 + * Description: Thin wrapper to queue a message onto a connection
6630 + *
6631 + * Returns: int32_t - success == 0
6632 + *
6633 + ***********************************************************/
6634 +int32_t
6635 +vchi_msg_queue( VCHI_SERVICE_HANDLE_T handle,
6636 + const void * data,
6637 + uint32_t data_size,
6638 + VCHI_FLAGS_T flags,
6639 + void * msg_handle )
6640 +{
6641 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6642 + VCHIQ_QUEUE_MESSAGE_T args;
6643 + VCHIQ_ELEMENT_T element = {data, data_size};
6644 + int ret;
6645 +
6646 + vcos_unused(msg_handle);
6647 + vcos_assert(flags == VCHI_FLAGS_BLOCK_UNTIL_QUEUED);
6648 +
6649 + args.handle = service->handle;
6650 + args.elements = &element;
6651 + args.count = 1;
6652 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_MESSAGE, &args));
6653 +
6654 + return ret;
6655 +}
6656 +
6657 +/***********************************************************
6658 + * Name: vchi_bulk_queue_receive
6659 + *
6660 + * Arguments: VCHI_BULK_HANDLE_T handle,
6661 + * void *data_dst,
6662 + * const uint32_t data_size,
6663 + * VCHI_FLAGS_T flags
6664 + * void *bulk_handle
6665 + *
6666 + * Description: Routine to setup a rcv buffer
6667 + *
6668 + * Returns: int32_t - success == 0
6669 + *
6670 + ***********************************************************/
6671 +int32_t
6672 +vchi_bulk_queue_receive( VCHI_SERVICE_HANDLE_T handle,
6673 + void * data_dst,
6674 + uint32_t data_size,
6675 + VCHI_FLAGS_T flags,
6676 + void * bulk_handle )
6677 +{
6678 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6679 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6680 + int ret;
6681 +
6682 + switch ((int)flags) {
6683 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
6684 + args.mode = VCHIQ_BULK_MODE_CALLBACK;
6685 + break;
6686 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
6687 + args.mode = VCHIQ_BULK_MODE_BLOCKING;
6688 + break;
6689 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
6690 + case VCHI_FLAGS_NONE:
6691 + args.mode = VCHIQ_BULK_MODE_NOCALLBACK;
6692 + break;
6693 + default:
6694 + vcos_assert(0);
6695 + break;
6696 + }
6697 +
6698 + args.handle = service->handle;
6699 + args.data = data_dst;
6700 + args.size = data_size;
6701 + args.userdata = bulk_handle;
6702 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_RECEIVE, &args));
6703 +
6704 + return ret;
6705 +}
6706 +
6707 +/***********************************************************
6708 + * Name: vchi_bulk_queue_transmit
6709 + *
6710 + * Arguments: VCHI_BULK_HANDLE_T handle,
6711 + * const void *data_src,
6712 + * uint32_t data_size,
6713 + * VCHI_FLAGS_T flags,
6714 + * void *bulk_handle
6715 + *
6716 + * Description: Routine to transmit some data
6717 + *
6718 + * Returns: int32_t - success == 0
6719 + *
6720 + ***********************************************************/
6721 +int32_t
6722 +vchi_bulk_queue_transmit( VCHI_SERVICE_HANDLE_T handle,
6723 + const void * data_src,
6724 + uint32_t data_size,
6725 + VCHI_FLAGS_T flags,
6726 + void * bulk_handle )
6727 +{
6728 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6729 + VCHIQ_QUEUE_BULK_TRANSFER_T args;
6730 + int ret;
6731 +
6732 + switch ((int)flags) {
6733 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
6734 + args.mode = VCHIQ_BULK_MODE_CALLBACK;
6735 + break;
6736 + case VCHI_FLAGS_BLOCK_UNTIL_DATA_READ:
6737 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
6738 + args.mode = VCHIQ_BULK_MODE_BLOCKING;
6739 + break;
6740 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
6741 + case VCHI_FLAGS_NONE:
6742 + args.mode = VCHIQ_BULK_MODE_NOCALLBACK;
6743 + break;
6744 + default:
6745 + vcos_assert(0);
6746 + break;
6747 + }
6748 +
6749 + args.handle = service->handle;
6750 + args.data = (void *)data_src;
6751 + args.size = data_size;
6752 + args.userdata = bulk_handle;
6753 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_BULK_TRANSMIT, &args));
6754 +
6755 + return ret;
6756 +}
6757 +
6758 +/***********************************************************
6759 + * Name: vchi_msg_dequeue
6760 + *
6761 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
6762 + * void *data,
6763 + * uint32_t max_data_size_to_read,
6764 + * uint32_t *actual_msg_size
6765 + * VCHI_FLAGS_T flags
6766 + *
6767 + * Description: Routine to dequeue a message into the supplied buffer
6768 + *
6769 + * Returns: int32_t - success == 0
6770 + *
6771 + ***********************************************************/
6772 +int32_t
6773 +vchi_msg_dequeue( VCHI_SERVICE_HANDLE_T handle,
6774 + void *data,
6775 + uint32_t max_data_size_to_read,
6776 + uint32_t *actual_msg_size,
6777 + VCHI_FLAGS_T flags )
6778 +{
6779 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6780 + VCHIQ_DEQUEUE_MESSAGE_T args;
6781 + int ret;
6782 +
6783 + vcos_assert(flags == VCHI_FLAGS_NONE || flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
6784 +
6785 + if (service->peek_size >= 0)
6786 + {
6787 + fprintf(stderr, "vchi_msg_dequeue -> using peek buffer\n");
6788 + if ((uint32_t)service->peek_size <= max_data_size_to_read)
6789 + {
6790 + memcpy(data, service->peek_buf, service->peek_size);
6791 + *actual_msg_size = service->peek_size;
6792 + /* Invalidate the peek data, but retain the buffer */
6793 + service->peek_size = -1;
6794 + ret = 0;
6795 + }
6796 + else
6797 + {
6798 + ret = -1;
6799 + }
6800 + }
6801 + else
6802 + {
6803 + args.handle = service->handle;
6804 + args.blocking = (flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
6805 + args.bufsize = max_data_size_to_read;
6806 + args.buf = data;
6807 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_DEQUEUE_MESSAGE, &args));
6808 + if (ret >= 0)
6809 + {
6810 + *actual_msg_size = ret;
6811 + ret = 0;
6812 + }
6813 + }
6814 +
6815 + if ((ret < 0) && (errno != EWOULDBLOCK))
6816 + fprintf(stderr, "vchi_msg_dequeue -> %d(%d)\n", ret, errno);
6817 +
6818 + return ret;
6819 +}
6820 +
6821 +/***********************************************************
6822 + * Name: vchi_msg_queuev
6823 + *
6824 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
6825 + * const void *data,
6826 + * uint32_t data_size,
6827 + * VCHI_FLAGS_T flags,
6828 + * void *msg_handle
6829 + *
6830 + * Description: Thin wrapper to queue a message onto a connection
6831 + *
6832 + * Returns: int32_t - success == 0
6833 + *
6834 + ***********************************************************/
6835 +
6836 +vcos_static_assert(sizeof(VCHI_MSG_VECTOR_T) == sizeof(VCHIQ_ELEMENT_T));
6837 +vcos_static_assert(offsetof(VCHI_MSG_VECTOR_T, vec_base) == offsetof(VCHIQ_ELEMENT_T, data));
6838 +vcos_static_assert(offsetof(VCHI_MSG_VECTOR_T, vec_len) == offsetof(VCHIQ_ELEMENT_T, size));
6839 +
6840 +int32_t
6841 +vchi_msg_queuev( VCHI_SERVICE_HANDLE_T handle,
6842 + VCHI_MSG_VECTOR_T * vector,
6843 + uint32_t count,
6844 + VCHI_FLAGS_T flags,
6845 + void *msg_handle )
6846 +{
6847 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6848 + VCHIQ_QUEUE_MESSAGE_T args;
6849 + int ret;
6850 +
6851 + vcos_unused(msg_handle);
6852 +
6853 + vcos_assert(flags == VCHI_FLAGS_BLOCK_UNTIL_QUEUED);
6854 +
6855 + args.handle = service->handle;
6856 + args.elements = (const VCHIQ_ELEMENT_T *)vector;
6857 + args.count = count;
6858 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_QUEUE_MESSAGE, &args));
6859 +
6860 + return ret;
6861 +}
6862 +
6863 +/***********************************************************
6864 + * Name: vchi_held_msg_release
6865 + *
6866 + * Arguments: VCHI_HELD_MSG_T *message
6867 + *
6868 + * Description: Routine to release a held message (after it has been read with vchi_msg_hold)
6869 + *
6870 + * Returns: int32_t - success == 0
6871 + *
6872 + ***********************************************************/
6873 +int32_t
6874 +vchi_held_msg_release( VCHI_HELD_MSG_T *message )
6875 +{
6876 + int ret = -1;
6877 +
6878 + if (message && message->message && !message->service)
6879 + {
6880 + free_msgbuf(message->message);
6881 + ret = 0;
6882 + }
6883 +
6884 + return ret;
6885 +}
6886 +
6887 +/***********************************************************
6888 + * Name: vchi_msg_hold
6889 + *
6890 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
6891 + * void **data,
6892 + * uint32_t *msg_size,
6893 + * VCHI_FLAGS_T flags,
6894 + * VCHI_HELD_MSG_T *message_handle
6895 + *
6896 + * Description: Routine to return a pointer to the current message (to allow in place processing)
6897 + * The message is dequeued - don't forget to release the message using
6898 + * vchi_held_msg_release when you're finished
6899 + *
6900 + * Returns: int32_t - success == 0
6901 + *
6902 + ***********************************************************/
6903 +int32_t
6904 +vchi_msg_hold( VCHI_SERVICE_HANDLE_T handle,
6905 + void **data,
6906 + uint32_t *msg_size,
6907 + VCHI_FLAGS_T flags,
6908 + VCHI_HELD_MSG_T *message_handle )
6909 +{
6910 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
6911 + int ret;
6912 +
6913 + ret = fill_peek_buf(service, flags);
6914 +
6915 + if (ret == 0)
6916 + {
6917 + *data = service->peek_buf;
6918 + *msg_size = service->peek_size;
6919 +
6920 + message_handle->message = service->peek_buf;
6921 + message_handle->service = NULL;
6922 +
6923 + service->peek_size = -1;
6924 + service->peek_buf = NULL;
6925 + }
6926 +
6927 + return 0;
6928 +}
6929 +
6930 +/***********************************************************
6931 + * Name: vchi_initialise
6932 + *
6933 + * Arguments: VCHI_INSTANCE_T *instance_handle
6934 + * VCHI_CONNECTION_T **connections
6935 + * const uint32_t num_connections
6936 + *
6937 + * Description: Initialises the hardware but does not transmit anything
6938 + * When run as a Host App this will be called twice hence the need
6939 + * to malloc the state information
6940 + *
6941 + * Returns: 0 if successful, failure otherwise
6942 + *
6943 + ***********************************************************/
6944 +int32_t
6945 +vchi_initialise( VCHI_INSTANCE_T *instance_handle )
6946 +{
6947 + VCHIQ_INSTANCE_T instance;
6948 +
6949 + instance = vchiq_lib_init();
6950 +
6951 + vcos_log_trace( "%s: returning instance handle %p", __func__, instance );
6952 +
6953 + *instance_handle = (VCHI_INSTANCE_T)instance;
6954 +
6955 + return (instance != NULL) ? 0 : -1;
6956 +}
6957 +
6958 +/***********************************************************
6959 + * Name: vchi_connect
6960 + *
6961 + * Arguments: VCHI_CONNECTION_T **connections
6962 + * const uint32_t num_connections
6963 + * VCHI_INSTANCE_T instance_handle )
6964 + *
6965 + * Description: Starts the command service on each connection,
6966 + * causing INIT messages to be pinged back and forth
6967 + *
6968 + * Returns: 0 if successful, failure otherwise
6969 + *
6970 + ***********************************************************/
6971 +int32_t
6972 +vchi_connect( VCHI_CONNECTION_T **connections,
6973 + const uint32_t num_connections,
6974 + VCHI_INSTANCE_T instance_handle )
6975 +{
6976 + VCHIQ_STATUS_T status;
6977 +
6978 + vcos_unused(connections);
6979 + vcos_unused(num_connections);
6980 +
6981 + status = vchiq_connect((VCHIQ_INSTANCE_T)instance_handle);
6982 +
6983 + return (status == VCHIQ_SUCCESS) ? 0 : -1;
6984 +}
6985 +
6986 +
6987 +/***********************************************************
6988 + * Name: vchi_disconnect
6989 + *
6990 + * Arguments: VCHI_INSTANCE_T instance_handle
6991 + *
6992 + * Description: Stops the command service on each connection,
6993 + * causing DE-INIT messages to be pinged back and forth
6994 + *
6995 + * Returns: 0 if successful, failure otherwise
6996 + *
6997 + ***********************************************************/
6998 +int32_t
6999 +vchi_disconnect( VCHI_INSTANCE_T instance_handle )
7000 +{
7001 + VCHIQ_STATUS_T status;
7002 +
7003 + status = vchiq_shutdown((VCHIQ_INSTANCE_T)instance_handle);
7004 +
7005 + return (status == VCHIQ_SUCCESS) ? 0 : -1;
7006 +}
7007 +
7008 +
7009 +/***********************************************************
7010 + * Name: vchi_service_open
7011 + * Name: vchi_service_create
7012 + *
7013 + * Arguments: VCHI_INSTANCE_T *instance_handle
7014 + * SERVICE_CREATION_T *setup,
7015 + * VCHI_SERVICE_HANDLE_T *handle
7016 + *
7017 + * Description: Routine to open a service
7018 + *
7019 + * Returns: int32_t - success == 0
7020 + *
7021 + ***********************************************************/
7022 +int32_t
7023 +vchi_service_open( VCHI_INSTANCE_T instance_handle,
7024 + SERVICE_CREATION_T *setup,
7025 + VCHI_SERVICE_HANDLE_T *handle )
7026 +{
7027 + VCHIQ_SERVICE_PARAMS_T params;
7028 + VCHIQ_STATUS_T status;
7029 +
7030 + memset(&params, 0, sizeof(params));
7031 + params.fourcc = setup->service_id;
7032 + params.userdata = setup->callback_param;
7033 +
7034 + status = create_service((VCHIQ_INSTANCE_T)instance_handle,
7035 + &params,
7036 + setup->callback,
7037 + 1/*open*/,
7038 + (VCHIQ_SERVICE_HANDLE_T *)handle);
7039 +
7040 + return (status == VCHIQ_SUCCESS) ? 0 : -1;
7041 +}
7042 +
7043 +int32_t
7044 +vchi_service_create( VCHI_INSTANCE_T instance_handle,
7045 + SERVICE_CREATION_T *setup, VCHI_SERVICE_HANDLE_T *handle )
7046 +{
7047 + VCHIQ_SERVICE_PARAMS_T params;
7048 + VCHIQ_STATUS_T status;
7049 +
7050 + memset(&params, 0, sizeof(params));
7051 + params.fourcc = setup->service_id;
7052 + params.userdata = setup->callback_param;
7053 +
7054 + status = create_service((VCHIQ_INSTANCE_T)instance_handle,
7055 + &params,
7056 + setup->callback,
7057 + 0/*!open*/,
7058 + (VCHIQ_SERVICE_HANDLE_T *)handle);
7059 +
7060 + return (status == VCHIQ_SUCCESS) ? 0 : -1;
7061 +}
7062 +
7063 +int32_t
7064 +vchi_service_close( const VCHI_SERVICE_HANDLE_T handle )
7065 +{
7066 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
7067 + int ret;
7068 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_REMOVE_SERVICE, service->handle));
7069 +
7070 + if (ret == 0)
7071 + service->handle = VCHIQ_INVALID_HANDLE;
7072 +
7073 + return ret;
7074 +}
7075 +
7076 +int32_t
7077 +vchi_service_destroy( const VCHI_SERVICE_HANDLE_T handle )
7078 +{
7079 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
7080 + int ret;
7081 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_REMOVE_SERVICE, service->handle));
7082 +
7083 + if (ret == 0)
7084 + service->handle = VCHIQ_INVALID_HANDLE;
7085 +
7086 + return ret;
7087 +}
7088 +
7089 +/* ----------------------------------------------------------------------
7090 + * read a uint32_t from buffer.
7091 + * network format is defined to be little endian
7092 + * -------------------------------------------------------------------- */
7093 +uint32_t
7094 +vchi_readbuf_uint32( const void *_ptr )
7095 +{
7096 + const unsigned char *ptr = _ptr;
7097 + return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
7098 +}
7099 +
7100 +/* ----------------------------------------------------------------------
7101 + * write a uint32_t to buffer.
7102 + * network format is defined to be little endian
7103 + * -------------------------------------------------------------------- */
7104 +void
7105 +vchi_writebuf_uint32( void *_ptr, uint32_t value )
7106 +{
7107 + unsigned char *ptr = _ptr;
7108 + ptr[0] = (unsigned char)((value >> 0) & 0xFF);
7109 + ptr[1] = (unsigned char)((value >> 8) & 0xFF);
7110 + ptr[2] = (unsigned char)((value >> 16) & 0xFF);
7111 + ptr[3] = (unsigned char)((value >> 24) & 0xFF);
7112 +}
7113 +
7114 +/* ----------------------------------------------------------------------
7115 + * read a uint16_t from buffer.
7116 + * network format is defined to be little endian
7117 + * -------------------------------------------------------------------- */
7118 +uint16_t
7119 +vchi_readbuf_uint16( const void *_ptr )
7120 +{
7121 + const unsigned char *ptr = _ptr;
7122 + return ptr[0] | (ptr[1] << 8);
7123 +}
7124 +
7125 +/* ----------------------------------------------------------------------
7126 + * write a uint16_t into the buffer.
7127 + * network format is defined to be little endian
7128 + * -------------------------------------------------------------------- */
7129 +void
7130 +vchi_writebuf_uint16( void *_ptr, uint16_t value )
7131 +{
7132 + unsigned char *ptr = _ptr;
7133 + ptr[0] = (value >> 0) & 0xFF;
7134 + ptr[1] = (value >> 8) & 0xFF;
7135 +}
7136 +
7137 +/***********************************************************
7138 + * Name: vchi_service_use
7139 + *
7140 + * Arguments: const VCHI_SERVICE_HANDLE_T handle
7141 + *
7142 + * Description: Routine to increment refcount on a service
7143 + *
7144 + * Returns: void
7145 + *
7146 + ***********************************************************/
7147 +int32_t
7148 +vchi_service_use( const VCHI_SERVICE_HANDLE_T handle )
7149 +{
7150 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
7151 + int ret;
7152 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_USE_SERVICE, service->handle));
7153 + return ret;
7154 +}
7155 +
7156 +/***********************************************************
7157 + * Name: vchi_service_release
7158 + *
7159 + * Arguments: const VCHI_SERVICE_HANDLE_T handle
7160 + *
7161 + * Description: Routine to decrement refcount on a service
7162 + *
7163 + * Returns: void
7164 + *
7165 + ***********************************************************/
7166 +int32_t vchi_service_release( const VCHI_SERVICE_HANDLE_T handle )
7167 +{
7168 + VCHI_SERVICE_T *service = (VCHI_SERVICE_T *)handle;
7169 + int ret;
7170 + RETRY(ret,ioctl(service->fd, VCHIQ_IOC_RELEASE_SERVICE, service->handle));
7171 + return ret;
7172 +}
7173 +
7174 +/*
7175 + * Support functions
7176 + */
7177 +
7178 +static VCHIQ_INSTANCE_T
7179 +vchiq_lib_init(void)
7180 +{
7181 + static int mutex_initialised = 0;
7182 + static VCOS_MUTEX_T vchiq_lib_mutex;
7183 + VCHIQ_INSTANCE_T instance = &vchiq_instance;
7184 +
7185 + vcos_global_lock();
7186 + if (!mutex_initialised)
7187 + {
7188 + vcos_mutex_create(&vchiq_lib_mutex, "vchiq-init");
7189 +
7190 + vcos_log_set_level( &vchiq_lib_log_category, vchiq_default_lib_log_level );
7191 + vcos_log_register( "vchiq_lib", &vchiq_lib_log_category );
7192 +
7193 + mutex_initialised = 1;
7194 + }
7195 + vcos_global_unlock();
7196 +
7197 + vcos_mutex_lock(&vchiq_lib_mutex);
7198 +
7199 + if (instance->initialised == 0)
7200 + {
7201 + instance->fd = open("/dev/vchiq", O_RDWR);
7202 + if (instance->fd >= 0)
7203 + {
7204 + VCHIQ_GET_CONFIG_T args;
7205 + VCHIQ_CONFIG_T config;
7206 + int ret;
7207 + args.config_size = sizeof(config);
7208 + args.pconfig = &config;
7209 + RETRY(ret, ioctl(instance->fd, VCHIQ_IOC_GET_CONFIG, &args));
7210 + if ((ret == 0) && (config.version >= VCHIQ_VERSION_MIN) && (config.version_min <= VCHIQ_VERSION))
7211 + {
7212 + instance->used_services = 0;
7213 + vcos_mutex_create(&instance->mutex, "VCHIQ instance");
7214 + instance->initialised = 1;
7215 + }
7216 + else
7217 + {
7218 + if (ret == 0)
7219 + {
7220 + vcos_log_error("Incompatible VCHIQ library - driver version %d (min %d), library version %d (min %d)",
7221 + config.version, config.version_min, VCHIQ_VERSION, VCHIQ_VERSION_MIN);
7222 + }
7223 + else
7224 + {
7225 + vcos_log_error("Very incompatible VCHIQ library - cannot retrieve driver version");
7226 + }
7227 + close(instance->fd);
7228 + instance = NULL;
7229 + }
7230 + }
7231 + else
7232 + {
7233 + instance = NULL;
7234 + }
7235 + }
7236 + else if (instance->initialised > 0)
7237 + {
7238 + instance->initialised++;
7239 + }
7240 +
7241 + vcos_mutex_unlock(&vchiq_lib_mutex);
7242 +
7243 + return instance;
7244 +}
7245 +
7246 +static void *
7247 +completion_thread(void *arg)
7248 +{
7249 + VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)arg;
7250 + VCHIQ_AWAIT_COMPLETION_T args;
7251 + VCHIQ_COMPLETION_DATA_T completions[8];
7252 + void *msgbufs[8];
7253 +
7254 + static const VCHI_CALLBACK_REASON_T vchiq_reason_to_vchi[] =
7255 + {
7256 + VCHI_CALLBACK_SERVICE_OPENED, // VCHIQ_SERVICE_OPENED
7257 + VCHI_CALLBACK_SERVICE_CLOSED, // VCHIQ_SERVICE_CLOSED
7258 + VCHI_CALLBACK_MSG_AVAILABLE, // VCHIQ_MESSAGE_AVAILABLE
7259 + VCHI_CALLBACK_BULK_SENT, // VCHIQ_BULK_TRANSMIT_DONE
7260 + VCHI_CALLBACK_BULK_RECEIVED, // VCHIQ_BULK_RECEIVE_DONE
7261 + VCHI_CALLBACK_BULK_TRANSMIT_ABORTED, // VCHIQ_BULK_TRANSMIT_ABORTED
7262 + VCHI_CALLBACK_BULK_RECEIVE_ABORTED, // VCHIQ_BULK_RECEIVE_ABORTED
7263 + };
7264 +
7265 + args.count = vcos_countof(completions);
7266 + args.buf = completions;
7267 + args.msgbufsize = MSGBUF_SIZE;
7268 + args.msgbufcount = 0;
7269 + args.msgbufs = msgbufs;
7270 +
7271 + while (1)
7272 + {
7273 + int ret, i;
7274 +
7275 + while ((unsigned int)args.msgbufcount < vcos_countof(msgbufs))
7276 + {
7277 + void *msgbuf = alloc_msgbuf();
7278 + if (msgbuf)
7279 + {
7280 + msgbufs[args.msgbufcount++] = msgbuf;
7281 + }
7282 + else
7283 + {
7284 + fprintf(stderr, "vchiq_lib: failed to allocate a message buffer\n");
7285 + vcos_demand(args.msgbufcount != 0);
7286 + }
7287 + }
7288 +
7289 + RETRY(ret, ioctl(instance->fd, VCHIQ_IOC_AWAIT_COMPLETION, &args));
7290 +
7291 + if (ret <= 0)
7292 + break;
7293 +
7294 + for (i = 0; i < ret; i++)
7295 + {
7296 + VCHIQ_COMPLETION_DATA_T *completion = &completions[i];
7297 + VCHIQ_SERVICE_T *service = (VCHIQ_SERVICE_T *)completion->service_userdata;
7298 + if (service->base.callback)
7299 + {
7300 + vcos_log_trace( "callback(%x, %x, %x, %x)",
7301 + completion->reason, (uint32_t)completion->header,
7302 + (uint32_t)&service->base, (uint32_t)completion->bulk_userdata );
7303 + service->base.callback(completion->reason, completion->header,
7304 + &service->base, completion->bulk_userdata);
7305 + }
7306 + else if (service->vchi_callback)
7307 + {
7308 + VCHI_CALLBACK_REASON_T vchi_reason =
7309 + vchiq_reason_to_vchi[completion->reason];
7310 + service->vchi_callback(service->base.userdata, vchi_reason, completion->bulk_userdata);
7311 + }
7312 + }
7313 + }
7314 + return NULL;
7315 +}
7316 +
7317 +static VCHIQ_STATUS_T
7318 +create_service(VCHIQ_INSTANCE_T instance,
7319 + const VCHIQ_SERVICE_PARAMS_T *params,
7320 + VCHI_CALLBACK_T vchi_callback,
7321 + int is_open,
7322 + VCHIQ_SERVICE_HANDLE_T *pservice)
7323 +{
7324 + VCHIQ_SERVICE_T *service = NULL;
7325 + VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
7326 + int i;
7327 +
7328 + if (!is_valid_instance(instance))
7329 + return VCHIQ_ERROR;
7330 +
7331 + vcos_mutex_lock(&instance->mutex);
7332 +
7333 + /* Find a free service */
7334 + if (is_open)
7335 + {
7336 + /* Find a free service */
7337 + for (i = 0; i < instance->used_services; i++)
7338 + {
7339 + if (instance->services[i].handle == VCHIQ_INVALID_HANDLE)
7340 + {
7341 + service = &instance->services[i];
7342 + break;
7343 + }
7344 + }
7345 + }
7346 + else
7347 + {
7348 + for (i = (instance->used_services - 1); i >= 0; i--)
7349 + {
7350 + VCHIQ_SERVICE_T *srv = &instance->services[i];
7351 + if (srv->handle == VCHIQ_INVALID_HANDLE)
7352 + {
7353 + service = srv;
7354 + }
7355 + else if (
7356 + (srv->base.fourcc == params->fourcc) &&
7357 + ((srv->base.callback != params->callback) ||
7358 + (srv->vchi_callback != vchi_callback)))
7359 + {
7360 + /* There is another server using this fourcc which doesn't match */
7361 + service = NULL;
7362 + status = VCHIQ_ERROR;
7363 + break;
7364 + }
7365 + }
7366 + }
7367 +
7368 + if (!service && (status == VCHIQ_SUCCESS) &&
7369 + (instance->used_services < VCHIQ_MAX_INSTANCE_SERVICES))
7370 + service = &instance->services[instance->used_services++];
7371 +
7372 + if (service)
7373 + {
7374 + VCHIQ_CREATE_SERVICE_T args;
7375 + int ret;
7376 + service->base.fourcc = params->fourcc;
7377 + service->base.callback = params->callback;
7378 + service->vchi_callback = vchi_callback;
7379 + service->base.userdata = params->userdata;
7380 + service->fd = instance->fd;
7381 + service->peek_size = -1;
7382 + service->peek_buf = NULL;
7383 +
7384 + args.params = *params;
7385 + args.params.userdata = service;
7386 + args.is_open = is_open;
7387 + args.is_vchi = (params->callback == NULL);
7388 + args.handle = -1; /* OUT parameter */
7389 + RETRY(ret, ioctl(instance->fd, VCHIQ_IOC_CREATE_SERVICE, &args));
7390 + if (ret == 0)
7391 + service->handle = args.handle;
7392 + else
7393 + status = VCHIQ_ERROR;
7394 + }
7395 +
7396 + *pservice = (status == VCHIQ_SUCCESS) ? &service->base : NULL;
7397 +
7398 + vcos_mutex_unlock(&instance->mutex);
7399 +
7400 + return status;
7401 +}
7402 +
7403 +static int
7404 +fill_peek_buf(VCHI_SERVICE_T *service,
7405 + VCHI_FLAGS_T flags)
7406 +{
7407 + VCHIQ_DEQUEUE_MESSAGE_T args;
7408 + int ret = 0;
7409 +
7410 + vcos_assert(flags == VCHI_FLAGS_NONE || flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
7411 +
7412 + if (service->peek_size < 0)
7413 + {
7414 + if (!service->peek_buf)
7415 + service->peek_buf = alloc_msgbuf();
7416 +
7417 + if (service->peek_buf)
7418 + {
7419 + args.handle = service->handle;
7420 + args.blocking = (flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
7421 + args.bufsize = MSGBUF_SIZE;
7422 + args.buf = service->peek_buf;
7423 +
7424 + RETRY(ret, ioctl(service->fd, VCHIQ_IOC_DEQUEUE_MESSAGE, &args));
7425 +
7426 + if (ret >= 0)
7427 + {
7428 + service->peek_size = ret;
7429 + ret = 0;
7430 + }
7431 + else
7432 + {
7433 + ret = -1;
7434 + }
7435 + }
7436 + else
7437 + {
7438 + ret = -1;
7439 + }
7440 + }
7441 +
7442 + return ret;
7443 +}
7444 +
7445 +
7446 +static void *
7447 +alloc_msgbuf(void)
7448 +{
7449 + void *msgbuf;
7450 + vcos_mutex_lock(&vchiq_lib_mutex);
7451 + msgbuf = free_msgbufs;
7452 + if (msgbuf)
7453 + free_msgbufs = *(void **)msgbuf;
7454 + vcos_mutex_unlock(&vchiq_lib_mutex);
7455 + if (!msgbuf)
7456 + msgbuf = malloc(MSGBUF_SIZE);
7457 + return msgbuf;
7458 +}
7459 +
7460 +static void
7461 +free_msgbuf(void *buf)
7462 +{
7463 + vcos_mutex_lock(&vchiq_lib_mutex);
7464 + *(void **)buf = free_msgbufs;
7465 + free_msgbufs = buf;
7466 + vcos_mutex_unlock(&vchiq_lib_mutex);
7467 +}
7468 --- /dev/null
7469 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_memdrv.h
7470 @@ -0,0 +1,45 @@
7471 +/*****************************************************************************
7472 +* Copyright 2001 - 2010 Broadcom Corporation. All rights reserved.
7473 +*
7474 +* Unless you and Broadcom execute a separate written software license
7475 +* agreement governing use of this software, this software is licensed to you
7476 +* under the terms of the GNU General Public License version 2, available at
7477 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
7478 +*
7479 +* Notwithstanding the above, under no circumstances may you combine this
7480 +* software in any way with any other Broadcom software provided under a
7481 +* license other than the GPL, without Broadcom's express prior written
7482 +* consent.
7483 +*****************************************************************************/
7484 +
7485 +#ifndef VCHIQ_MEMDRV_H
7486 +#define VCHIQ_MEMDRV_H
7487 +
7488 +/* ---- Include Files ----------------------------------------------------- */
7489 +
7490 +#include <linux/kernel.h>
7491 +#include "vchiq_if.h"
7492 +
7493 +/* ---- Constants and Types ---------------------------------------------- */
7494 +
7495 +typedef struct
7496 +{
7497 + void *armSharedMemVirt;
7498 + dma_addr_t armSharedMemPhys;
7499 + size_t armSharedMemSize;
7500 +
7501 + void *vcSharedMemVirt;
7502 + dma_addr_t vcSharedMemPhys;
7503 + size_t vcSharedMemSize;
7504 +
7505 +} VCHIQ_SHARED_MEM_INFO_T;
7506 +
7507 +/* ---- Variable Externs ------------------------------------------------- */
7508 +
7509 +/* ---- Function Prototypes ---------------------------------------------- */
7510 +
7511 +void vchiq_get_shared_mem_info( VCHIQ_SHARED_MEM_INFO_T *info );
7512 +
7513 +VCHIQ_STATUS_T vchiq_memdrv_initialise(void);
7514 +
7515 +#endif
7516 --- /dev/null
7517 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_pagelist.h
7518 @@ -0,0 +1,43 @@
7519 +/*
7520 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
7521 + *
7522 + * This program is free software; you can redistribute it and/or modify
7523 + * it under the terms of the GNU General Public License as published by
7524 + * the Free Software Foundation; either version 2 of the License, or
7525 + * (at your option) any later version.
7526 + *
7527 + * This program is distributed in the hope that it will be useful,
7528 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
7529 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7530 + * GNU General Public License for more details.
7531 + *
7532 + * You should have received a copy of the GNU General Public License
7533 + * along with this program; if not, write to the Free Software
7534 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
7535 + */
7536 +
7537 +#ifndef VCHIQ_PAGELIST_H
7538 +#define VCHIQ_PAGELIST_H
7539 +
7540 +#ifndef PAGE_SIZE
7541 +#define PAGE_SIZE 4096
7542 +#endif
7543 +#define CACHE_LINE_SIZE 32
7544 +#define PAGELIST_WRITE 0
7545 +#define PAGELIST_READ 1
7546 +#define PAGELIST_READ_WITH_FRAGMENTS 2
7547 +
7548 +typedef struct pagelist_struct {
7549 + unsigned long length;
7550 + unsigned short type;
7551 + unsigned short offset;
7552 + unsigned long addrs[1]; /* N.B. 12 LSBs hold the number of following
7553 + pages at consecutive addresses. */
7554 +} PAGELIST_T;
7555 +
7556 +typedef struct fragments_struct {
7557 + char headbuf[CACHE_LINE_SIZE];
7558 + char tailbuf[CACHE_LINE_SIZE];
7559 +} FRAGMENTS_T;
7560 +
7561 +#endif /* VCHIQ_PAGELIST_H */
7562 --- /dev/null
7563 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_shim.c
7564 @@ -0,0 +1,970 @@
7565 +/*
7566 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
7567 + *
7568 + * This program is free software; you can redistribute it and/or modify
7569 + * it under the terms of the GNU General Public License as published by
7570 + * the Free Software Foundation; either version 2 of the License, or
7571 + * (at your option) any later version.
7572 + *
7573 + * This program is distributed in the hope that it will be useful,
7574 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
7575 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7576 + * GNU General Public License for more details.
7577 + *
7578 + * You should have received a copy of the GNU General Public License
7579 + * along with this program; if not, write to the Free Software
7580 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
7581 + */
7582 +
7583 +#include "interface/vchi/vchi.h"
7584 +#include "vchiq.h"
7585 +#include "vchiq_core.h"
7586 +
7587 +#include "vchiq_util.h"
7588 +
7589 +#include <stddef.h>
7590 +
7591 +#if defined(__KERNEL__)
7592 +#include <linux/module.h>
7593 +#endif
7594 +
7595 +#define vchiq_status_to_vchi(status) ((int32_t)status)
7596 +
7597 +typedef struct {
7598 + VCHIQ_SERVICE_HANDLE_T handle;
7599 +
7600 + VCHIU_QUEUE_T queue;
7601 +
7602 + VCHI_CALLBACK_T callback;
7603 + void *callback_param;
7604 +} SHIM_SERVICE_T;
7605 +
7606 +/* ----------------------------------------------------------------------
7607 + * return pointer to the mphi message driver function table
7608 + * -------------------------------------------------------------------- */
7609 +#ifdef WIN32
7610 +const VCHI_MESSAGE_DRIVER_T *
7611 +mphi_get_func_table( void )
7612 +{
7613 + return NULL;
7614 +}
7615 +#endif
7616 +
7617 +/* ----------------------------------------------------------------------
7618 + * return pointer to the mphi message driver function table
7619 + * -------------------------------------------------------------------- */
7620 +const VCHI_MESSAGE_DRIVER_T *
7621 +vchi_mphi_message_driver_func_table( void )
7622 +{
7623 + return NULL;
7624 +}
7625 +
7626 +/* ----------------------------------------------------------------------
7627 + * return a pointer to the 'single' connection driver fops
7628 + * -------------------------------------------------------------------- */
7629 +const VCHI_CONNECTION_API_T *
7630 +single_get_func_table( void )
7631 +{
7632 + return NULL;
7633 +}
7634 +
7635 +VCHI_CONNECTION_T * vchi_create_connection( const VCHI_CONNECTION_API_T * function_table,
7636 + const VCHI_MESSAGE_DRIVER_T * low_level)
7637 +{
7638 + vcos_unused(function_table);
7639 + vcos_unused(low_level);
7640 + return NULL;
7641 +}
7642 +
7643 +/***********************************************************
7644 + * Name: vchi_msg_peek
7645 + *
7646 + * Arguments: const VCHI_SERVICE_HANDLE_T handle,
7647 + * void **data,
7648 + * uint32_t *msg_size,
7649 + * VCHI_FLAGS_T flags
7650 + *
7651 + * Description: Routine to return a pointer to the current message (to allow in place processing)
7652 + * The message can be removed using vchi_msg_remove when you're finished
7653 + *
7654 + * Returns: int32_t - success == 0
7655 + *
7656 + ***********************************************************/
7657 +int32_t vchi_msg_peek( VCHI_SERVICE_HANDLE_T handle,
7658 + void **data,
7659 + uint32_t *msg_size,
7660 + VCHI_FLAGS_T flags )
7661 +{
7662 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7663 + VCHIQ_HEADER_T *header;
7664 +
7665 + vcos_assert(flags == VCHI_FLAGS_NONE || flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
7666 +
7667 + if (flags == VCHI_FLAGS_NONE)
7668 + if (vchiu_queue_is_empty(&service->queue))
7669 + return -1;
7670 +
7671 + header = vchiu_queue_peek(&service->queue);
7672 +
7673 + *data = header->data;
7674 + *msg_size = header->size;
7675 +
7676 + return 0;
7677 +}
7678 +
7679 +/***********************************************************
7680 + * Name: vchi_msg_remove
7681 + *
7682 + * Arguments: const VCHI_SERVICE_HANDLE_T handle,
7683 + *
7684 + * Description: Routine to remove a message (after it has been read with vchi_msg_peek)
7685 + *
7686 + * Returns: int32_t - success == 0
7687 + *
7688 + ***********************************************************/
7689 +int32_t vchi_msg_remove( VCHI_SERVICE_HANDLE_T handle )
7690 +{
7691 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7692 + VCHIQ_HEADER_T *header;
7693 +
7694 + header = vchiu_queue_pop(&service->queue);
7695 +
7696 + vchiq_release_message(service->handle, header);
7697 +
7698 + return 0;
7699 +}
7700 +
7701 +/***********************************************************
7702 + * Name: vchi_msg_queue
7703 + *
7704 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
7705 + * const void *data,
7706 + * uint32_t data_size,
7707 + * VCHI_FLAGS_T flags,
7708 + * void *msg_handle,
7709 + *
7710 + * Description: Thin wrapper to queue a message onto a connection
7711 + *
7712 + * Returns: int32_t - success == 0
7713 + *
7714 + ***********************************************************/
7715 +int32_t vchi_msg_queue( VCHI_SERVICE_HANDLE_T handle,
7716 + const void * data,
7717 + uint32_t data_size,
7718 + VCHI_FLAGS_T flags,
7719 + void * msg_handle )
7720 +{
7721 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7722 + VCHIQ_ELEMENT_T element = {data, data_size};
7723 + VCHIQ_STATUS_T status;
7724 +
7725 + vcos_unused(msg_handle);
7726 +
7727 + vcos_assert(flags == VCHI_FLAGS_BLOCK_UNTIL_QUEUED);
7728 +
7729 + status = vchiq_queue_message(service->handle, &element, 1);
7730 +
7731 + // On some platforms, like linux kernel, vchiq_queue_message() may return
7732 + // VCHIQ_RETRY, so we need to implment a retry mechanism since this
7733 + // function is supposed to block until queued
7734 + while ( status == VCHIQ_RETRY )
7735 + {
7736 + vcos_sleep( 1 );
7737 + status = vchiq_queue_message(service->handle, &element, 1);
7738 + }
7739 +
7740 + return vchiq_status_to_vchi(status);
7741 +}
7742 +
7743 +/***********************************************************
7744 + * Name: vchi_bulk_queue_receive
7745 + *
7746 + * Arguments: VCHI_BULK_HANDLE_T handle,
7747 + * void *data_dst,
7748 + * const uint32_t data_size,
7749 + * VCHI_FLAGS_T flags
7750 + * void *bulk_handle
7751 + *
7752 + * Description: Routine to setup a rcv buffer
7753 + *
7754 + * Returns: int32_t - success == 0
7755 + *
7756 + ***********************************************************/
7757 +int32_t vchi_bulk_queue_receive( VCHI_SERVICE_HANDLE_T handle,
7758 + void * data_dst,
7759 + uint32_t data_size,
7760 + VCHI_FLAGS_T flags,
7761 + void * bulk_handle )
7762 +{
7763 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7764 + VCHIQ_BULK_MODE_T mode;
7765 + VCHIQ_STATUS_T status;
7766 +
7767 + switch ((int)flags) {
7768 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7769 + vcos_assert(service->callback);
7770 + mode = VCHIQ_BULK_MODE_CALLBACK;
7771 + break;
7772 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
7773 + mode = VCHIQ_BULK_MODE_BLOCKING;
7774 + break;
7775 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7776 + case VCHI_FLAGS_NONE:
7777 + mode = VCHIQ_BULK_MODE_NOCALLBACK;
7778 + break;
7779 + default:
7780 + vcos_assert(0);
7781 + return vchiq_status_to_vchi(VCHIQ_ERROR);
7782 + }
7783 +
7784 + status = vchiq_bulk_receive(service->handle, data_dst, data_size,
7785 + bulk_handle, mode);
7786 +
7787 + // On some platforms, like linux kernel, vchiq_bulk_receive() may return
7788 + // VCHIQ_RETRY, so we need to implment a retry mechanism since this
7789 + // function is supposed to block until queued
7790 + while ( status == VCHIQ_RETRY )
7791 + {
7792 + vcos_sleep( 1 );
7793 + status = vchiq_bulk_receive(service->handle, data_dst, data_size,
7794 + bulk_handle, mode);
7795 + }
7796 +
7797 + return vchiq_status_to_vchi(status);
7798 +}
7799 +
7800 +/***********************************************************
7801 + * Name: vchi_bulk_queue_receive_reloc
7802 + *
7803 + * Arguments: VCHI_BULK_HANDLE_T handle,
7804 + * VCHI_MEM_HANDLE_T h
7805 + * uint32_t offset
7806 + * const uint32_t data_size,
7807 + * VCHI_FLAGS_T flags
7808 + * void *bulk_handle
7809 + *
7810 + * Description: Routine to setup a relocatable rcv buffer
7811 + *
7812 + * Returns: int32_t - success == 0
7813 + *
7814 + ***********************************************************/
7815 +int32_t vchi_bulk_queue_receive_reloc( const VCHI_SERVICE_HANDLE_T handle,
7816 + VCHI_MEM_HANDLE_T h,
7817 + uint32_t offset,
7818 + uint32_t data_size,
7819 + const VCHI_FLAGS_T flags,
7820 + void * const bulk_handle )
7821 +{
7822 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7823 + VCHIQ_BULK_MODE_T mode;
7824 + VCHIQ_STATUS_T status;
7825 +
7826 + switch ((int)flags) {
7827 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7828 + vcos_assert(service->callback);
7829 + mode = VCHIQ_BULK_MODE_CALLBACK;
7830 + break;
7831 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
7832 + mode = VCHIQ_BULK_MODE_BLOCKING;
7833 + break;
7834 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7835 + case VCHI_FLAGS_NONE:
7836 + mode = VCHIQ_BULK_MODE_NOCALLBACK;
7837 + break;
7838 + default:
7839 + vcos_assert(0);
7840 + return vchiq_status_to_vchi(VCHIQ_ERROR);
7841 + }
7842 +
7843 + status = vchiq_bulk_receive_handle(service->handle, h, (void*)offset,
7844 + data_size, bulk_handle, mode);
7845 +
7846 + // On some platforms, like linux kernel, vchiq_bulk_receive_handle() may
7847 + // return VCHIQ_RETRY, so we need to implment a retry mechanism since
7848 + // this function is supposed to block until queued
7849 + while ( status == VCHIQ_RETRY )
7850 + {
7851 + vcos_sleep( 1 );
7852 + status = vchiq_bulk_receive_handle(service->handle, h, (void*)offset,
7853 + data_size, bulk_handle, mode);
7854 + }
7855 +
7856 + return vchiq_status_to_vchi(status);
7857 +}
7858 +
7859 +/***********************************************************
7860 + * Name: vchi_bulk_queue_transmit
7861 + *
7862 + * Arguments: VCHI_BULK_HANDLE_T handle,
7863 + * const void *data_src,
7864 + * uint32_t data_size,
7865 + * VCHI_FLAGS_T flags,
7866 + * void *bulk_handle
7867 + *
7868 + * Description: Routine to transmit some data
7869 + *
7870 + * Returns: int32_t - success == 0
7871 + *
7872 + ***********************************************************/
7873 +int32_t vchi_bulk_queue_transmit( VCHI_SERVICE_HANDLE_T handle,
7874 + const void * data_src,
7875 + uint32_t data_size,
7876 + VCHI_FLAGS_T flags,
7877 + void * bulk_handle )
7878 +{
7879 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7880 + VCHIQ_BULK_MODE_T mode;
7881 + VCHIQ_STATUS_T status;
7882 +
7883 + switch ((int)flags) {
7884 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7885 + vcos_assert(service->callback);
7886 + mode = VCHIQ_BULK_MODE_CALLBACK;
7887 + break;
7888 + case VCHI_FLAGS_BLOCK_UNTIL_DATA_READ:
7889 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
7890 + mode = VCHIQ_BULK_MODE_BLOCKING;
7891 + break;
7892 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7893 + case VCHI_FLAGS_NONE:
7894 + mode = VCHIQ_BULK_MODE_NOCALLBACK;
7895 + break;
7896 + default:
7897 + vcos_assert(0);
7898 + return vchiq_status_to_vchi(VCHIQ_ERROR);
7899 + }
7900 +
7901 + status = vchiq_bulk_transmit(service->handle, data_src, data_size,
7902 + bulk_handle, mode);
7903 +
7904 + // On some platforms, like linux kernel, vchiq_bulk_transmit() may return
7905 + // VCHIQ_RETRY, so we need to implment a retry mechanism since this
7906 + // function is supposed to block until queued
7907 + while ( status == VCHIQ_RETRY )
7908 + {
7909 + vcos_sleep( 1 );
7910 + status = vchiq_bulk_transmit(service->handle, data_src, data_size,
7911 + bulk_handle, mode);
7912 + }
7913 +
7914 + return vchiq_status_to_vchi(status);
7915 +}
7916 +
7917 +/***********************************************************
7918 + * Name: vchi_bulk_queue_transmit_reloc
7919 + *
7920 + * Arguments: VCHI_BULK_HANDLE_T handle,
7921 + * VCHI_MEM_HANDLE_T h_src,
7922 + * uint32_t offset,
7923 + * uint32_t data_size,
7924 + * VCHI_FLAGS_T flags,
7925 + * void *bulk_handle
7926 + *
7927 + * Description: Routine to transmit some data from a relocatable buffer
7928 + *
7929 + * Returns: int32_t - success == 0
7930 + *
7931 + ***********************************************************/
7932 +
7933 +int32_t vchi_bulk_queue_transmit_reloc( VCHI_SERVICE_HANDLE_T handle,
7934 + VCHI_MEM_HANDLE_T h_src,
7935 + uint32_t offset,
7936 + uint32_t data_size,
7937 + VCHI_FLAGS_T flags,
7938 + void * const bulk_handle )
7939 +{
7940 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7941 + VCHIQ_BULK_MODE_T mode;
7942 + VCHIQ_STATUS_T status;
7943 +
7944 + switch ((int)flags) {
7945 + case VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE | VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7946 + vcos_assert(service->callback);
7947 + mode = VCHIQ_BULK_MODE_CALLBACK;
7948 + break;
7949 + case VCHI_FLAGS_BLOCK_UNTIL_DATA_READ:
7950 + case VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE:
7951 + mode = VCHIQ_BULK_MODE_BLOCKING;
7952 + break;
7953 + case VCHI_FLAGS_BLOCK_UNTIL_QUEUED:
7954 + case VCHI_FLAGS_NONE:
7955 + mode = VCHIQ_BULK_MODE_NOCALLBACK;
7956 + break;
7957 + default:
7958 + vcos_assert(0);
7959 + return vchiq_status_to_vchi(VCHIQ_ERROR);
7960 + }
7961 +
7962 + status = vchiq_bulk_transmit_handle(service->handle, h_src, (void*)offset,
7963 + data_size, bulk_handle, mode);
7964 +
7965 + // On some platforms, like linux kernel, vchiq_bulk_transmit_handle() may
7966 + // return VCHIQ_RETRY, so we need to implment a retry mechanism since this
7967 + // function is supposed to block until queued
7968 + while ( status == VCHIQ_RETRY )
7969 + {
7970 + vcos_sleep( 1 );
7971 + status = vchiq_bulk_transmit_handle(service->handle, h_src, (void*)offset,
7972 + data_size, bulk_handle, mode);
7973 + }
7974 +
7975 + return vchiq_status_to_vchi(status);
7976 +}
7977 +
7978 +/***********************************************************
7979 + * Name: vchi_msg_dequeue
7980 + *
7981 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
7982 + * void *data,
7983 + * uint32_t max_data_size_to_read,
7984 + * uint32_t *actual_msg_size
7985 + * VCHI_FLAGS_T flags
7986 + *
7987 + * Description: Routine to dequeue a message into the supplied buffer
7988 + *
7989 + * Returns: int32_t - success == 0
7990 + *
7991 + ***********************************************************/
7992 +int32_t vchi_msg_dequeue( VCHI_SERVICE_HANDLE_T handle,
7993 + void *data,
7994 + uint32_t max_data_size_to_read,
7995 + uint32_t *actual_msg_size,
7996 + VCHI_FLAGS_T flags )
7997 +{
7998 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
7999 + VCHIQ_HEADER_T *header;
8000 +
8001 + vcos_assert(flags == VCHI_FLAGS_NONE || flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
8002 +
8003 + if (flags == VCHI_FLAGS_NONE)
8004 + if (vchiu_queue_is_empty(&service->queue))
8005 + return -1;
8006 +
8007 + header = vchiu_queue_pop(&service->queue);
8008 +
8009 + memcpy(data, header->data, header->size < max_data_size_to_read ? header->size : max_data_size_to_read);
8010 +
8011 + *actual_msg_size = header->size;
8012 +
8013 + vchiq_release_message(service->handle, header);
8014 +
8015 + return 0;
8016 +}
8017 +
8018 +/***********************************************************
8019 + * Name: vchi_msg_queuev
8020 + *
8021 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
8022 + * const void *data,
8023 + * uint32_t data_size,
8024 + * VCHI_FLAGS_T flags,
8025 + * void *msg_handle
8026 + *
8027 + * Description: Thin wrapper to queue a message onto a connection
8028 + *
8029 + * Returns: int32_t - success == 0
8030 + *
8031 + ***********************************************************/
8032 +
8033 +vcos_static_assert(sizeof(VCHI_MSG_VECTOR_T) == sizeof(VCHIQ_ELEMENT_T));
8034 +vcos_static_assert(offsetof(VCHI_MSG_VECTOR_T, vec_base) == offsetof(VCHIQ_ELEMENT_T, data));
8035 +vcos_static_assert(offsetof(VCHI_MSG_VECTOR_T, vec_len) == offsetof(VCHIQ_ELEMENT_T, size));
8036 +
8037 +int32_t vchi_msg_queuev( VCHI_SERVICE_HANDLE_T handle,
8038 + VCHI_MSG_VECTOR_T * vector,
8039 + uint32_t count,
8040 + VCHI_FLAGS_T flags,
8041 + void *msg_handle )
8042 +{
8043 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
8044 +
8045 + vcos_unused(msg_handle);
8046 +
8047 + vcos_assert(flags == VCHI_FLAGS_BLOCK_UNTIL_QUEUED);
8048 +
8049 + return vchiq_status_to_vchi(vchiq_queue_message(service->handle, (const VCHIQ_ELEMENT_T *)vector, count));
8050 +}
8051 +
8052 +#ifdef USE_MEMMGR
8053 +
8054 +/***********************************************************
8055 + * Name: vchi_msg_queuev_ex
8056 + *
8057 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
8058 + * VCHI_MSG_VECTOR_EX_T *vector
8059 + * uint32_t count
8060 + * VCHI_FLAGS_T flags,
8061 + * void *msg_handle
8062 + *
8063 + * Description: Thin wrapper to queue an array of messages onto a connection
8064 + * Supports resolving MEM_HANDLE's at last possible moment to avoid deadlocks.
8065 + *
8066 + * Currently just a shim, so deadlocks are still possible!
8067 + *
8068 + * Returns: int32_t - success == 0
8069 + *
8070 + ***********************************************************/
8071 +int32_t vchi_msg_queuev_ex( const VCHI_SERVICE_HANDLE_T handle,
8072 + VCHI_MSG_VECTOR_EX_T * const vector,
8073 + const uint32_t count,
8074 + const VCHI_FLAGS_T flags,
8075 + void * const msg_handle )
8076 +{
8077 + int32_t success = -1;
8078 + // For now, we don't actually support sending anything other than
8079 + // a pointer, so handles have to be patched up; this is likely
8080 + // to cause deadlocks. This code is not designed to be either
8081 + // pretty, efficient, or deadlock-free.
8082 +
8083 + #define max_vecs 16
8084 + VCHI_MSG_VECTOR_T copy[max_vecs];
8085 + const uint8_t *orig[max_vecs];
8086 +
8087 + int i;
8088 + vcos_unused(msg_handle);
8089 +
8090 + if (count > sizeof(copy)/sizeof(copy[0]))
8091 + {
8092 + vcos_assert(0);
8093 + return -1;
8094 + }
8095 +
8096 + for (i=0; i<count; i++)
8097 + {
8098 + VCHI_MSG_VECTOR_EX_T *v = vector+i;
8099 +
8100 + switch (vector[i].type)
8101 + {
8102 + case VCHI_VEC_POINTER:
8103 + copy[i].vec_base = v->u.ptr.vec_base;
8104 + copy[i].vec_len = v->u.ptr.vec_len;
8105 + break;
8106 + case VCHI_VEC_HANDLE:
8107 + vcos_assert(v->u.handle.offset+v->u.handle.vec_len <= mem_get_size(v->u.handle.handle));
8108 + copy[i].vec_base = (uint8_t*)mem_lock(v->u.handle.handle) + v->u.handle.offset;
8109 + orig[i] = copy[i].vec_base;
8110 + copy[i].vec_len = v->u.handle.vec_len;
8111 + break;
8112 + case VCHI_VEC_LIST:
8113 + vcos_assert(0); // FIXME: implement this
8114 + break;
8115 + default:
8116 + vcos_assert(0);
8117 + }
8118 + }
8119 + success = vchi_msg_queuev( handle,
8120 + copy,
8121 + count,
8122 + flags &~ VCHI_FLAGS_INTERNAL,
8123 + msg_handle );
8124 + if (vcos_verify(success == 0))
8125 + {
8126 + // now we need to patch up the vectors if any have been only partially consumed, and
8127 + // unlock memory handles.
8128 +
8129 + for (i=0; i<count; i++)
8130 + {
8131 + VCHI_MSG_VECTOR_EX_T *v = vector+i;
8132 +
8133 + switch (vector[i].type)
8134 + {
8135 + case VCHI_VEC_POINTER:
8136 + if (flags & VCHI_FLAGS_ALLOW_PARTIAL)
8137 + {
8138 + v->u.ptr.vec_base = copy[i].vec_base;
8139 + v->u.ptr.vec_len = copy[i].vec_len;
8140 + }
8141 + break;
8142 + case VCHI_VEC_HANDLE:
8143 + mem_unlock(v->u.handle.handle);
8144 + if (flags & VCHI_FLAGS_ALLOW_PARTIAL)
8145 + {
8146 + const uint8_t *old = orig[i];
8147 + uint32_t change = (const uint8_t*)copy[i].vec_base-old;
8148 + v->u.handle.offset += change;
8149 + v->u.handle.vec_len -= change;
8150 + }
8151 + break;
8152 + default:
8153 + vcos_assert(0);
8154 + }
8155 + }
8156 + }
8157 +
8158 + return vchiq_status_to_vchi(success);
8159 +}
8160 +
8161 +#endif
8162 +
8163 +/***********************************************************
8164 + * Name: vchi_held_msg_release
8165 + *
8166 + * Arguments: VCHI_HELD_MSG_T *message
8167 + *
8168 + * Description: Routine to release a held message (after it has been read with vchi_msg_hold)
8169 + *
8170 + * Returns: int32_t - success == 0
8171 + *
8172 + ***********************************************************/
8173 +int32_t vchi_held_msg_release( VCHI_HELD_MSG_T *message )
8174 +{
8175 + vchiq_release_message((VCHIQ_SERVICE_HANDLE_T)message->service, (VCHIQ_HEADER_T *)message->message);
8176 +
8177 + return 0;
8178 +}
8179 +
8180 +/***********************************************************
8181 + * Name: vchi_msg_hold
8182 + *
8183 + * Arguments: VCHI_SERVICE_HANDLE_T handle,
8184 + * void **data,
8185 + * uint32_t *msg_size,
8186 + * VCHI_FLAGS_T flags,
8187 + * VCHI_HELD_MSG_T *message_handle
8188 + *
8189 + * Description: Routine to return a pointer to the current message (to allow in place processing)
8190 + * The message is dequeued - don't forget to release the message using
8191 + * vchi_held_msg_release when you're finished
8192 + *
8193 + * Returns: int32_t - success == 0
8194 + *
8195 + ***********************************************************/
8196 +int32_t vchi_msg_hold( VCHI_SERVICE_HANDLE_T handle,
8197 + void **data,
8198 + uint32_t *msg_size,
8199 + VCHI_FLAGS_T flags,
8200 + VCHI_HELD_MSG_T *message_handle )
8201 +{
8202 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
8203 + VCHIQ_HEADER_T *header;
8204 +
8205 + vcos_assert(flags == VCHI_FLAGS_NONE || flags == VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE);
8206 +
8207 + if (flags == VCHI_FLAGS_NONE)
8208 + if (vchiu_queue_is_empty(&service->queue))
8209 + return -1;
8210 +
8211 + header = vchiu_queue_pop(&service->queue);
8212 +
8213 + *data = header->data;
8214 + *msg_size = header->size;
8215 +
8216 + message_handle->service = (struct opaque_vchi_service_t *)service->handle;
8217 + message_handle->message = header;
8218 +
8219 + return 0;
8220 +}
8221 +
8222 +/***********************************************************
8223 + * Name: vchi_initialise
8224 + *
8225 + * Arguments: VCHI_INSTANCE_T *instance_handle
8226 + * VCHI_CONNECTION_T **connections
8227 + * const uint32_t num_connections
8228 + *
8229 + * Description: Initialises the hardware but does not transmit anything
8230 + * When run as a Host App this will be called twice hence the need
8231 + * to malloc the state information
8232 + *
8233 + * Returns: 0 if successful, failure otherwise
8234 + *
8235 + ***********************************************************/
8236 +
8237 +int32_t vchi_initialise( VCHI_INSTANCE_T *instance_handle )
8238 +{
8239 + VCHIQ_INSTANCE_T instance;
8240 + VCHIQ_STATUS_T status;
8241 +
8242 + status = vchiq_initialise(&instance);
8243 +
8244 + *instance_handle = (VCHI_INSTANCE_T)instance;
8245 +
8246 + return vchiq_status_to_vchi(status);
8247 +}
8248 +
8249 +/***********************************************************
8250 + * Name: vchi_connect
8251 + *
8252 + * Arguments: VCHI_CONNECTION_T **connections
8253 + * const uint32_t num_connections
8254 + * VCHI_INSTANCE_T instance_handle )
8255 + *
8256 + * Description: Starts the command service on each connection,
8257 + * causing INIT messages to be pinged back and forth
8258 + *
8259 + * Returns: 0 if successful, failure otherwise
8260 + *
8261 + ***********************************************************/
8262 +int32_t vchi_connect( VCHI_CONNECTION_T **connections,
8263 + const uint32_t num_connections,
8264 + VCHI_INSTANCE_T instance_handle )
8265 +{
8266 + VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)instance_handle;
8267 +
8268 + vcos_unused(connections);
8269 + vcos_unused(num_connections);
8270 +
8271 + return vchiq_connect(instance);
8272 +}
8273 +
8274 +
8275 +/***********************************************************
8276 + * Name: vchi_disconnect
8277 + *
8278 + * Arguments: VCHI_INSTANCE_T instance_handle
8279 + *
8280 + * Description: Stops the command service on each connection,
8281 + * causing DE-INIT messages to be pinged back and forth
8282 + *
8283 + * Returns: 0 if successful, failure otherwise
8284 + *
8285 + ***********************************************************/
8286 +int32_t vchi_disconnect( VCHI_INSTANCE_T instance_handle )
8287 +{
8288 + VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)instance_handle;
8289 + return vchiq_status_to_vchi(vchiq_shutdown(instance));
8290 +}
8291 +
8292 +
8293 +/***********************************************************
8294 + * Name: vchi_service_open
8295 + * Name: vchi_service_create
8296 + *
8297 + * Arguments: VCHI_INSTANCE_T *instance_handle
8298 + * SERVICE_CREATION_T *setup,
8299 + * VCHI_SERVICE_HANDLE_T *handle
8300 + *
8301 + * Description: Routine to open a service
8302 + *
8303 + * Returns: int32_t - success == 0
8304 + *
8305 + ***********************************************************/
8306 +
8307 +static VCHIQ_STATUS_T shim_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header, VCHIQ_SERVICE_HANDLE_T handle, void *bulk_user)
8308 +{
8309 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)VCHIQ_GET_SERVICE_USERDATA(handle);
8310 +
8311 + switch (reason) {
8312 + case VCHIQ_MESSAGE_AVAILABLE:
8313 + vchiu_queue_push(&service->queue, header);
8314 +
8315 + if (service->callback)
8316 + service->callback(service->callback_param, VCHI_CALLBACK_MSG_AVAILABLE, NULL);
8317 + break;
8318 + case VCHIQ_BULK_TRANSMIT_DONE:
8319 + if (service->callback)
8320 + service->callback(service->callback_param, VCHI_CALLBACK_BULK_SENT, bulk_user);
8321 + break;
8322 + case VCHIQ_BULK_RECEIVE_DONE:
8323 + if (service->callback)
8324 + service->callback(service->callback_param, VCHI_CALLBACK_BULK_RECEIVED, bulk_user);
8325 + break;
8326 + case VCHIQ_SERVICE_CLOSED:
8327 + if (service->callback)
8328 + service->callback(service->callback_param, VCHI_CALLBACK_SERVICE_CLOSED, NULL);
8329 + break;
8330 + case VCHIQ_SERVICE_OPENED:
8331 + /* No equivalent VCHI reason */
8332 + break;
8333 + case VCHIQ_BULK_TRANSMIT_ABORTED:
8334 + if (service->callback)
8335 + service->callback(service->callback_param, VCHI_CALLBACK_BULK_TRANSMIT_ABORTED, bulk_user);
8336 + break;
8337 + case VCHIQ_BULK_RECEIVE_ABORTED:
8338 + if (service->callback)
8339 + service->callback(service->callback_param, VCHI_CALLBACK_BULK_RECEIVE_ABORTED, bulk_user);
8340 + break;
8341 + default:
8342 + vcos_assert(0);
8343 + break;
8344 + }
8345 +
8346 + return VCHIQ_SUCCESS;
8347 +}
8348 +
8349 +static SHIM_SERVICE_T *service_alloc(VCHIQ_INSTANCE_T instance,
8350 + SERVICE_CREATION_T *setup)
8351 +{
8352 + SHIM_SERVICE_T *service = vcos_calloc(1, sizeof(SHIM_SERVICE_T), "vchiq_shim");
8353 +
8354 + vcos_unused(instance);
8355 +
8356 + if (service)
8357 + {
8358 + if (vchiu_queue_init(&service->queue, 64))
8359 + {
8360 + service->callback = setup->callback;
8361 + service->callback_param = setup->callback_param;
8362 + }
8363 + else
8364 + {
8365 + vcos_free(service);
8366 + service = NULL;
8367 + }
8368 + }
8369 +
8370 + return service;
8371 +}
8372 +
8373 +static void service_free(SHIM_SERVICE_T *service)
8374 +{
8375 + if (service)
8376 + {
8377 + vchiu_queue_delete(&service->queue);
8378 + vcos_free((void*)service);
8379 + }
8380 +}
8381 +
8382 +int32_t vchi_service_open( VCHI_INSTANCE_T instance_handle,
8383 + SERVICE_CREATION_T *setup,
8384 + VCHI_SERVICE_HANDLE_T *handle)
8385 +{
8386 + VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)instance_handle;
8387 + SHIM_SERVICE_T *service = service_alloc(instance, setup);
8388 + if (service)
8389 + {
8390 + VCHIQ_STATUS_T status = vchiq_open_service(instance, setup->service_id, shim_callback, service, &service->handle);
8391 + if (status != VCHIQ_SUCCESS)
8392 + {
8393 + service_free(service);
8394 + service = NULL;
8395 + }
8396 + }
8397 +
8398 + *handle = (VCHI_SERVICE_HANDLE_T)service;
8399 +
8400 + return (service != NULL) ? 0 : -1;
8401 +}
8402 +
8403 +int32_t vchi_service_create( VCHI_INSTANCE_T instance_handle,
8404 + SERVICE_CREATION_T *setup,
8405 + VCHI_SERVICE_HANDLE_T *handle )
8406 +{
8407 + VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)instance_handle;
8408 + SHIM_SERVICE_T *service = service_alloc(instance, setup);
8409 + if (service)
8410 + {
8411 + VCHIQ_STATUS_T status = vchiq_add_service(instance, setup->service_id, shim_callback, service, &service->handle);
8412 + if (status != VCHIQ_SUCCESS)
8413 + {
8414 + service_free(service);
8415 + service = NULL;
8416 + }
8417 + }
8418 +
8419 + *handle = (VCHI_SERVICE_HANDLE_T)service;
8420 +
8421 + return (service != NULL) ? 0 : -1;
8422 +}
8423 +
8424 +int32_t vchi_service_close( const VCHI_SERVICE_HANDLE_T handle )
8425 +{
8426 + vcos_unused(handle);
8427 +
8428 + // YTI??
8429 + return 0;
8430 +}
8431 +
8432 +/* ----------------------------------------------------------------------
8433 + * read a uint32_t from buffer.
8434 + * network format is defined to be little endian
8435 + * -------------------------------------------------------------------- */
8436 +uint32_t
8437 +vchi_readbuf_uint32( const void *_ptr )
8438 +{
8439 + const unsigned char *ptr = _ptr;
8440 + return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
8441 +}
8442 +
8443 +/* ----------------------------------------------------------------------
8444 + * write a uint32_t to buffer.
8445 + * network format is defined to be little endian
8446 + * -------------------------------------------------------------------- */
8447 +void
8448 +vchi_writebuf_uint32( void *_ptr, uint32_t value )
8449 +{
8450 + unsigned char *ptr = _ptr;
8451 + ptr[0] = (unsigned char)((value >> 0) & 0xFF);
8452 + ptr[1] = (unsigned char)((value >> 8) & 0xFF);
8453 + ptr[2] = (unsigned char)((value >> 16) & 0xFF);
8454 + ptr[3] = (unsigned char)((value >> 24) & 0xFF);
8455 +}
8456 +
8457 +/* ----------------------------------------------------------------------
8458 + * read a uint16_t from buffer.
8459 + * network format is defined to be little endian
8460 + * -------------------------------------------------------------------- */
8461 +uint16_t
8462 +vchi_readbuf_uint16( const void *_ptr )
8463 +{
8464 + const unsigned char *ptr = _ptr;
8465 + return ptr[0] | (ptr[1] << 8);
8466 +}
8467 +
8468 +/* ----------------------------------------------------------------------
8469 + * write a uint16_t into the buffer.
8470 + * network format is defined to be little endian
8471 + * -------------------------------------------------------------------- */
8472 +void
8473 +vchi_writebuf_uint16( void *_ptr, uint16_t value )
8474 +{
8475 + unsigned char *ptr = _ptr;
8476 + ptr[0] = (value >> 0) & 0xFF;
8477 + ptr[1] = (value >> 8) & 0xFF;
8478 +}
8479 +
8480 +/***********************************************************
8481 + * Name: vchi_service_use
8482 + *
8483 + * Arguments: const VCHI_SERVICE_HANDLE_T handle
8484 + *
8485 + * Description: Routine to increment refcount on a service
8486 + *
8487 + * Returns: void
8488 + *
8489 + ***********************************************************/
8490 +int32_t vchi_service_use( const VCHI_SERVICE_HANDLE_T handle )
8491 +{
8492 + int32_t ret = -1;
8493 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
8494 + if(service)
8495 + {
8496 + ret = vchiq_status_to_vchi(vchiq_use_service(service->handle));
8497 + }
8498 + return ret;
8499 +}
8500 +
8501 +/***********************************************************
8502 + * Name: vchi_service_release
8503 + *
8504 + * Arguments: const VCHI_SERVICE_HANDLE_T handle
8505 + *
8506 + * Description: Routine to decrement refcount on a service
8507 + *
8508 + * Returns: void
8509 + *
8510 + ***********************************************************/
8511 +int32_t vchi_service_release( const VCHI_SERVICE_HANDLE_T handle )
8512 +{
8513 + int32_t ret = -1;
8514 + SHIM_SERVICE_T *service = (SHIM_SERVICE_T *)handle;
8515 + if(service)
8516 + {
8517 + ret = vchiq_status_to_vchi(vchiq_release_service(service->handle));
8518 + }
8519 + return ret;
8520 +}
8521 +
8522 +#if defined(__KERNEL__)
8523 +EXPORT_SYMBOL(vchi_initialise);
8524 +EXPORT_SYMBOL(vchi_connect);
8525 +EXPORT_SYMBOL(vchi_bulk_queue_transmit);
8526 +EXPORT_SYMBOL(vchi_msg_dequeue);
8527 +EXPORT_SYMBOL(vchi_msg_queue);
8528 +EXPORT_SYMBOL(vchi_msg_queuev);
8529 +EXPORT_SYMBOL(vchi_service_close);
8530 +EXPORT_SYMBOL(vchi_service_open);
8531 +EXPORT_SYMBOL(vchi_service_create);
8532 +EXPORT_SYMBOL(vchi_service_use);
8533 +EXPORT_SYMBOL(vchi_service_release);
8534 +#endif
8535 --- /dev/null
8536 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_util.c
8537 @@ -0,0 +1,97 @@
8538 +/*
8539 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
8540 + *
8541 + * This program is free software; you can redistribute it and/or modify
8542 + * it under the terms of the GNU General Public License as published by
8543 + * the Free Software Foundation; either version 2 of the License, or
8544 + * (at your option) any later version.
8545 + *
8546 + * This program is distributed in the hope that it will be useful,
8547 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
8548 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8549 + * GNU General Public License for more details.
8550 + *
8551 + * You should have received a copy of the GNU General Public License
8552 + * along with this program; if not, write to the Free Software
8553 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
8554 + */
8555 +
8556 +#include "vchiq_util.h"
8557 +
8558 +#if !defined(__KERNEL__)
8559 +#include <stdlib.h>
8560 +#endif
8561 +
8562 +static __inline int is_pow2(int i)
8563 +{
8564 + return i && !(i & (i - 1));
8565 +}
8566 +
8567 +int vchiu_queue_init(VCHIU_QUEUE_T *queue, int size)
8568 +{
8569 + vcos_assert(is_pow2(size));
8570 +
8571 + queue->size = size;
8572 + queue->read = 0;
8573 + queue->write = 0;
8574 +
8575 + vcos_event_create(&queue->pop, "vchiu");
8576 + vcos_event_create(&queue->push, "vchiu");
8577 +
8578 + queue->storage = vcos_malloc(size * sizeof(VCHIQ_HEADER_T *), VCOS_FUNCTION);
8579 + if (queue->storage == NULL)
8580 + {
8581 + vchiu_queue_delete(queue);
8582 + return 0;
8583 + }
8584 + return 1;
8585 +}
8586 +
8587 +void vchiu_queue_delete(VCHIU_QUEUE_T *queue)
8588 +{
8589 + vcos_event_delete(&queue->pop);
8590 + vcos_event_delete(&queue->push);
8591 + if (queue->storage != NULL)
8592 + vcos_free(queue->storage);
8593 +}
8594 +
8595 +int vchiu_queue_is_empty(VCHIU_QUEUE_T *queue)
8596 +{
8597 + return queue->read == queue->write;
8598 +}
8599 +
8600 +void vchiu_queue_push(VCHIU_QUEUE_T *queue, VCHIQ_HEADER_T *header)
8601 +{
8602 + while (queue->write == queue->read + queue->size)
8603 + vcos_event_wait(&queue->pop);
8604 +
8605 + queue->storage[queue->write & (queue->size - 1)] = header;
8606 +
8607 + queue->write++;
8608 +
8609 + vcos_event_signal(&queue->push);
8610 +}
8611 +
8612 +VCHIQ_HEADER_T *vchiu_queue_peek(VCHIU_QUEUE_T *queue)
8613 +{
8614 + while (queue->write == queue->read)
8615 + vcos_event_wait(&queue->push);
8616 +
8617 + return queue->storage[queue->read & (queue->size - 1)];
8618 +}
8619 +
8620 +VCHIQ_HEADER_T *vchiu_queue_pop(VCHIU_QUEUE_T *queue)
8621 +{
8622 + VCHIQ_HEADER_T *header;
8623 +
8624 + while (queue->write == queue->read)
8625 + vcos_event_wait(&queue->push);
8626 +
8627 + header = queue->storage[queue->read & (queue->size - 1)];
8628 +
8629 + queue->read++;
8630 +
8631 + vcos_event_signal(&queue->pop);
8632 +
8633 + return header;
8634 +}
8635 --- /dev/null
8636 +++ b/drivers/misc/vc04_services/interface/vchiq_arm/vchiq_util.h
8637 @@ -0,0 +1,47 @@
8638 +/*
8639 + * Copyright (c) 2010-2011 Broadcom Corporation. All rights reserved.
8640 + *
8641 + * This program is free software; you can redistribute it and/or modify
8642 + * it under the terms of the GNU General Public License as published by
8643 + * the Free Software Foundation; either version 2 of the License, or
8644 + * (at your option) any later version.
8645 + *
8646 + * This program is distributed in the hope that it will be useful,
8647 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
8648 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8649 + * GNU General Public License for more details.
8650 + *
8651 + * You should have received a copy of the GNU General Public License
8652 + * along with this program; if not, write to the Free Software
8653 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
8654 + */
8655 +
8656 +#ifndef VCHIQ_UTIL_H
8657 +#define VCHIQ_UTIL_H
8658 +
8659 +#include "vchiq_if.h"
8660 +#include "interface/vcos/vcos.h"
8661 +
8662 +typedef struct {
8663 + int size;
8664 + int read;
8665 + int write;
8666 +
8667 + VCOS_EVENT_T pop;
8668 + VCOS_EVENT_T push;
8669 +
8670 + VCHIQ_HEADER_T **storage;
8671 +} VCHIU_QUEUE_T;
8672 +
8673 +extern int vchiu_queue_init(VCHIU_QUEUE_T *queue, int size);
8674 +extern void vchiu_queue_delete(VCHIU_QUEUE_T *queue);
8675 +
8676 +extern int vchiu_queue_is_empty(VCHIU_QUEUE_T *queue);
8677 +
8678 +extern void vchiu_queue_push(VCHIU_QUEUE_T *queue, VCHIQ_HEADER_T *header);
8679 +
8680 +extern VCHIQ_HEADER_T *vchiu_queue_peek(VCHIU_QUEUE_T *queue);
8681 +extern VCHIQ_HEADER_T *vchiu_queue_pop(VCHIU_QUEUE_T *queue);
8682 +
8683 +#endif
8684 +
8685 --- /dev/null
8686 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_cmd.c
8687 @@ -0,0 +1,681 @@
8688 +/*****************************************************************************
8689 +* Copyright 2009 - 2011 Broadcom Corporation. All rights reserved.
8690 +*
8691 +* Unless you and Broadcom execute a separate written software license
8692 +* agreement governing use of this software, this software is licensed to you
8693 +* under the terms of the GNU General Public License version 2, available at
8694 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
8695 +*
8696 +* Notwithstanding the above, under no circumstances may you combine this
8697 +* software in any way with any other Broadcom software provided under a
8698 +* license other than the GPL, without Broadcom's express prior written
8699 +* consent.
8700 +*****************************************************************************/
8701 +
8702 +/*****************************************************************************
8703 +*
8704 +* This file provides a generic command line interface which allows
8705 +* vcos internals to be manipulated and/or displayed.
8706 +*
8707 +*****************************************************************************/
8708 +
8709 +/* ---- Include Files ---------------------------------------------------- */
8710 +
8711 +#include "interface/vcos/vcos.h"
8712 +
8713 +#ifdef HAVE_VCOS_VERSION
8714 +#include "interface/vcos/vcos_build_info.h"
8715 +#endif
8716 +
8717 + #ifdef _VIDEOCORE
8718 +#include vcfw/logging/logging.h
8719 +#endif
8720 +
8721 +/* ---- Public Variables ------------------------------------------------- */
8722 +
8723 +/* ---- Private Constants and Types -------------------------------------- */
8724 +
8725 +#define VCOS_LOG_CATEGORY (&vcos_cmd_log_category)
8726 +VCOS_LOG_CAT_T vcos_cmd_log_category;
8727 +
8728 +/* ---- Private Variables ------------------------------------------------ */
8729 +
8730 +static struct VCOS_CMD_GLOBALS_T
8731 +{
8732 + VCOS_MUTEX_T lock;
8733 + VCOS_ONCE_T initialized;
8734 +
8735 + unsigned num_cmd_entries;
8736 + unsigned num_cmd_alloc;
8737 + VCOS_CMD_T *cmd_entry;
8738 +
8739 + VCOS_LOG_CAT_T *log_category;
8740 +} cmd_globals;
8741 +
8742 +/* ---- Private Function Prototypes -------------------------------------- */
8743 +
8744 +static VCOS_STATUS_T help_cmd( VCOS_CMD_PARAM_T *param );
8745 +
8746 +/* ---- Functions ------------------------------------------------------- */
8747 +
8748 +/*****************************************************************************
8749 +*
8750 +* Walks through the commands looking for a particular command
8751 +*
8752 +*****************************************************************************/
8753 +
8754 +static VCOS_CMD_T *find_cmd( VCOS_CMD_T *cmd_entry, const char *name )
8755 +{
8756 + VCOS_CMD_T *scan_entry = cmd_entry;
8757 +
8758 + while ( scan_entry->name != NULL )
8759 + {
8760 + if ( vcos_strcmp( scan_entry->name, name ) == 0 )
8761 + {
8762 + return scan_entry;
8763 + }
8764 + scan_entry++;
8765 + }
8766 +
8767 + return NULL;
8768 +}
8769 +
8770 +/*****************************************************************************
8771 +*
8772 +* Saves away
8773 +* each line individually.
8774 +*
8775 +*****************************************************************************/
8776 +
8777 +void vcos_cmd_always_log_output( VCOS_LOG_CAT_T *log_category )
8778 +{
8779 + cmd_globals.log_category = log_category;
8780 +}
8781 +
8782 +/*****************************************************************************
8783 +*
8784 +* Walks through a buffer containing newline separated lines, and logs
8785 +* each line individually.
8786 +*
8787 +*****************************************************************************/
8788 +
8789 +static void cmd_log_results( VCOS_CMD_PARAM_T *param )
8790 +{
8791 + char *start;
8792 + char *end;
8793 +
8794 + start = end = param->result_buf;
8795 +
8796 + while ( *start != '\0' )
8797 + {
8798 + while (( *end != '\0' ) && ( *end != '\n' ))
8799 + end++;
8800 +
8801 + if ( *end == '\n' )
8802 + {
8803 + *end++ = '\0';
8804 + }
8805 +
8806 + if ( cmd_globals.log_category != NULL )
8807 + {
8808 + if ( vcos_is_log_enabled( cmd_globals.log_category, VCOS_LOG_INFO ))
8809 + {
8810 + vcos_log_impl( cmd_globals.log_category, VCOS_LOG_INFO, "%s", start );
8811 + }
8812 + }
8813 + else
8814 + {
8815 + vcos_log_info( "%s", start );
8816 + }
8817 +
8818 + start = end;
8819 + }
8820 +
8821 + /* Since we logged the buffer, reset the pointer back to the beginning. */
8822 +
8823 + param->result_ptr = param->result_buf;
8824 + param->result_buf[0] = '\0';
8825 +}
8826 +
8827 +/*****************************************************************************
8828 +*
8829 +* Since we may have limited output space, we create a generic routine
8830 +* which tries to use the result space, but will switch over to using
8831 +* logging if the output is too large.
8832 +*
8833 +*****************************************************************************/
8834 +
8835 +void vcos_cmd_vprintf( VCOS_CMD_PARAM_T *param, const char *fmt, va_list args )
8836 +{
8837 + int bytes_written;
8838 + int bytes_remaining;
8839 +
8840 + bytes_remaining = (int)(param->result_size - ( param->result_ptr - param->result_buf ));
8841 +
8842 + bytes_written = vcos_vsnprintf( param->result_ptr, bytes_remaining, fmt, args );
8843 +
8844 + if ( cmd_globals.log_category != NULL )
8845 + {
8846 + /* We're going to log each line as we encounter it. If the buffer
8847 + * doesn't end in a newline, then we'll wait for one first.
8848 + */
8849 +
8850 + if ( (( bytes_written + 1 ) >= bytes_remaining )
8851 + || ( param->result_ptr[ bytes_written - 1 ] == '\n' ))
8852 + {
8853 + cmd_log_results( param );
8854 + }
8855 + else
8856 + {
8857 + param->result_ptr += bytes_written;
8858 + }
8859 + }
8860 + else
8861 + {
8862 + if (( bytes_written + 1 ) >= bytes_remaining )
8863 + {
8864 + /* Output doesn't fit - switch over to logging */
8865 +
8866 + param->use_log = 1;
8867 +
8868 + *param->result_ptr = '\0'; /* Zap the partial line that didn't fit above. */
8869 +
8870 + cmd_log_results( param ); /* resets result_ptr */
8871 +
8872 + bytes_written = vcos_vsnprintf( param->result_ptr, bytes_remaining, fmt, args );
8873 + }
8874 + param->result_ptr += bytes_written;
8875 + }
8876 +}
8877 +
8878 +/*****************************************************************************
8879 +*
8880 +* Prints the output.
8881 +*
8882 +*****************************************************************************/
8883 +
8884 +void vcos_cmd_printf( VCOS_CMD_PARAM_T *param, const char *fmt, ... )
8885 +{
8886 + va_list args;
8887 +
8888 + va_start( args, fmt );
8889 + vcos_cmd_vprintf( param, fmt, args );
8890 + va_end( args );
8891 +}
8892 +
8893 +/*****************************************************************************
8894 +*
8895 +* Prints the arguments which were on the command line prior to ours.
8896 +*
8897 +*****************************************************************************/
8898 +
8899 +static void print_argument_prefix( VCOS_CMD_PARAM_T *param )
8900 +{
8901 + int arg_idx;
8902 +
8903 + for ( arg_idx = 0; &param->argv_orig[arg_idx] != param->argv; arg_idx++ )
8904 + {
8905 + vcos_cmd_printf( param, "%s ", param->argv_orig[arg_idx] );
8906 + }
8907 +}
8908 +
8909 +/*****************************************************************************
8910 +*
8911 +* Prints an error message, prefixed by the command chain required to get
8912 +* to where we're at.
8913 +*
8914 +*****************************************************************************/
8915 +
8916 +void vcos_cmd_error( VCOS_CMD_PARAM_T *param, const char *fmt, ... )
8917 +{
8918 + va_list args;
8919 +
8920 + print_argument_prefix( param );
8921 +
8922 + va_start( args, fmt );
8923 + vcos_cmd_vprintf( param, fmt, args );
8924 + va_end( args );
8925 + vcos_cmd_printf( param, "\n" );
8926 +}
8927 +
8928 +/****************************************************************************
8929 +*
8930 +* usage - prints command usage for an array of commands.
8931 +*
8932 +***************************************************************************/
8933 +
8934 +static void usage( VCOS_CMD_PARAM_T *param, VCOS_CMD_T *cmd_entry )
8935 +{
8936 + int cmd_idx;
8937 + int nameWidth = 0;
8938 + int argsWidth = 0;
8939 + VCOS_CMD_T *scan_entry;
8940 +
8941 + vcos_cmd_printf( param, "Usage: " );
8942 + print_argument_prefix( param );
8943 + vcos_cmd_printf( param, "command [args ...]\n" );
8944 + vcos_cmd_printf( param, "\n" );
8945 + vcos_cmd_printf( param, "Where command is one of the following:\n" );
8946 +
8947 + for ( cmd_idx = 0; cmd_entry[cmd_idx].name != NULL; cmd_idx++ )
8948 + {
8949 + int aw;
8950 + int nw;
8951 +
8952 + scan_entry = &cmd_entry[cmd_idx];
8953 +
8954 + nw = vcos_strlen( scan_entry->name );
8955 + aw = vcos_strlen( scan_entry->args );
8956 +
8957 + if ( nw > nameWidth )
8958 + {
8959 + nameWidth = nw;
8960 + }
8961 + if ( aw > argsWidth )
8962 + {
8963 + argsWidth = aw;
8964 + }
8965 + }
8966 +
8967 + for ( cmd_idx = 0; cmd_entry[cmd_idx].name != NULL; cmd_idx++ )
8968 + {
8969 + scan_entry = &cmd_entry[cmd_idx];
8970 +
8971 + vcos_cmd_printf( param, " %-*s %-*s - %s\n",
8972 + nameWidth, scan_entry->name,
8973 + argsWidth, scan_entry->args,
8974 + scan_entry->descr );
8975 + }
8976 +}
8977 +
8978 +/****************************************************************************
8979 +*
8980 +* Prints the usage for the current command.
8981 +*
8982 +***************************************************************************/
8983 +
8984 +void vcos_cmd_usage( VCOS_CMD_PARAM_T *param )
8985 +{
8986 + VCOS_CMD_T *cmd_entry;
8987 +
8988 + cmd_entry = param->cmd_entry;
8989 +
8990 + if ( cmd_entry->sub_cmd_entry != NULL )
8991 + {
8992 + /* This command is command with sub-commands */
8993 +
8994 + usage( param, param->cmd_entry->sub_cmd_entry );
8995 + }
8996 + else
8997 + {
8998 + vcos_cmd_printf( param, "Usage: " );
8999 + print_argument_prefix( param );
9000 + vcos_cmd_printf( param, "%s - %s\n",
9001 + param->cmd_entry->args,
9002 + param->cmd_entry->descr );
9003 + }
9004 +}
9005 +
9006 +/*****************************************************************************
9007 +*
9008 +* Command to print out the help
9009 +*
9010 +* This help command is only called from the main menu.
9011 +*
9012 +*****************************************************************************/
9013 +
9014 +static VCOS_STATUS_T help_cmd( VCOS_CMD_PARAM_T *param )
9015 +{
9016 + VCOS_CMD_T *found_entry;
9017 +
9018 +#if 0
9019 + {
9020 + int arg_idx;
9021 +
9022 + vcos_log_trace( "%s: argc = %d", __func__, param->argc );
9023 + for ( arg_idx = 0; arg_idx < param->argc; arg_idx++ )
9024 + {
9025 + vcos_log_trace( "%s: argv[%d] = '%s'", __func__, arg_idx, param->argv[arg_idx] );
9026 + }
9027 + }
9028 +#endif
9029 +
9030 + /* If there is an argument after the word help, then we want to print
9031 + * help for that command.
9032 + */
9033 +
9034 + if ( param->argc == 1 )
9035 + {
9036 + if ( param->cmd_parent_entry == cmd_globals.cmd_entry )
9037 + {
9038 + /* Bare help - print the command usage for the root */
9039 +
9040 + usage( param, cmd_globals.cmd_entry );
9041 + return VCOS_SUCCESS;
9042 + }
9043 +
9044 + /* For all other cases help requires an argument */
9045 +
9046 + vcos_cmd_error( param, "%s requires an argument", param->argv[0] );
9047 + return VCOS_EINVAL;
9048 + }
9049 +
9050 + /* We were given an argument. */
9051 +
9052 + if (( found_entry = find_cmd( param->cmd_parent_entry, param->argv[1] )) != NULL )
9053 + {
9054 + /* Make it look like the command that was specified is the one that's
9055 + * currently running
9056 + */
9057 +
9058 + param->cmd_entry = found_entry;
9059 + param->argv[0] = param->argv[1];
9060 + param->argv++;
9061 + param->argc--;
9062 +
9063 + vcos_cmd_usage( param );
9064 + return VCOS_SUCCESS;
9065 + }
9066 +
9067 + vcos_cmd_error( param, "- unrecognized command: '%s'", param->argv[1] );
9068 + return VCOS_ENOENT;
9069 +}
9070 +
9071 +/*****************************************************************************
9072 +*
9073 +* Command to print out the version/build information.
9074 +*
9075 +*****************************************************************************/
9076 +
9077 +#ifdef HAVE_VCOS_VERSION
9078 +
9079 +static VCOS_STATUS_T version_cmd( VCOS_CMD_PARAM_T *param )
9080 +{
9081 + static const char* copyright = "Copyright (c) 2011 Broadcom";
9082 +
9083 + vcos_cmd_printf( param, "%s %s\n%s\nversion %s\n",
9084 + vcos_get_build_date(),
9085 + vcos_get_build_time(),
9086 + copyright,
9087 + vcos_get_build_version() );
9088 +
9089 + return VCOS_SUCCESS;
9090 +}
9091 +
9092 +#endif
9093 +
9094 +/*****************************************************************************
9095 +*
9096 +* Internal commands
9097 +*
9098 +*****************************************************************************/
9099 +
9100 +static VCOS_CMD_T cmd_help = { "help", "[command]", help_cmd, NULL, "Prints command help information" };
9101 +
9102 +#ifdef HAVE_VCOS_VERSION
9103 +static VCOS_CMD_T cmd_version = { "version", "", version_cmd, NULL, "Prints build/version information" };
9104 +#endif
9105 +
9106 +/*****************************************************************************
9107 +*
9108 +* Walks the command table and executes the commands
9109 +*
9110 +*****************************************************************************/
9111 +
9112 +static VCOS_STATUS_T execute_cmd( VCOS_CMD_PARAM_T *param, VCOS_CMD_T *cmd_entry )
9113 +{
9114 + const char *cmdStr;
9115 + VCOS_CMD_T *found_entry;
9116 +
9117 +#if 0
9118 + {
9119 + int arg_idx;
9120 +
9121 + vcos_cmd_printf( param, "%s: argc = %d", __func__, param->argc );
9122 + for ( arg_idx = 0; arg_idx < param->argc; arg_idx++ )
9123 + {
9124 + vcos_cmd_printf( param, " argv[%d] = '%s'", arg_idx, param->argv[arg_idx] );
9125 + }
9126 + vcos_cmd_printf( param, "\n" );
9127 + }
9128 +#endif
9129 +
9130 + if ( param->argc <= 1 )
9131 + {
9132 + /* No command specified */
9133 +
9134 + vcos_cmd_error( param, "%s - no command specified", param->argv[0] );
9135 + return VCOS_EINVAL;
9136 + }
9137 +
9138 + /* argv[0] is the command/program that caused us to get invoked, so we strip
9139 + * it off.
9140 + */
9141 +
9142 + param->argc--;
9143 + param->argv++;
9144 + param->cmd_parent_entry = cmd_entry;
9145 +
9146 + /* Not the help command, scan for the command and execute it. */
9147 +
9148 + cmdStr = param->argv[0];
9149 +
9150 + if (( found_entry = find_cmd( cmd_entry, cmdStr )) != NULL )
9151 + {
9152 + if ( found_entry->sub_cmd_entry != NULL )
9153 + {
9154 + return execute_cmd( param, found_entry->sub_cmd_entry );
9155 + }
9156 +
9157 + param->cmd_entry = found_entry;
9158 + return found_entry->cmd_fn( param );
9159 + }
9160 +
9161 + /* Unrecognized command - check to see if it was the help command */
9162 +
9163 + if ( vcos_strcmp( cmdStr, cmd_help.name ) == 0 )
9164 + {
9165 + return help_cmd( param );
9166 + }
9167 +
9168 + vcos_cmd_error( param, "- unrecognized command: '%s'", cmdStr );
9169 + return VCOS_ENOENT;
9170 +}
9171 +
9172 +/*****************************************************************************
9173 +*
9174 +* Initializes the command line parser.
9175 +*
9176 +*****************************************************************************/
9177 +
9178 +static void vcos_cmd_init( void )
9179 +{
9180 + vcos_mutex_create( &cmd_globals.lock, "vcos_cmd" );
9181 +
9182 + cmd_globals.num_cmd_entries = 0;
9183 + cmd_globals.num_cmd_alloc = 0;
9184 + cmd_globals.cmd_entry = NULL;
9185 +}
9186 +
9187 +/*****************************************************************************
9188 +*
9189 +* Command line processor.
9190 +*
9191 +*****************************************************************************/
9192 +
9193 +VCOS_STATUS_T vcos_cmd_execute( int argc, char **argv, size_t result_size, char *result_buf )
9194 +{
9195 + VCOS_STATUS_T rc = VCOS_EINVAL;
9196 + VCOS_CMD_PARAM_T param;
9197 +
9198 + vcos_once( &cmd_globals.initialized, vcos_cmd_init );
9199 +
9200 + param.argc = argc;
9201 + param.argv = param.argv_orig = argv;
9202 +
9203 + param.use_log = 0;
9204 + param.result_size = result_size;
9205 + param.result_ptr = result_buf;
9206 + param.result_buf = result_buf;
9207 +
9208 + result_buf[0] = '\0';
9209 +
9210 + vcos_mutex_lock( &cmd_globals.lock );
9211 +
9212 + rc = execute_cmd( &param, cmd_globals.cmd_entry );
9213 +
9214 + if ( param.use_log )
9215 + {
9216 + cmd_log_results( &param );
9217 + vcos_snprintf( result_buf, result_size, "results logged" );
9218 + }
9219 + else
9220 + if ( cmd_globals.log_category != NULL )
9221 + {
9222 + if ( result_buf[0] != '\0' )
9223 + {
9224 + /* There is a partial line still buffered. */
9225 +
9226 + vcos_cmd_printf( &param, "\n" );
9227 + }
9228 + }
9229 +
9230 + vcos_mutex_unlock( &cmd_globals.lock );
9231 +
9232 + return rc;
9233 +}
9234 +
9235 +/*****************************************************************************
9236 +*
9237 +* Registers a command entry with the command line processor
9238 +*
9239 +*****************************************************************************/
9240 +
9241 +VCOS_STATUS_T vcos_cmd_register( VCOS_CMD_T *cmd_entry )
9242 +{
9243 + VCOS_STATUS_T rc;
9244 + VCOS_UNSIGNED new_num_cmd_alloc;
9245 + VCOS_CMD_T *new_cmd_entry;
9246 + VCOS_CMD_T *old_cmd_entry;
9247 + VCOS_CMD_T *scan_entry;
9248 +
9249 + vcos_once( &cmd_globals.initialized, vcos_cmd_init );
9250 +
9251 + vcos_assert( cmd_entry != NULL );
9252 + vcos_assert( cmd_entry->name != NULL );
9253 +
9254 + vcos_log_trace( "%s: cmd '%s'", __FUNCTION__, cmd_entry->name );
9255 +
9256 + vcos_assert( cmd_entry->args != NULL );
9257 + vcos_assert(( cmd_entry->cmd_fn != NULL ) || ( cmd_entry->sub_cmd_entry != NULL ));
9258 + vcos_assert( cmd_entry->descr != NULL );
9259 +
9260 + /* We expect vcos_cmd_init to be called before vcos_logging_init, so we
9261 + * need to defer registering our logging category until someplace
9262 + * like right here.
9263 + */
9264 +
9265 + if ( vcos_cmd_log_category.name == NULL )
9266 + {
9267 + /*
9268 + * If you're using the command interface, you pretty much always want
9269 + * log messages from this file to show up. So we change the default
9270 + * from ERROR to be the more reasonable INFO level.
9271 + */
9272 +
9273 + vcos_log_set_level(&vcos_cmd_log_category, VCOS_LOG_INFO);
9274 + vcos_log_register("vcos_cmd", &vcos_cmd_log_category);
9275 +
9276 + /* We register a help command so that it shows up in the usage. */
9277 +
9278 + vcos_cmd_register( &cmd_help );
9279 +#ifdef HAVE_VCOS_VERSION
9280 + vcos_cmd_register( &cmd_version );
9281 +#endif
9282 + }
9283 +
9284 + vcos_mutex_lock( &cmd_globals.lock );
9285 +
9286 + if ( cmd_globals.num_cmd_entries >= cmd_globals.num_cmd_alloc )
9287 + {
9288 + if ( cmd_globals.num_cmd_alloc == 0 )
9289 + {
9290 + /* We haven't allocated a table yet */
9291 + }
9292 +
9293 + /* The number 8 is rather arbitrary. */
9294 +
9295 + new_num_cmd_alloc = cmd_globals.num_cmd_alloc + 8;
9296 +
9297 + /* The + 1 is to ensure that we always have a NULL entry at the end. */
9298 +
9299 + new_cmd_entry = (VCOS_CMD_T *)vcos_calloc( new_num_cmd_alloc + 1, sizeof( *cmd_entry ), "vcos_cmd_entries" );
9300 + if ( new_cmd_entry == NULL )
9301 + {
9302 + rc = VCOS_ENOMEM;
9303 + goto out;
9304 + }
9305 + memcpy( new_cmd_entry, cmd_globals.cmd_entry, cmd_globals.num_cmd_entries * sizeof( *cmd_entry ));
9306 + cmd_globals.num_cmd_alloc = new_num_cmd_alloc;
9307 + old_cmd_entry = cmd_globals.cmd_entry;
9308 + cmd_globals.cmd_entry = new_cmd_entry;
9309 + vcos_free( old_cmd_entry );
9310 + }
9311 +
9312 + if ( cmd_globals.num_cmd_entries == 0 )
9313 + {
9314 + /* This is the first command being registered */
9315 +
9316 + cmd_globals.cmd_entry[0] = *cmd_entry;
9317 + }
9318 + else
9319 + {
9320 + /* Keep the list in alphabetical order. We start at the end and work backwards
9321 + * shuffling entries up one until we find an insertion point.
9322 + */
9323 +
9324 + for ( scan_entry = &cmd_globals.cmd_entry[cmd_globals.num_cmd_entries - 1];
9325 + scan_entry >= cmd_globals.cmd_entry; scan_entry-- )
9326 + {
9327 + if ( vcos_strcmp( cmd_entry->name, scan_entry->name ) > 0 )
9328 + {
9329 + /* We found an insertion point. */
9330 +
9331 + break;
9332 + }
9333 +
9334 + scan_entry[1] = scan_entry[0];
9335 + }
9336 + scan_entry[1] = *cmd_entry;
9337 + }
9338 + cmd_globals.num_cmd_entries++;
9339 +
9340 + rc = VCOS_SUCCESS;
9341 +
9342 +out:
9343 +
9344 + vcos_mutex_unlock( &cmd_globals.lock );
9345 + return rc;
9346 +}
9347 +
9348 +/*****************************************************************************
9349 +*
9350 +* Registers multiple commands.
9351 +*
9352 +*****************************************************************************/
9353 +
9354 +VCOS_STATUS_T vcos_cmd_register_multiple( VCOS_CMD_T *cmd_entry )
9355 +{
9356 + VCOS_STATUS_T status;
9357 +
9358 + while ( cmd_entry->name != NULL )
9359 + {
9360 + if (( status = vcos_cmd_register( cmd_entry )) != VCOS_SUCCESS )
9361 + {
9362 + return status;
9363 + }
9364 + cmd_entry++;
9365 + }
9366 + return VCOS_SUCCESS;
9367 +}
9368 +
9369 --- /dev/null
9370 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_common.h
9371 @@ -0,0 +1,76 @@
9372 +/*=============================================================================
9373 +Copyright (c) 2009 Broadcom Europe Limited.
9374 +All rights reserved.
9375 +
9376 +Project : vcfw
9377 +Module : chip driver
9378 +
9379 +FILE DESCRIPTION
9380 +VideoCore OS Abstraction Layer - common postamble code
9381 +=============================================================================*/
9382 +
9383 +/** \file
9384 + *
9385 + * Postamble code included by the platform-specific header files
9386 + */
9387 +
9388 +#define VCOS_THREAD_PRI_DEFAULT VCOS_THREAD_PRI_NORMAL
9389 +
9390 +#if !defined(VCOS_THREAD_PRI_INCREASE)
9391 +#error Which way to thread priorities go?
9392 +#endif
9393 +
9394 +#if VCOS_THREAD_PRI_INCREASE < 0
9395 +/* smaller numbers are higher priority */
9396 +#define VCOS_THREAD_PRI_LESS(x) ((x)<VCOS_THREAD_PRI_MAX?(x)+1:VCOS_THREAD_PRI_MAX)
9397 +#define VCOS_THREAD_PRI_MORE(x) ((x)>VCOS_THREAD_PRI_MIN?(x)-1:VCOS_THREAD_PRI_MIN)
9398 +#else
9399 +/* bigger numbers are lower priority */
9400 +#define VCOS_THREAD_PRI_MORE(x) ((x)<VCOS_THREAD_PRI_MAX?(x)+1:VCOS_THREAD_PRI_MAX)
9401 +#define VCOS_THREAD_PRI_LESS(x) ((x)>VCOS_THREAD_PRI_MIN?(x)-1:VCOS_THREAD_PRI_MIN)
9402 +#endif
9403 +
9404 +/* Convenience for Brits: */
9405 +#define VCOS_APPLICATION_INITIALISE VCOS_APPLICATION_INITIALIZE
9406 +
9407 +/*
9408 + * Check for constant definitions
9409 + */
9410 +#ifndef VCOS_TICKS_PER_SECOND
9411 +#error VCOS_TICKS_PER_SECOND not defined
9412 +#endif
9413 +
9414 +#if !defined(VCOS_THREAD_PRI_MIN) || !defined(VCOS_THREAD_PRI_MAX)
9415 +#error Priority range not defined
9416 +#endif
9417 +
9418 +#if !defined(VCOS_THREAD_PRI_HIGHEST) || !defined(VCOS_THREAD_PRI_LOWEST) || !defined(VCOS_THREAD_PRI_NORMAL)
9419 +#error Priority ordering not defined
9420 +#endif
9421 +
9422 +#if !defined(VCOS_CAN_SET_STACK_ADDR)
9423 +#error Can stack addresses be set on this platform? Please set this macro to either 0 or 1.
9424 +#endif
9425 +
9426 +#if (_VCOS_AFFINITY_CPU0|_VCOS_AFFINITY_CPU1) & (~_VCOS_AFFINITY_MASK)
9427 +#error _VCOS_AFFINITY_CPUxxx values are not consistent with _VCOS_AFFINITY_MASK
9428 +#endif
9429 +
9430 +/** Append to the end of a singly-linked queue, O(1). Works with
9431 + * any structure where list has members 'head' and 'tail' and
9432 + * item has a 'next' pointer.
9433 + */
9434 +#define VCOS_QUEUE_APPEND_TAIL(list, item) {\
9435 + (item)->next = NULL;\
9436 + if (!(list)->head) {\
9437 + (list)->head = (list)->tail = (item); \
9438 + } else {\
9439 + (list)->tail->next = (item); \
9440 + (list)->tail = (item); \
9441 + } \
9442 +}
9443 +
9444 +#ifndef VCOS_HAVE_TIMER
9445 +VCOSPRE_ void VCOSPOST_ vcos_timer_init(void);
9446 +#endif
9447 +
9448 --- /dev/null
9449 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_blockpool.h
9450 @@ -0,0 +1,260 @@
9451 +/*=============================================================================
9452 +Copyright (c) 2011 Broadcom Europe Limited.
9453 +All rights reserved.
9454 +
9455 +Project : vcfw
9456 +Module : chip driver
9457 +
9458 +FILE DESCRIPTION
9459 +VideoCore OS Abstraction Layer - event flags implemented via a semaphore
9460 +=============================================================================*/
9461 +
9462 +#ifndef VCOS_GENERIC_BLOCKPOOL_H
9463 +#define VCOS_GENERIC_BLOCKPOOL_H
9464 +
9465 +/**
9466 + * \file
9467 + *
9468 + * This provides a generic, thread safe implementation of a VCOS block pool
9469 + * fixed size memory allocator.
9470 + */
9471 +
9472 +#ifdef __cplusplus
9473 +extern "C" {
9474 +#endif
9475 +
9476 +#include "interface/vcos/vcos_types.h"
9477 +
9478 +/** Bits 0 to (VCOS_BLOCKPOOL_SUBPOOL_BITS - 1) are used to store the
9479 + * subpool id. */
9480 +#define VCOS_BLOCKPOOL_SUBPOOL_BITS 3
9481 +#define VCOS_BLOCKPOOL_MAX_SUBPOOLS (1 << VCOS_BLOCKPOOL_SUBPOOL_BITS)
9482 +
9483 +/* Make zero an invalid handle at the cost of decreasing the maximum
9484 + * number of blocks (2^28) by 1. Alternatively, a spare bit could be
9485 + * used to indicated valid blocks but there are likely to be better
9486 + * uses for spare bits. e.g. allowing more subpools
9487 + */
9488 +#define INDEX_OFFSET 1
9489 +
9490 +#define VCOS_BLOCKPOOL_HANDLE_GET_INDEX(h) \
9491 + (((h) >> VCOS_BLOCKPOOL_SUBPOOL_BITS) - INDEX_OFFSET)
9492 +
9493 +#define VCOS_BLOCKPOOL_HANDLE_GET_SUBPOOL(h) \
9494 + ((h) & ((1 << VCOS_BLOCKPOOL_SUBPOOL_BITS) - 1))
9495 +
9496 +#define VCOS_BLOCKPOOL_HANDLE_CREATE(i,s) \
9497 + ((((i) + INDEX_OFFSET) << VCOS_BLOCKPOOL_SUBPOOL_BITS) | (s))
9498 +
9499 +#define VCOS_BLOCKPOOL_INVALID_HANDLE 0
9500 +
9501 +typedef struct VCOS_BLOCKPOOL_HEADER_TAG
9502 +{
9503 + /* Blocks either refer to to the pool if they are allocated
9504 + * or the free list if they are available.
9505 + */
9506 + union {
9507 + struct VCOS_BLOCKPOOL_HEADER_TAG *next;
9508 + struct VCOS_BLOCKPOOL_SUBPOOL_TAG* subpool;
9509 + } owner;
9510 +} VCOS_BLOCKPOOL_HEADER_T;
9511 +
9512 +typedef struct VCOS_BLOCKPOOL_SUBPOOL_TAG
9513 +{
9514 + /** VCOS_BLOCKPOOL_SUBPOOL_MAGIC */
9515 + uint32_t magic;
9516 + VCOS_BLOCKPOOL_HEADER_T* free_list;
9517 + /* The start of the pool memory */
9518 + void *mem;
9519 + /* Address of the first block header */
9520 + void *start;
9521 + /** The number of blocks in this sub-pool */
9522 + VCOS_UNSIGNED num_blocks;
9523 + /** Current number of available blocks in this sub-pool */
9524 + VCOS_UNSIGNED available_blocks;
9525 + /** Pointers to the pool that owns this sub-pool */
9526 + struct VCOS_BLOCKPOOL_TAG* owner;
9527 + /** Define properties such as memory ownership */
9528 + uint32_t flags;
9529 +} VCOS_BLOCKPOOL_SUBPOOL_T;
9530 +
9531 +typedef struct VCOS_BLOCKPOOL_TAG
9532 +{
9533 + /** VCOS_BLOCKPOOL_MAGIC */
9534 + uint32_t magic;
9535 + /** Thread safety for Alloc, Free, Delete, Stats */
9536 + VCOS_MUTEX_T mutex;
9537 + /** The size of the block data */
9538 + size_t block_data_size;
9539 + /** Block size inc overheads */
9540 + size_t block_size;
9541 + /** Name for debugging */
9542 + const char *name;
9543 + /* The number of subpools that may be used */
9544 + VCOS_UNSIGNED num_subpools;
9545 + /** Number of blocks in each dynamically allocated subpool */
9546 + VCOS_UNSIGNED num_extension_blocks;
9547 + /** Array of subpools. Subpool zero is is not deleted until the pool is
9548 + * destroed. If the index of the pool is < num_subpools and
9549 + * subpool[index.mem] is null then the subpool entry is valid but
9550 + * "not currently allocated" */
9551 + VCOS_BLOCKPOOL_SUBPOOL_T subpools[VCOS_BLOCKPOOL_MAX_SUBPOOLS];
9552 +} VCOS_BLOCKPOOL_T;
9553 +
9554 +#define VCOS_BLOCKPOOL_ROUND_UP(x,s) (((x) + ((s) - 1)) & ~((s) - 1))
9555 +/**
9556 + * Calculates the size in bytes required for a block pool containing
9557 + * num_blocks of size block_size plus any overheads.
9558 + *
9559 + * The block pool header (VCOS_BLOCKPOOL_T) is allocated separately
9560 + *
9561 + * Overheads:
9562 + * block_size + header must be a multiple of sizeof(void*)
9563 + * The start of the first block may need to be up to wordsize - 1 bytes
9564 + * into the given buffer because statically allocated buffers within structures
9565 + * are not guaranteed to be word aligned.
9566 + */
9567 +#define VCOS_BLOCKPOOL_SIZE(num_blocks, block_size) \
9568 + ((VCOS_BLOCKPOOL_ROUND_UP((block_size) + sizeof(VCOS_BLOCKPOOL_HEADER_T), \
9569 + sizeof(void*)) * (num_blocks)) + sizeof(void*))
9570 +
9571 +/**
9572 + * Sanity check to verify whether a handle is potentially a blockpool handle
9573 + * when the pool pointer is not available.
9574 + *
9575 + * If the pool pointer is availabe use vcos_blockpool_elem_to_handle instead.
9576 + *
9577 + * @param handle the handle to verify
9578 + * @param max_blocks the expected maximum number of block in the pool
9579 + * that the handle belongs to.
9580 + */
9581 +#define VCOS_BLOCKPOOL_IS_VALID_HANDLE_FORMAT(handle, max_blocks) \
9582 + ((handle) != VCOS_BLOCKPOOL_INVALID_HANDLE \
9583 + && VCOS_BLOCKPOOL_HANDLE_GET_INDEX((handle)) < (max_blocks))
9584 +
9585 +VCOSPRE_
9586 + VCOS_STATUS_T VCOSPOST_ vcos_generic_blockpool_init(VCOS_BLOCKPOOL_T *pool,
9587 + VCOS_UNSIGNED num_blocks, VCOS_UNSIGNED block_size,
9588 + void *start, VCOS_UNSIGNED pool_size, const char *name);
9589 +
9590 +VCOSPRE_
9591 + VCOS_STATUS_T VCOSPOST_ vcos_generic_blockpool_create_on_heap(
9592 + VCOS_BLOCKPOOL_T *pool, VCOS_UNSIGNED num_blocks,
9593 + VCOS_UNSIGNED block_size, const char *name);
9594 +
9595 +VCOSPRE_
9596 + VCOS_STATUS_T VCOSPOST_ vcos_generic_blockpool_extend(VCOS_BLOCKPOOL_T *pool,
9597 + VCOS_UNSIGNED num_extensions, VCOS_UNSIGNED num_blocks);
9598 +
9599 +VCOSPRE_ void VCOSPOST_ *vcos_generic_blockpool_alloc(VCOS_BLOCKPOOL_T *pool);
9600 +
9601 +VCOSPRE_ void VCOSPOST_ *vcos_generic_blockpool_calloc(VCOS_BLOCKPOOL_T *pool);
9602 +
9603 +VCOSPRE_ void VCOSPOST_ vcos_generic_blockpool_free(void *block);
9604 +
9605 +VCOSPRE_
9606 + VCOS_UNSIGNED VCOSPOST_ vcos_generic_blockpool_available_count(
9607 + VCOS_BLOCKPOOL_T *pool);
9608 +
9609 +VCOSPRE_
9610 + VCOS_UNSIGNED VCOSPOST_ vcos_generic_blockpool_used_count(
9611 + VCOS_BLOCKPOOL_T *pool);
9612 +
9613 +VCOSPRE_ void VCOSPOST_ vcos_generic_blockpool_delete(VCOS_BLOCKPOOL_T *pool);
9614 +
9615 +VCOSPRE_ uint32_t VCOSPOST_ vcos_generic_blockpool_elem_to_handle(void *block);
9616 +
9617 +VCOSPRE_ void VCOSPOST_
9618 + *vcos_generic_blockpool_elem_from_handle(
9619 + VCOS_BLOCKPOOL_T *pool, uint32_t handle);
9620 +
9621 +VCOSPRE_ uint32_t VCOSPOST_
9622 + vcos_generic_blockpool_is_valid_elem(
9623 + VCOS_BLOCKPOOL_T *pool, const void *block);
9624 +#if defined(VCOS_INLINE_BODIES)
9625 +
9626 +VCOS_INLINE_IMPL
9627 +VCOS_STATUS_T vcos_blockpool_init(VCOS_BLOCKPOOL_T *pool,
9628 + VCOS_UNSIGNED num_blocks, VCOS_UNSIGNED block_size,
9629 + void *start, VCOS_UNSIGNED pool_size, const char *name)
9630 +{
9631 + return vcos_generic_blockpool_init(pool, num_blocks, block_size,
9632 + start, pool_size, name);
9633 +}
9634 +
9635 +VCOS_INLINE_IMPL
9636 +VCOS_STATUS_T vcos_blockpool_create_on_heap(VCOS_BLOCKPOOL_T *pool,
9637 + VCOS_UNSIGNED num_blocks, VCOS_UNSIGNED block_size, const char *name)
9638 +{
9639 + return vcos_generic_blockpool_create_on_heap(
9640 + pool, num_blocks, block_size, name);
9641 +}
9642 +
9643 +VCOS_INLINE_IMPL
9644 + VCOS_STATUS_T VCOSPOST_ vcos_blockpool_extend(VCOS_BLOCKPOOL_T *pool,
9645 + VCOS_UNSIGNED num_extensions, VCOS_UNSIGNED num_blocks)
9646 +{
9647 + return vcos_generic_blockpool_extend(pool, num_extensions, num_blocks);
9648 +}
9649 +
9650 +VCOS_INLINE_IMPL
9651 +void *vcos_blockpool_alloc(VCOS_BLOCKPOOL_T *pool)
9652 +{
9653 + return vcos_generic_blockpool_alloc(pool);
9654 +}
9655 +
9656 +VCOS_INLINE_IMPL
9657 +void *vcos_blockpool_calloc(VCOS_BLOCKPOOL_T *pool)
9658 +{
9659 + return vcos_generic_blockpool_calloc(pool);
9660 +}
9661 +
9662 +VCOS_INLINE_IMPL
9663 +void vcos_blockpool_free(void *block)
9664 +{
9665 + vcos_generic_blockpool_free(block);
9666 +}
9667 +
9668 +VCOS_INLINE_IMPL
9669 +VCOS_UNSIGNED vcos_blockpool_available_count(VCOS_BLOCKPOOL_T *pool)
9670 +{
9671 + return vcos_generic_blockpool_available_count(pool);
9672 +}
9673 +
9674 +VCOS_INLINE_IMPL
9675 +VCOS_UNSIGNED vcos_blockpool_used_count(VCOS_BLOCKPOOL_T *pool)
9676 +{
9677 + return vcos_generic_blockpool_used_count(pool);
9678 +}
9679 +
9680 +VCOS_INLINE_IMPL
9681 +void vcos_blockpool_delete(VCOS_BLOCKPOOL_T *pool)
9682 +{
9683 + vcos_generic_blockpool_delete(pool);
9684 +}
9685 +
9686 +VCOS_INLINE_IMPL
9687 +uint32_t vcos_blockpool_elem_to_handle(void *block)
9688 +{
9689 + return vcos_generic_blockpool_elem_to_handle(block);
9690 +}
9691 +
9692 +VCOS_INLINE_IMPL
9693 +void *vcos_blockpool_elem_from_handle(VCOS_BLOCKPOOL_T *pool, uint32_t handle)
9694 +{
9695 + return vcos_generic_blockpool_elem_from_handle(pool, handle);
9696 +}
9697 +
9698 +VCOS_INLINE_IMPL
9699 +uint32_t vcos_blockpool_is_valid_elem(VCOS_BLOCKPOOL_T *pool, const void *block)
9700 +{
9701 + return vcos_generic_blockpool_is_valid_elem(pool, block);
9702 +}
9703 +#endif /* VCOS_INLINE_BODIES */
9704 +
9705 +
9706 +#ifdef __cplusplus
9707 +}
9708 +#endif
9709 +#endif /* VCOS_GENERIC_BLOCKPOOL_H */
9710 +
9711 --- /dev/null
9712 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_event_flags.c
9713 @@ -0,0 +1,297 @@
9714 +/*=============================================================================
9715 +Copyright (c) 2009 Broadcom Europe Limited.
9716 +All rights reserved.
9717 +
9718 +FILE DESCRIPTION
9719 +VideoCore OS Abstraction Layer - event flags implemented via mutexes
9720 +=============================================================================*/
9721 +
9722 +#include "interface/vcos/vcos.h"
9723 +#include "interface/vcos/generic/vcos_generic_event_flags.h"
9724 +
9725 +#include <stddef.h>
9726 +
9727 +/** A structure created by a thread that waits on the event flags
9728 + * for a particular combination of flags to arrive.
9729 + */
9730 +typedef struct VCOS_EVENT_WAITER_T
9731 +{
9732 + VCOS_UNSIGNED requested_events; /**< The events wanted */
9733 + VCOS_UNSIGNED actual_events; /**< Actual events found */
9734 + VCOS_UNSIGNED op; /**< The event operation to be used */
9735 + VCOS_STATUS_T return_status; /**< The return status the waiter should pass back */
9736 + VCOS_EVENT_FLAGS_T *flags; /**< Pointer to the original 'flags' structure */
9737 + VCOS_THREAD_T *thread; /**< Thread waiting */
9738 + struct VCOS_EVENT_WAITER_T *next;
9739 +} VCOS_EVENT_WAITER_T;
9740 +
9741 +#ifndef NDEBUG
9742 +static int waiter_list_valid(VCOS_EVENT_FLAGS_T *flags);
9743 +#endif
9744 +static void event_flags_timer_expired(void *cxt);
9745 +
9746 +VCOS_STATUS_T vcos_generic_event_flags_create(VCOS_EVENT_FLAGS_T *flags, const char *name)
9747 +{
9748 + VCOS_STATUS_T rc;
9749 + if ((rc=vcos_mutex_create(&flags->lock, name)) != VCOS_SUCCESS)
9750 + {
9751 + return rc;
9752 + }
9753 +
9754 + flags->events = 0;
9755 + flags->waiters.head = flags->waiters.tail = 0;
9756 + return rc;
9757 +}
9758 +
9759 +void vcos_generic_event_flags_set(VCOS_EVENT_FLAGS_T *flags,
9760 + VCOS_UNSIGNED bitmask,
9761 + VCOS_OPTION op)
9762 +{
9763 + vcos_assert(flags);
9764 + vcos_mutex_lock(&flags->lock);
9765 + if (op == VCOS_OR)
9766 + {
9767 + flags->events |= bitmask;
9768 + }
9769 + else if (op == VCOS_AND)
9770 + {
9771 + flags->events &= bitmask;
9772 + }
9773 + else
9774 + {
9775 + vcos_assert(0);
9776 + }
9777 +
9778 + /* Now wake up any threads that have now become signalled. */
9779 + if (flags->waiters.head != NULL)
9780 + {
9781 + VCOS_UNSIGNED consumed_events = 0;
9782 + VCOS_EVENT_WAITER_T **pcurrent_waiter = &flags->waiters.head;
9783 + VCOS_EVENT_WAITER_T *prev_waiter = NULL;
9784 +
9785 + /* Walk the chain of tasks suspend on this event flag group to determine
9786 + * if any of their requests can be satisfied.
9787 + */
9788 + while ((*pcurrent_waiter) != NULL)
9789 + {
9790 + VCOS_EVENT_WAITER_T *curr_waiter = *pcurrent_waiter;
9791 +
9792 + /* Determine if this request has been satisfied */
9793 +
9794 + /* First, find the event flags in common. */
9795 + VCOS_UNSIGNED waiter_satisfied = flags->events & curr_waiter->requested_events;
9796 +
9797 + /* Second, determine if all the event flags must match */
9798 + if (curr_waiter->op & VCOS_AND)
9799 + {
9800 + /* All requested events must be present */
9801 + waiter_satisfied = (waiter_satisfied == curr_waiter->requested_events);
9802 + }
9803 +
9804 + /* Wake this one up? */
9805 + if (waiter_satisfied)
9806 + {
9807 +
9808 + if (curr_waiter->op & VCOS_CONSUME)
9809 + {
9810 + consumed_events |= curr_waiter->requested_events;
9811 + }
9812 +
9813 + /* remove this block from the list, taking care at the end */
9814 + *pcurrent_waiter = curr_waiter->next;
9815 + if (curr_waiter->next == NULL)
9816 + flags->waiters.tail = prev_waiter;
9817 +
9818 + vcos_assert(waiter_list_valid(flags));
9819 +
9820 + curr_waiter->return_status = VCOS_SUCCESS;
9821 + curr_waiter->actual_events = flags->events;
9822 +
9823 + _vcos_thread_sem_post(curr_waiter->thread);
9824 + }
9825 + else
9826 + {
9827 + /* move to next element in the list */
9828 + prev_waiter = *pcurrent_waiter;
9829 + pcurrent_waiter = &(curr_waiter->next);
9830 + }
9831 + }
9832 +
9833 + flags->events &= ~consumed_events;
9834 +
9835 + }
9836 +
9837 + vcos_mutex_unlock(&flags->lock);
9838 +}
9839 +
9840 +void vcos_generic_event_flags_delete(VCOS_EVENT_FLAGS_T *flags)
9841 +{
9842 + vcos_mutex_delete(&flags->lock);
9843 +}
9844 +
9845 +extern VCOS_STATUS_T vcos_generic_event_flags_get(VCOS_EVENT_FLAGS_T *flags,
9846 + VCOS_UNSIGNED bitmask,
9847 + VCOS_OPTION op,
9848 + VCOS_UNSIGNED suspend,
9849 + VCOS_UNSIGNED *retrieved_bits)
9850 +{
9851 + VCOS_EVENT_WAITER_T waitreq;
9852 + VCOS_STATUS_T rc = VCOS_EAGAIN;
9853 + int satisfied = 0;
9854 +
9855 + vcos_assert(flags);
9856 +
9857 + /* default retrieved bits to 0 */
9858 + *retrieved_bits = 0;
9859 +
9860 + vcos_mutex_lock(&flags->lock);
9861 + switch (op & VCOS_EVENT_FLAG_OP_MASK)
9862 + {
9863 + case VCOS_AND:
9864 + if ((flags->events & bitmask) == bitmask)
9865 + {
9866 + *retrieved_bits = flags->events;
9867 + rc = VCOS_SUCCESS;
9868 + satisfied = 1;
9869 + if (op & VCOS_CONSUME)
9870 + flags->events &= ~bitmask;
9871 + }
9872 + break;
9873 +
9874 + case VCOS_OR:
9875 + if (flags->events & bitmask)
9876 + {
9877 + *retrieved_bits = flags->events;
9878 + rc = VCOS_SUCCESS;
9879 + satisfied = 1;
9880 + if (op & VCOS_CONSUME)
9881 + flags->events &= ~bitmask;
9882 + }
9883 + break;
9884 +
9885 + default:
9886 + vcos_assert(0);
9887 + rc = VCOS_EINVAL;
9888 + break;
9889 + }
9890 +
9891 + if (!satisfied && suspend)
9892 + {
9893 + /* Have to go to sleep.
9894 + *
9895 + * Append to tail so we get FIFO ordering.
9896 + */
9897 + waitreq.requested_events = bitmask;
9898 + waitreq.op = op;
9899 + waitreq.return_status = VCOS_EAGAIN;
9900 + waitreq.flags = flags;
9901 + waitreq.actual_events = 0;
9902 + waitreq.thread = vcos_thread_current();
9903 + waitreq.next = 0;
9904 + vcos_assert(waitreq.thread != (VCOS_THREAD_T*)-1);
9905 + VCOS_QUEUE_APPEND_TAIL(&flags->waiters, &waitreq);
9906 +
9907 + if (suspend != (VCOS_UNSIGNED)-1)
9908 + _vcos_task_timer_set(event_flags_timer_expired, &waitreq, suspend);
9909 +
9910 + vcos_mutex_unlock(&flags->lock);
9911 + /* go to sleep and wait to be signalled or timeout */
9912 +
9913 + _vcos_thread_sem_wait();
9914 +
9915 + *retrieved_bits = waitreq.actual_events;
9916 + rc = waitreq.return_status;
9917 +
9918 + /* cancel the timer - do not do this while holding the mutex as it
9919 + * might be waiting for the timeout function to complete, which will
9920 + * try to take the mutex.
9921 + */
9922 + if (suspend != (VCOS_UNSIGNED)-1)
9923 + _vcos_task_timer_cancel();
9924 + }
9925 + else
9926 + {
9927 + vcos_mutex_unlock(&flags->lock);
9928 + }
9929 +
9930 + return rc;
9931 +}
9932 +
9933 +
9934 +/** Called when a get call times out. Remove this thread's
9935 + * entry from the waiting queue, then resume the thread.
9936 + */
9937 +static void event_flags_timer_expired(void *cxt)
9938 +{
9939 + VCOS_EVENT_WAITER_T *waitreq = (VCOS_EVENT_WAITER_T *)cxt;
9940 + VCOS_EVENT_FLAGS_T *flags = waitreq->flags;
9941 + VCOS_EVENT_WAITER_T **plist;
9942 + VCOS_EVENT_WAITER_T *prev = NULL;
9943 + VCOS_THREAD_T *thread = 0;
9944 +
9945 + vcos_assert(flags);
9946 +
9947 + vcos_mutex_lock(&flags->lock);
9948 +
9949 + /* walk the list of waiting threads on this event group, and remove
9950 + * the one that has expired.
9951 + *
9952 + * FIXME: could use doubly-linked list if lots of threads are found
9953 + * to be waiting on a single event flag instance.
9954 + */
9955 + plist = &flags->waiters.head;
9956 + while (*plist != NULL)
9957 + {
9958 + if (*plist == waitreq)
9959 + {
9960 + int at_end;
9961 + /* found it */
9962 + thread = (*plist)->thread;
9963 + at_end = ((*plist)->next == NULL);
9964 +
9965 + /* link past */
9966 + *plist = (*plist)->next;
9967 + if (at_end)
9968 + flags->waiters.tail = prev;
9969 +
9970 + break;
9971 + }
9972 + prev = *plist;
9973 + plist = &(*plist)->next;
9974 + }
9975 + vcos_assert(waiter_list_valid(flags));
9976 +
9977 + vcos_mutex_unlock(&flags->lock);
9978 +
9979 + if (thread)
9980 + {
9981 + _vcos_thread_sem_post(thread);
9982 + }
9983 +}
9984 +
9985 +#ifndef NDEBUG
9986 +
9987 +static int waiter_list_valid(VCOS_EVENT_FLAGS_T *flags)
9988 +{
9989 + int valid;
9990 + /* Either both head and tail are NULL, or neither are NULL */
9991 + if (flags->waiters.head == NULL)
9992 + {
9993 + valid = (flags->waiters.tail == NULL);
9994 + }
9995 + else
9996 + {
9997 + valid = (flags->waiters.tail != NULL);
9998 + }
9999 +
10000 + /* If head and tail point at the same non-NULL element, then there
10001 + * is only one element in the list.
10002 + */
10003 + if (flags->waiters.head && (flags->waiters.head == flags->waiters.tail))
10004 + {
10005 + valid = (flags->waiters.head->next == NULL);
10006 + }
10007 + return valid;
10008 +}
10009 +
10010 +#endif
10011 --- /dev/null
10012 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_event_flags.h
10013 @@ -0,0 +1,104 @@
10014 +/*=============================================================================
10015 +Copyright (c) 2009 Broadcom Europe Limited.
10016 +All rights reserved.
10017 +
10018 +FILE DESCRIPTION
10019 +VideoCore OS Abstraction Layer - event flags implemented via a semaphore
10020 +=============================================================================*/
10021 +
10022 +#ifndef VCOS_GENERIC_EVENT_FLAGS_H
10023 +#define VCOS_GENERIC_EVENT_FLAGS_H
10024 +
10025 +#ifdef __cplusplus
10026 +extern "C" {
10027 +#endif
10028 +
10029 +#include "interface/vcos/vcos_types.h"
10030 +
10031 +/**
10032 + * \file
10033 + *
10034 + * This provides event flags (as per Nucleus Event Groups) based on a
10035 + * mutex, a semaphore (per waiting thread) and a timer (per waiting
10036 + * thread).
10037 + *
10038 + * The data structure is a 32 bit unsigned int (the current set of
10039 + * flags) and a linked list of clients waiting to be 'satisfied'.
10040 + *
10041 + * The mutex merely locks access to the data structure. If a client
10042 + * calls vcos_event_flags_get() and the requested bits are not already
10043 + * present, it then sleeps on its per-thread semaphore after adding
10044 + * this semaphore to the queue waiting. It also sets up a timer.
10045 + *
10046 + * The per-thread semaphore and timer are actually stored in the
10047 + * thread context (joinable thread). In future it may become necessary
10048 + * to support non-VCOS threads by using thread local storage to
10049 + * create these objects and associate them with the thread.
10050 + */
10051 +
10052 +struct VCOS_EVENT_WAITER_T;
10053 +
10054 +typedef struct VCOS_EVENT_FLAGS_T
10055 +{
10056 + VCOS_UNSIGNED events; /**< Events currently set */
10057 + VCOS_MUTEX_T lock; /**< Serialize access */
10058 + struct
10059 + {
10060 + struct VCOS_EVENT_WAITER_T *head; /**< List of threads waiting */
10061 + struct VCOS_EVENT_WAITER_T *tail; /**< List of threads waiting */
10062 + } waiters;
10063 +} VCOS_EVENT_FLAGS_T;
10064 +
10065 +#define VCOS_OR 1
10066 +#define VCOS_AND 2
10067 +#define VCOS_CONSUME 4
10068 +#define VCOS_OR_CONSUME (VCOS_OR | VCOS_CONSUME)
10069 +#define VCOS_AND_CONSUME (VCOS_AND | VCOS_CONSUME)
10070 +#define VCOS_EVENT_FLAG_OP_MASK (VCOS_OR|VCOS_AND)
10071 +
10072 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_generic_event_flags_create(VCOS_EVENT_FLAGS_T *flags, const char *name);
10073 +VCOSPRE_ void VCOSPOST_ vcos_generic_event_flags_set(VCOS_EVENT_FLAGS_T *flags,
10074 + VCOS_UNSIGNED events,
10075 + VCOS_OPTION op);
10076 +VCOSPRE_ void VCOSPOST_ vcos_generic_event_flags_delete(VCOS_EVENT_FLAGS_T *);
10077 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_generic_event_flags_get(VCOS_EVENT_FLAGS_T *flags,
10078 + VCOS_UNSIGNED requested_events,
10079 + VCOS_OPTION op,
10080 + VCOS_UNSIGNED suspend,
10081 + VCOS_UNSIGNED *retrieved_events);
10082 +
10083 +#ifdef VCOS_INLINE_BODIES
10084 +
10085 +VCOS_INLINE_IMPL
10086 +VCOS_STATUS_T vcos_event_flags_create(VCOS_EVENT_FLAGS_T *flags, const char *name) {
10087 + return vcos_generic_event_flags_create(flags, name);
10088 +}
10089 +
10090 +VCOS_INLINE_IMPL
10091 +void vcos_event_flags_set(VCOS_EVENT_FLAGS_T *flags,
10092 + VCOS_UNSIGNED events,
10093 + VCOS_OPTION op) {
10094 + vcos_generic_event_flags_set(flags, events, op);
10095 +}
10096 +
10097 +VCOS_INLINE_IMPL
10098 +void vcos_event_flags_delete(VCOS_EVENT_FLAGS_T *f) {
10099 + vcos_generic_event_flags_delete(f);
10100 +}
10101 +
10102 +VCOS_INLINE_IMPL
10103 +VCOS_STATUS_T vcos_event_flags_get(VCOS_EVENT_FLAGS_T *flags,
10104 + VCOS_UNSIGNED requested_events,
10105 + VCOS_OPTION op,
10106 + VCOS_UNSIGNED suspend,
10107 + VCOS_UNSIGNED *retrieved_events) {
10108 + return vcos_generic_event_flags_get(flags, requested_events, op, suspend, retrieved_events);
10109 +}
10110 +
10111 +#endif /* VCOS_INLINE_BODIES */
10112 +
10113 +#ifdef __cplusplus
10114 +}
10115 +#endif
10116 +#endif
10117 +
10118 --- /dev/null
10119 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_named_sem.h
10120 @@ -0,0 +1,81 @@
10121 +/*=============================================================================
10122 +Copyright (c) 2009 Broadcom Europe Limited.
10123 +All rights reserved.
10124 +
10125 +Project : vcfw
10126 +Module : chip driver
10127 +
10128 +FILE DESCRIPTION
10129 +VideoCore OS Abstraction Layer - named semaphores
10130 +=============================================================================*/
10131 +
10132 +#ifndef VCOS_GENERIC_NAMED_SEM_H
10133 +#define VCOS_GENERIC_NAMED_SEM_H
10134 +
10135 +#ifdef __cplusplus
10136 +extern "C" {
10137 +#endif
10138 +
10139 +#include "interface/vcos/vcos_types.h"
10140 +
10141 +/**
10142 + * \file
10143 + *
10144 + * Generic support for named semaphores, using regular ones. This is only
10145 + * suitable for emulating them on an embedded MMUless system, since there is
10146 + * no support for opening semaphores across process boundaries.
10147 + *
10148 + */
10149 +
10150 +#define VCOS_NAMED_SEMAPHORE_NAMELEN 64
10151 +
10152 +/* In theory we could use the name facility provided within Nucleus. However, this
10153 + * is hard to do as semaphores are constantly being created and destroyed; we
10154 + * would need to stop everything while allocating the memory for the semaphore
10155 + * list and then walking it. So keep our own list.
10156 + */
10157 +typedef struct VCOS_NAMED_SEMAPHORE_T
10158 +{
10159 + struct VCOS_NAMED_SEMAPHORE_IMPL_T *actual; /**< There are 'n' named semaphores per 1 actual semaphore */
10160 + VCOS_SEMAPHORE_T *sem; /**< Pointer to actual underlying semaphore */
10161 +} VCOS_NAMED_SEMAPHORE_T;
10162 +
10163 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_
10164 +vcos_generic_named_semaphore_create(VCOS_NAMED_SEMAPHORE_T *sem, const char *name, VCOS_UNSIGNED count);
10165 +
10166 +VCOSPRE_ void VCOSPOST_ vcos_named_semaphore_delete(VCOS_NAMED_SEMAPHORE_T *sem);
10167 +
10168 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ _vcos_named_semaphore_init(void);
10169 +VCOSPRE_ void VCOSPOST_ _vcos_named_semaphore_deinit(void);
10170 +
10171 +#if defined(VCOS_INLINE_BODIES)
10172 +
10173 +VCOS_INLINE_IMPL
10174 +VCOS_STATUS_T vcos_named_semaphore_create(VCOS_NAMED_SEMAPHORE_T *sem, const char *name, VCOS_UNSIGNED count) {
10175 + return vcos_generic_named_semaphore_create(sem, name, count);
10176 +}
10177 +
10178 +VCOS_INLINE_IMPL
10179 +void vcos_named_semaphore_wait(VCOS_NAMED_SEMAPHORE_T *sem) {
10180 + vcos_semaphore_wait(sem->sem);
10181 +}
10182 +
10183 +VCOS_INLINE_IMPL
10184 +VCOS_STATUS_T vcos_named_semaphore_trywait(VCOS_NAMED_SEMAPHORE_T *sem) {
10185 + return vcos_semaphore_trywait(sem->sem);
10186 +}
10187 +
10188 +VCOS_INLINE_IMPL
10189 +void vcos_named_semaphore_post(VCOS_NAMED_SEMAPHORE_T *sem) {
10190 + vcos_semaphore_post(sem->sem);
10191 +}
10192 +
10193 +
10194 +#endif
10195 +
10196 +#ifdef __cplusplus
10197 +}
10198 +#endif
10199 +#endif
10200 +
10201 +
10202 --- /dev/null
10203 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_quickslow_mutex.h
10204 @@ -0,0 +1,75 @@
10205 +/*=============================================================================
10206 +Copyright (c) 2009 Broadcom Europe Limited.
10207 +All rights reserved.
10208 +
10209 +Project : vcfw
10210 +Module : chip driver
10211 +
10212 +FILE DESCRIPTION
10213 +VideoCore OS Abstraction Layer - reentrant mutexes created from regular ones.
10214 +=============================================================================*/
10215 +
10216 +#ifndef VCOS_GENERIC_QUICKSLOW_MUTEX_H
10217 +#define VCOS_GENERIC_QUICKSLOW_MUTEX_H
10218 +
10219 +#ifdef __cplusplus
10220 +extern "C" {
10221 +#endif
10222 +
10223 +#include "interface/vcos/vcos_types.h"
10224 +
10225 +/**
10226 + * \file
10227 + *
10228 + * Quickslow Mutexes implemented as regular ones (i.e. quick and slow modes are the same).
10229 + *
10230 + */
10231 +
10232 +typedef VCOS_MUTEX_T VCOS_QUICKSLOW_MUTEX_T;
10233 +
10234 +#if defined(VCOS_INLINE_BODIES)
10235 +VCOS_INLINE_IMPL
10236 +VCOS_STATUS_T vcos_quickslow_mutex_create(VCOS_QUICKSLOW_MUTEX_T *m, const char *name)
10237 +{
10238 + return vcos_mutex_create(m, name);
10239 +}
10240 +
10241 +VCOS_INLINE_IMPL
10242 +void vcos_quickslow_mutex_delete(VCOS_QUICKSLOW_MUTEX_T *m)
10243 +{
10244 + vcos_mutex_delete(m);
10245 +}
10246 +
10247 +VCOS_INLINE_IMPL
10248 +void vcos_quickslow_mutex_lock(VCOS_QUICKSLOW_MUTEX_T *m)
10249 +{
10250 + while (vcos_mutex_lock(m) == VCOS_EAGAIN);
10251 +}
10252 +
10253 +VCOS_INLINE_IMPL
10254 +void vcos_quickslow_mutex_unlock(VCOS_QUICKSLOW_MUTEX_T *m)
10255 +{
10256 + vcos_mutex_unlock(m);
10257 +}
10258 +
10259 +VCOS_INLINE_IMPL
10260 +void vcos_quickslow_mutex_lock_quick(VCOS_QUICKSLOW_MUTEX_T *m)
10261 +{
10262 + while (vcos_mutex_lock(m) == VCOS_EAGAIN);
10263 +}
10264 +
10265 +VCOS_INLINE_IMPL
10266 +void vcos_quickslow_mutex_unlock_quick(VCOS_QUICKSLOW_MUTEX_T *m)
10267 +{
10268 + vcos_mutex_unlock(m);
10269 +}
10270 +
10271 +#endif
10272 +
10273 +
10274 +#ifdef __cplusplus
10275 +}
10276 +#endif
10277 +#endif
10278 +
10279 +
10280 --- /dev/null
10281 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_reentrant_mtx.h
10282 @@ -0,0 +1,75 @@
10283 +/*=============================================================================
10284 +Copyright (c) 2009 Broadcom Europe Limited.
10285 +All rights reserved.
10286 +
10287 +Project : vcfw
10288 +Module : chip driver
10289 +
10290 +FILE DESCRIPTION
10291 +VideoCore OS Abstraction Layer - reentrant mutexes created from regular ones.
10292 +=============================================================================*/
10293 +
10294 +#ifndef VCOS_GENERIC_REENTRANT_MUTEX_H
10295 +#define VCOS_GENERIC_REENTRANT_MUTEX_H
10296 +
10297 +#ifdef __cplusplus
10298 +extern "C" {
10299 +#endif
10300 +
10301 +#include "interface/vcos/vcos_types.h"
10302 +
10303 +/**
10304 + * \file
10305 + *
10306 + * Reentrant Mutexes from regular ones.
10307 + *
10308 + */
10309 +
10310 +typedef struct VCOS_REENTRANT_MUTEX_T
10311 +{
10312 + VCOS_MUTEX_T mutex;
10313 + VCOS_THREAD_T *owner;
10314 + unsigned count;
10315 +} VCOS_REENTRANT_MUTEX_T;
10316 +
10317 +/* Extern definitions of functions that do the actual work */
10318 +
10319 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_generic_reentrant_mutex_create(VCOS_REENTRANT_MUTEX_T *m, const char *name);
10320 +
10321 +VCOSPRE_ void VCOSPOST_ vcos_generic_reentrant_mutex_delete(VCOS_REENTRANT_MUTEX_T *m);
10322 +
10323 +VCOSPRE_ void VCOSPOST_ vcos_generic_reentrant_mutex_lock(VCOS_REENTRANT_MUTEX_T *m);
10324 +
10325 +VCOSPRE_ void VCOSPOST_ vcos_generic_reentrant_mutex_unlock(VCOS_REENTRANT_MUTEX_T *m);
10326 +
10327 +/* Inline forwarding functions */
10328 +
10329 +#if defined(VCOS_INLINE_BODIES)
10330 +
10331 +VCOS_INLINE_IMPL
10332 +VCOS_STATUS_T vcos_reentrant_mutex_create(VCOS_REENTRANT_MUTEX_T *m, const char *name) {
10333 + return vcos_generic_reentrant_mutex_create(m,name);
10334 +}
10335 +
10336 +VCOS_INLINE_IMPL
10337 +void vcos_reentrant_mutex_delete(VCOS_REENTRANT_MUTEX_T *m) {
10338 + vcos_generic_reentrant_mutex_delete(m);
10339 +}
10340 +
10341 +VCOS_INLINE_IMPL
10342 +void vcos_reentrant_mutex_lock(VCOS_REENTRANT_MUTEX_T *m) {
10343 + vcos_generic_reentrant_mutex_lock(m);
10344 +}
10345 +
10346 +VCOS_INLINE_IMPL
10347 +void vcos_reentrant_mutex_unlock(VCOS_REENTRANT_MUTEX_T *m) {
10348 + vcos_generic_reentrant_mutex_unlock(m);
10349 +}
10350 +#endif
10351 +
10352 +#ifdef __cplusplus
10353 +}
10354 +#endif
10355 +#endif
10356 +
10357 +
10358 --- /dev/null
10359 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_generic_tls.h
10360 @@ -0,0 +1,144 @@
10361 +/*=============================================================================
10362 +Copyright (c) 2009 Broadcom Europe Limited.
10363 +All rights reserved.
10364 +
10365 +Project : vcfw
10366 +Module : chip driver
10367 +
10368 +FILE DESCRIPTION
10369 +VideoCore OS Abstraction Layer - generic thread local storage
10370 +=============================================================================*/
10371 +
10372 +#ifndef VCOS_GENERIC_TLS_H
10373 +#define VCOS_GENERIC_TLS_H
10374 +
10375 +#ifdef __cplusplus
10376 +extern "C" {
10377 +#endif
10378 +
10379 +#include "interface/vcos/vcos_types.h"
10380 +
10381 +/**
10382 + * \file
10383 + *
10384 + * Do an emulation of Thread Local Storage. The platform needs to
10385 + * provide a way to set and get a per-thread pointer which is
10386 + * where the TLS data itself is stored.
10387 + *
10388 + *
10389 + * Each thread that wants to join in this scheme needs to call
10390 + * vcos_tls_thread_register().
10391 + *
10392 + * The platform needs to support the macros/functions
10393 + * _vcos_tls_thread_ptr_set() and _vcos_tls_thread_ptr_get().
10394 + */
10395 +
10396 +#ifndef VCOS_WANT_TLS_EMULATION
10397 +#error Should not be included unless TLS emulation is defined
10398 +#endif
10399 +
10400 +/** Number of slots to reserve per thread. This results in an overhead
10401 + * of this many words per thread.
10402 + */
10403 +#define VCOS_TLS_MAX_SLOTS 4
10404 +
10405 +/** TLS key. Allocating one of these reserves the client one of the
10406 + * available slots.
10407 + */
10408 +typedef VCOS_UNSIGNED VCOS_TLS_KEY_T;
10409 +
10410 +/** TLS per-thread structure. Each thread gets one of these
10411 + * if TLS emulation (rather than native TLS support) is
10412 + * being used.
10413 + */
10414 +typedef struct VCOS_TLS_THREAD_T
10415 +{
10416 + void *slots[VCOS_TLS_MAX_SLOTS];
10417 +} VCOS_TLS_THREAD_T;
10418 +
10419 +/*
10420 + * Internal APIs
10421 + */
10422 +
10423 +/** Register this thread's TLS storage area. */
10424 +VCOSPRE_ void VCOSPOST_ vcos_tls_thread_register(VCOS_TLS_THREAD_T *);
10425 +
10426 +/** Create a new TLS key */
10427 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_generic_tls_create(VCOS_TLS_KEY_T *key);
10428 +
10429 +/** Delete a TLS key */
10430 +VCOSPRE_ void VCOSPOST_ vcos_generic_tls_delete(VCOS_TLS_KEY_T tls);
10431 +
10432 +/** Initialise the TLS library */
10433 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_tls_init(void);
10434 +
10435 +/** Deinitialise the TLS library */
10436 +VCOSPRE_ void VCOSPOST_ vcos_tls_deinit(void);
10437 +
10438 +#if defined(VCOS_INLINE_BODIES)
10439 +
10440 +#undef VCOS_ASSERT_LOGGING_DISABLE
10441 +#define VCOS_ASSERT_LOGGING_DISABLE 1
10442 +
10443 +/*
10444 + * Implementations of public API functions
10445 + */
10446 +
10447 +/** Set the given value. Since everything is per-thread, there is no need
10448 + * for any locking.
10449 + */
10450 +VCOS_INLINE_IMPL
10451 +VCOS_STATUS_T vcos_tls_set(VCOS_TLS_KEY_T tls, void *v) {
10452 + VCOS_TLS_THREAD_T *tlsdata = _vcos_tls_thread_ptr_get();
10453 + vcos_assert(tlsdata); /* Fires if this thread has not been registered */
10454 + if (tls<VCOS_TLS_MAX_SLOTS)
10455 + {
10456 + tlsdata->slots[tls] = v;
10457 + return VCOS_SUCCESS;
10458 + }
10459 + else
10460 + {
10461 + vcos_assert(0);
10462 + return VCOS_EINVAL;
10463 + }
10464 +}
10465 +
10466 +/** Get the given value. No locking required.
10467 + */
10468 +VCOS_INLINE_IMPL
10469 +void *vcos_tls_get(VCOS_TLS_KEY_T tls) {
10470 + VCOS_TLS_THREAD_T *tlsdata = _vcos_tls_thread_ptr_get();
10471 + vcos_assert(tlsdata); /* Fires if this thread has not been registered */
10472 + if (tls<VCOS_TLS_MAX_SLOTS)
10473 + {
10474 + return tlsdata->slots[tls];
10475 + }
10476 + else
10477 + {
10478 + vcos_assert(0);
10479 + return NULL;
10480 + }
10481 +}
10482 +
10483 +VCOS_INLINE_IMPL
10484 +VCOS_STATUS_T vcos_tls_create(VCOS_TLS_KEY_T *key) {
10485 + return vcos_generic_tls_create(key);
10486 +}
10487 +
10488 +VCOS_INLINE_IMPL
10489 +void vcos_tls_delete(VCOS_TLS_KEY_T tls) {
10490 + vcos_generic_tls_delete(tls);
10491 +}
10492 +
10493 +#undef VCOS_ASSERT_LOGGING_DISABLE
10494 +#define VCOS_ASSERT_LOGGING_DISABLE 0
10495 +
10496 +#endif /* VCOS_INLINE_BODIES */
10497 +
10498 +#ifdef __cplusplus
10499 +}
10500 +#endif
10501 +
10502 +#endif
10503 +
10504 +
10505 --- /dev/null
10506 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_joinable_thread_from_plain.h
10507 @@ -0,0 +1,202 @@
10508 +/*=============================================================================
10509 +Copyright (c) 2009 Broadcom Europe Limited.
10510 +All rights reserved.
10511 +
10512 +Module : vcos
10513 +
10514 +FILE DESCRIPTION
10515 +VideoCore OS Abstraction Layer - implementation: joinable thread from plain
10516 +=============================================================================*/
10517 +
10518 +/** \file
10519 + *
10520 + * Header file for platforms creating the joinable thread from a lowlevel
10521 + * thread.
10522 + *
10523 + * In addition to the actual thread, the following are also created:
10524 + *
10525 + * - a semaphore to wait on when joining the thread
10526 + * - a semaphore to support counted suspend/resume (used by event group)
10527 + * - a per-thread timer (used by event group, but could be removed)
10528 + */
10529 +
10530 +#ifndef VCOS_JOINABLE_THREAD_FROM_PLAIN_H
10531 +#define VCOS_JOINABLE_THREAD_FROM_PLAIN_H
10532 +
10533 +#ifdef __cplusplus
10534 +extern "C" {
10535 +#endif
10536 +
10537 +#include "interface/vcos/vcos_semaphore.h"
10538 +#include "interface/vcos/vcos_lowlevel_thread.h"
10539 +#include "interface/vcos/vcos_timer.h"
10540 +
10541 +#ifdef VCOS_WANT_TLS_EMULATION
10542 +#include "interface/vcos/generic/vcos_generic_tls.h"
10543 +#endif
10544 +
10545 +#define VCOS_THREAD_MAGIC 0x56436a74
10546 +
10547 +#define VCOS_THREAD_VALID(t) (t->magic == VCOS_THREAD_MAGIC)
10548 +#define VCOS_HAVE_THREAD_AT_EXIT 1
10549 +
10550 +/** Thread attribute structure. Clients should not manipulate this directly, but
10551 + * should instead use the provided functions.
10552 + */
10553 +typedef struct VCOS_THREAD_ATTR_T
10554 +{
10555 + void *ta_stackaddr;
10556 + VCOS_UNSIGNED ta_stacksz;
10557 + VCOS_UNSIGNED ta_priority;
10558 + VCOS_UNSIGNED ta_affinity;
10559 + VCOS_UNSIGNED ta_timeslice;
10560 + VCOS_UNSIGNED legacy;
10561 + VCOS_UNSIGNED ta_autostart;
10562 +} VCOS_THREAD_ATTR_T;
10563 +
10564 +/** Each thread gets a timer, which is for internal VCOS use.
10565 + */
10566 +typedef struct _VCOS_THREAD_TIMER_T
10567 +{
10568 + VCOS_TIMER_T timer;
10569 + void (*pfn)(void *);
10570 + void *cxt;
10571 +} _VCOS_THREAD_TIMER_T;
10572 +
10573 +typedef void (*VCOS_THREAD_EXIT_HANDLER_T)(void *);
10574 +/** Called at thread exit.
10575 + */
10576 +typedef struct VCOS_THREAD_EXIT_T
10577 +{
10578 + VCOS_THREAD_EXIT_HANDLER_T pfn;
10579 + void *cxt;
10580 +} VCOS_THREAD_EXIT_T;
10581 +#define VCOS_MAX_EXIT_HANDLERS 8
10582 +
10583 +/* The name field isn't used for anything, so we can just copy the
10584 + * the pointer. Nucleus makes its own copy.
10585 + */
10586 +typedef const char * VCOS_LLTHREAD_T_NAME;
10587 +#define _VCOS_LLTHREAD_NAME(dst,src) (dst)=(src)
10588 +
10589 +/*
10590 + * Simulated TLS support
10591 + */
10592 +
10593 +
10594 +/** Thread structure.
10595 + *
10596 + * \warning Do not access the members of this structure directly!
10597 + */
10598 +typedef struct VCOS_THREAD_T
10599 +{
10600 + VCOS_LLTHREAD_T thread; /**< The underlying thread */
10601 + char name[16]; /**< The name */
10602 + unsigned int magic; /**< For debug */
10603 + void *exit_data; /**< Exit data passed out in vcos_joinable_thread_exit() */
10604 + void *stack; /**< Stack, if not supplied by caller */
10605 + VCOS_SEMAPHORE_T wait; /**< Semaphore to wait on at join */
10606 + VCOS_SEMAPHORE_T suspend; /**< Semaphore to wait on for counted suspend */
10607 + int16_t joined; /**< Joined yet? For debug. */
10608 + VCOS_UNSIGNED legacy; /**< Use (argc,argv) for entry point arguments */
10609 + void *(*entry)(void*); /**< Entry point */
10610 + void *arg; /**< Argument passed to entry point */
10611 + void *(*term)(void*); /**< Termination function, used by reaper */
10612 + void *term_arg; /**< Argument passed to termination function */
10613 + _VCOS_THREAD_TIMER_T _timer; /**< Internal timer, mainly for event groups */
10614 +#ifdef VCOS_WANT_TLS_EMULATION
10615 + VCOS_TLS_THREAD_T _tls; /**< TLS data when native TLS not available, or NULL */
10616 +#endif
10617 + /** Array of functions to call at thread exit */
10618 + VCOS_THREAD_EXIT_T at_exit[VCOS_MAX_EXIT_HANDLERS];
10619 +
10620 + struct VCOS_THREAD_T *next; /**< For linked lists of threads */
10621 +} VCOS_THREAD_T;
10622 +
10623 +#if defined(VCOS_INLINE_BODIES)
10624 +
10625 +VCOS_INLINE_IMPL
10626 +void vcos_thread_attr_setstack(VCOS_THREAD_ATTR_T *attrs, void *addr, VCOS_UNSIGNED stacksz) {
10627 + attrs->ta_stackaddr = addr;
10628 + attrs->ta_stacksz = stacksz;
10629 +}
10630 +
10631 +VCOS_INLINE_IMPL
10632 +void vcos_thread_attr_setstacksize(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED stacksz) {
10633 + attrs->ta_stacksz = stacksz;
10634 +}
10635 +
10636 +VCOS_INLINE_IMPL
10637 +void vcos_thread_attr_setpriority(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED pri) {
10638 + attrs->ta_priority = pri;
10639 +}
10640 +
10641 +VCOS_INLINE_IMPL
10642 +void vcos_thread_attr_setaffinity(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED affinity) {
10643 + attrs->ta_affinity = affinity;
10644 +}
10645 +
10646 +VCOS_INLINE_IMPL
10647 +void vcos_thread_attr_settimeslice(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED ts) {
10648 + attrs->ta_timeslice = ts;
10649 +}
10650 +
10651 +VCOS_INLINE_IMPL
10652 +void _vcos_thread_attr_setlegacyapi(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED legacy) {
10653 + attrs->legacy = legacy;
10654 +}
10655 +
10656 +VCOS_INLINE_IMPL
10657 +void vcos_thread_attr_setautostart(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED autostart) {
10658 + attrs->ta_autostart = autostart;
10659 +}
10660 +
10661 +VCOS_INLINE_IMPL
10662 +VCOS_THREAD_T *vcos_thread_current(void) {
10663 + VCOS_THREAD_T *ret = (VCOS_THREAD_T*)vcos_llthread_current();
10664 + /*If we're called from a non-vcos thread, this assert will fail.
10665 + *XXX FIXME why is this commented out?
10666 + *vcos_assert(ret->magic == VCOS_THREAD_MAGIC);
10667 + */
10668 + return ret;
10669 +}
10670 +
10671 +VCOS_INLINE_IMPL
10672 +int vcos_thread_running(VCOS_THREAD_T *thread) {
10673 + return vcos_llthread_running(&thread->thread);
10674 +}
10675 +
10676 +VCOS_INLINE_IMPL
10677 +void vcos_thread_resume(VCOS_THREAD_T *thread) {
10678 + vcos_llthread_resume(&thread->thread);
10679 +}
10680 +
10681 +#endif /* VCOS_INLINE_BODIES */
10682 +
10683 +/**
10684 + * \brief Create a VCOS_THREAD_T for the current thread. This is so we can have
10685 + * VCOS_THREAD_Ts even for threads not originally created by VCOS (eg the
10686 + * thread that calls vcos_init)
10687 + */
10688 +extern VCOS_STATUS_T _vcos_thread_create_attach(VCOS_THREAD_T *thread,
10689 + const char *name);
10690 +
10691 +/**
10692 + * \brief Deletes the VCOS_THREAD_T, but does not wait for the underlying
10693 + * thread to exit. This will cleanup everything created by
10694 + * _vcos_thread_create_attach
10695 + */
10696 +extern void _vcos_thread_delete(VCOS_THREAD_T *thread);
10697 +
10698 +/** Register a function to be called when the current thread exits.
10699 + */
10700 +extern VCOS_STATUS_T vcos_thread_at_exit(void (*pfn)(void*), void *cxt);
10701 +
10702 +/** Deregister a previously registered at-exit function.
10703 + */
10704 +extern void vcos_thread_deregister_at_exit(void (*pfn)(void*), void *cxt);
10705 +
10706 +#ifdef __cplusplus
10707 +}
10708 +#endif
10709 +#endif /* VCOS_JOINABLE_THREAD_FROM_PLAIN_H */
10710 --- /dev/null
10711 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_latch_from_sem.h
10712 @@ -0,0 +1,48 @@
10713 +/*=============================================================================
10714 +Copyright (c) 2009 Broadcom Europe Limited.
10715 +All rights reserved.
10716 +
10717 +Project : vcfw
10718 +Module : vcos
10719 +
10720 +FILE DESCRIPTION
10721 +VideoCore OS Abstraction Layer - Construct a latch from a semaphore
10722 +=============================================================================*/
10723 +
10724 +/** FIXME: rename to vcos_mutex_from_sem.c
10725 + */
10726 +
10727 +typedef struct VCOS_MUTEX_T {
10728 + VCOS_SEMAPHORE_T sem;
10729 + struct VCOS_THREAD_T *owner;
10730 +} VCOS_MUTEX_T;
10731 +
10732 +extern VCOS_STATUS_T vcos_generic_mutex_create(VCOS_MUTEX_T *latch, const char *name);
10733 +extern void vcos_generic_mutex_delete(VCOS_MUTEX_T *latch);
10734 +extern VCOS_STATUS_T vcos_generic_mutex_lock(VCOS_MUTEX_T *latch);
10735 +extern void vcos_generic_mutex_unlock(VCOS_MUTEX_T *latch);
10736 +
10737 +#if defined(VCOS_INLINE_BODIES)
10738 +
10739 +VCOS_INLINE_IMPL
10740 +VCOS_STATUS_T vcos_mutex_create(VCOS_MUTEX_T *latch, const char *name) {
10741 + return vcos_generic_mutex_create(latch,name);
10742 +}
10743 +
10744 +VCOS_INLINE_IMPL
10745 +void vcos_mutex_delete(VCOS_MUTEX_T *latch) {
10746 + vcos_generic_mutex_delete(latch);
10747 +}
10748 +
10749 +VCOS_INLINE_IMPL
10750 +VCOS_STATUS_T vcos_mutex_lock(VCOS_MUTEX_T *latch) {
10751 + return vcos_generic_mutex_lock(latch);
10752 +}
10753 +
10754 +VCOS_INLINE_IMPL
10755 +void vcos_mutex_unlock(VCOS_MUTEX_T *latch) {
10756 + vcos_generic_mutex_unlock(latch);
10757 +}
10758 +
10759 +#endif /* VCOS_INLINE_BODIES */
10760 +
10761 --- /dev/null
10762 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_logcat.c
10763 @@ -0,0 +1,549 @@
10764 +/*=============================================================================
10765 +Copyright (c) 2010 Broadcom Europe Limited.
10766 +All rights reserved.
10767 +
10768 +Project : vcfw
10769 +Module : vcos
10770 +
10771 +FILE DESCRIPTION
10772 +Categorized logging for VCOS - a generic implementation.
10773 +=============================================================================*/
10774 +
10775 +#include "interface/vcos/vcos.h"
10776 +#include "interface/vcos/vcos_ctype.h"
10777 +#include "interface/vcos/vcos_string.h"
10778 +
10779 +static VCOS_MUTEX_T lock;
10780 +static int warned_loglevel; /* only warn about invalid log level once */
10781 +static VCOS_VLOG_IMPL_FUNC_T vcos_vlog_impl_func = vcos_vlog_default_impl;
10782 +
10783 +#define VCOS_LOG_CATEGORY (&dflt_log_category)
10784 +static VCOS_LOG_CAT_T dflt_log_category;
10785 +VCOS_LOG_CAT_T *vcos_logging_categories = NULL;
10786 +static int inited;
10787 +
10788 +#if VCOS_HAVE_CMD
10789 +
10790 +/*
10791 + * For kernel or videocore purposes, we generally want the log command. For
10792 + * user-space apps, they might want to provide their own log command, so we
10793 + * don't include the built in on.
10794 + *
10795 + * So pthreads/vcos_platform.h defines VCOS_WANT_LOG_CMD to be 0. It is
10796 + * undefined elsewhere.
10797 + */
10798 +
10799 +# if !defined( VCOS_WANT_LOG_CMD )
10800 +# define VCOS_WANT_LOG_CMD 1
10801 +# endif
10802 +#else
10803 +# define VCOS_WANT_LOG_CMD 0
10804 +#endif
10805 +
10806 +#if VCOS_WANT_LOG_CMD
10807 +
10808 +/*****************************************************************************
10809 +*
10810 +* Does a vcos_assert(0), which is useful to test logging.
10811 +*
10812 +*****************************************************************************/
10813 +
10814 +VCOS_STATUS_T vcos_log_assert_cmd( VCOS_CMD_PARAM_T *param )
10815 +{
10816 + (void)param;
10817 +
10818 +#if defined( NDEBUG ) && !defined( VCOS_RELEASE_ASSERTS )
10819 + vcos_log_error( "vcos_asserts have been compiled out" );
10820 + vcos_cmd_printf( param, "vcos_asserts have been compiled out - did a vcos_log_error instead\n" );
10821 +#else
10822 + vcos_assert(0);
10823 + vcos_cmd_printf( param, "Executed vcos_assert(0)\n" );
10824 +#endif
10825 +
10826 + return VCOS_SUCCESS;
10827 +}
10828 +
10829 +/*****************************************************************************
10830 +*
10831 +* Sets a vcos logging level
10832 +*
10833 +*****************************************************************************/
10834 +
10835 +VCOS_STATUS_T vcos_log_set_cmd( VCOS_CMD_PARAM_T *param )
10836 +{
10837 + VCOS_LOG_CAT_T *cat;
10838 + char *name;
10839 + char *levelStr;
10840 + VCOS_LOG_LEVEL_T level;
10841 + VCOS_STATUS_T status;
10842 +
10843 + if ( param->argc != 3 )
10844 + {
10845 + vcos_cmd_usage( param );
10846 + return VCOS_EINVAL;
10847 + }
10848 +
10849 + name = param->argv[1];
10850 + levelStr = param->argv[2];
10851 +
10852 + if ( vcos_string_to_log_level( levelStr, &level ) != VCOS_SUCCESS )
10853 + {
10854 + vcos_cmd_printf( param, "Unrecognized logging level: '%s'\n", levelStr );
10855 + return VCOS_EINVAL;
10856 + }
10857 +
10858 + vcos_mutex_lock(&lock);
10859 +
10860 + status = VCOS_SUCCESS;
10861 + for ( cat = vcos_logging_categories; cat != NULL; cat = cat->next )
10862 + {
10863 + if ( vcos_strcmp( name, cat->name ) == 0 )
10864 + {
10865 + cat->level = level;
10866 + vcos_cmd_printf( param, "Category %s level set to %s\n", name, levelStr );
10867 + break;
10868 + }
10869 + }
10870 + if ( cat == NULL )
10871 + {
10872 + vcos_cmd_printf( param, "Unrecognized category: '%s'\n", name );
10873 + status = VCOS_ENOENT;
10874 + }
10875 +
10876 + vcos_mutex_unlock(&lock);
10877 +
10878 + return status;
10879 +}
10880 +
10881 +/*****************************************************************************
10882 +*
10883 +* Prints out the current settings for a given category (or all cvategories)
10884 +*
10885 +*****************************************************************************/
10886 +
10887 +VCOS_STATUS_T vcos_log_status_cmd( VCOS_CMD_PARAM_T *param )
10888 +{
10889 + VCOS_LOG_CAT_T *cat;
10890 + VCOS_STATUS_T status;
10891 +
10892 + vcos_mutex_lock(&lock);
10893 +
10894 + if ( param->argc == 1)
10895 + {
10896 + int nw;
10897 + int nameWidth = 0;
10898 +
10899 + /* Print information about all of the categories. */
10900 +
10901 + for ( cat = vcos_logging_categories; cat != NULL; cat = cat->next )
10902 + {
10903 + nw = (int)strlen( cat->name );
10904 +
10905 + if ( nw > nameWidth )
10906 + {
10907 + nameWidth = nw;
10908 + }
10909 + }
10910 +
10911 + for ( cat = vcos_logging_categories; cat != NULL; cat = cat->next )
10912 + {
10913 + vcos_cmd_printf( param, "%-*s - %s\n", nameWidth, cat->name, vcos_log_level_to_string( cat->level ));
10914 + }
10915 + }
10916 + else
10917 + {
10918 + /* Print information about a particular category */
10919 +
10920 + for ( cat = vcos_logging_categories; cat != NULL; cat = cat->next )
10921 + {
10922 + if ( vcos_strcmp( cat->name, param->argv[1] ) == 0 )
10923 + {
10924 + vcos_cmd_printf( param, "%s - %s\n", cat->name, vcos_log_level_to_string( cat->level ));
10925 + break;
10926 + }
10927 + }
10928 + if ( cat == NULL )
10929 + {
10930 + vcos_cmd_printf( param, "Unrecognized logging category: '%s'\n", param->argv[1] );
10931 + status = VCOS_ENOENT;
10932 + goto out;
10933 + }
10934 + }
10935 +
10936 + status = VCOS_SUCCESS;
10937 +out:
10938 + vcos_mutex_unlock(&lock);
10939 +
10940 + return status;
10941 +}
10942 +
10943 +/*****************************************************************************
10944 +*
10945 +* Prints out the current settings for a given category (or all cvategories)
10946 +*
10947 +*****************************************************************************/
10948 +
10949 +VCOS_STATUS_T vcos_log_test_cmd( VCOS_CMD_PARAM_T *param )
10950 +{
10951 + if ( param->argc == 1 )
10952 + {
10953 + static int seq_num = 100;
10954 +
10955 + /* No additional arguments - generate a message with an incrementing number */
10956 +
10957 + vcos_log_error( "Test message %d", seq_num );
10958 +
10959 + seq_num++;
10960 + vcos_cmd_printf( param, "Logged 'Test message %d'\n", seq_num );
10961 + }
10962 + else
10963 + {
10964 + int arg_idx;
10965 +
10966 + /* Arguments supplied - log these */
10967 +
10968 + for ( arg_idx = 0; arg_idx < param->argc; arg_idx++ )
10969 + {
10970 + vcos_log_error( "argv[%d] = '%s'", arg_idx, param->argv[arg_idx] );
10971 + }
10972 + vcos_cmd_printf( param, "Logged %d line(s) of test data\n", param->argc );
10973 + }
10974 + return VCOS_SUCCESS;
10975 +}
10976 +
10977 +/*****************************************************************************
10978 +*
10979 +* Internal commands
10980 +*
10981 +*****************************************************************************/
10982 +
10983 +static VCOS_CMD_T log_cmd_entry[] =
10984 +{
10985 + { "assert", "", vcos_log_assert_cmd, NULL, "Does a vcos_assert(0) to test logging" },
10986 + { "set", "category level", vcos_log_set_cmd, NULL, "Sets the vcos logging level for a category" },
10987 + { "status", "[category]", vcos_log_status_cmd, NULL, "Prints the vcos log status for a (or all) categories" },
10988 + { "test", "[arbitrary text]", vcos_log_test_cmd, NULL, "Does a vcos_log to test logging" },
10989 +
10990 + { NULL, NULL, NULL, NULL, NULL }
10991 +};
10992 +
10993 +static VCOS_CMD_T cmd_log =
10994 + { "log", "command [args]", NULL, log_cmd_entry, "Commands related to vcos logging" };
10995 +
10996 +#endif
10997 +
10998 +void vcos_logging_init(void)
10999 +{
11000 + if (inited)
11001 + {
11002 + /* FIXME: should print a warning or something here */
11003 + return;
11004 + }
11005 + vcos_mutex_create(&lock, "vcos_log");
11006 +
11007 + vcos_log_platform_init();
11008 +
11009 + vcos_log_register("default", &dflt_log_category);
11010 +
11011 +#if VCOS_WANT_LOG_CMD
11012 + vcos_cmd_register( &cmd_log );
11013 +#endif
11014 +
11015 + vcos_assert(!inited);
11016 + inited = 1;
11017 +}
11018 +
11019 +/** Read an alphanumeric token, returning True if we succeeded.
11020 + */
11021 +
11022 +static int read_tok(char *tok, size_t toklen, const char **pstr, char sep)
11023 +{
11024 + const char *str = *pstr;
11025 + size_t n = 0;
11026 + char ch;
11027 +
11028 + /* skip past any whitespace */
11029 + while (str[0] && isspace((int)(str[0])))
11030 + str++;
11031 +
11032 + while ((ch = *str) != '\0' &&
11033 + ch != sep &&
11034 + (isalnum((int)ch) || (ch == '_')) &&
11035 + n != toklen-1)
11036 + {
11037 + tok[n++] = ch;
11038 + str++;
11039 + }
11040 +
11041 + /* did it work out? */
11042 + if (ch == '\0' || ch == sep)
11043 + {
11044 + if (ch) str++; /* move to next token if not at end */
11045 + /* yes */
11046 + tok[n] = '\0';
11047 + *pstr = str;
11048 + return 1;
11049 + }
11050 + else
11051 + {
11052 + /* no */
11053 + return 0;
11054 + }
11055 +}
11056 +
11057 +const char *vcos_log_level_to_string( VCOS_LOG_LEVEL_T level )
11058 +{
11059 + switch (level)
11060 + {
11061 + case VCOS_LOG_UNINITIALIZED: return "uninit";
11062 + case VCOS_LOG_NEVER: return "never";
11063 + case VCOS_LOG_ERROR: return "error";
11064 + case VCOS_LOG_WARN: return "warn";
11065 + case VCOS_LOG_INFO: return "info";
11066 + case VCOS_LOG_TRACE: return "trace";
11067 + }
11068 + return "???";
11069 +}
11070 +
11071 +VCOS_STATUS_T vcos_string_to_log_level( const char *str, VCOS_LOG_LEVEL_T *level )
11072 +{
11073 + if (strcmp(str,"error") == 0)
11074 + *level = VCOS_LOG_ERROR;
11075 + else if (strcmp(str,"never") == 0)
11076 + *level = VCOS_LOG_NEVER;
11077 + else if (strcmp(str,"warn") == 0)
11078 + *level = VCOS_LOG_WARN;
11079 + else if (strcmp(str,"warning") == 0)
11080 + *level = VCOS_LOG_WARN;
11081 + else if (strcmp(str,"info") == 0)
11082 + *level = VCOS_LOG_INFO;
11083 + else if (strcmp(str,"trace") == 0)
11084 + *level = VCOS_LOG_TRACE;
11085 + else
11086 + return VCOS_EINVAL;
11087 +
11088 + return VCOS_SUCCESS;
11089 +}
11090 +
11091 +static int read_level(VCOS_LOG_LEVEL_T *level, const char **pstr, char sep)
11092 +{
11093 + char buf[16];
11094 + int ret = 1;
11095 + if (read_tok(buf,sizeof(buf),pstr,sep))
11096 + {
11097 + if (vcos_string_to_log_level(buf,level) != VCOS_SUCCESS)
11098 + {
11099 + vcos_log("Invalid trace level '%s'\n", buf);
11100 + ret = 0;
11101 + }
11102 + }
11103 + else
11104 + {
11105 + ret = 0;
11106 + }
11107 + return ret;
11108 +}
11109 +
11110 +void vcos_log_register(const char *name, VCOS_LOG_CAT_T *category)
11111 +{
11112 + const char *env;
11113 + VCOS_LOG_CAT_T *i;
11114 +
11115 + category->name = name;
11116 + if ( category->level == VCOS_LOG_UNINITIALIZED )
11117 + {
11118 + category->level = VCOS_LOG_ERROR;
11119 + }
11120 + category->flags.want_prefix = (category != &dflt_log_category );
11121 +
11122 + vcos_mutex_lock(&lock);
11123 +
11124 + /* is it already registered? */
11125 + for (i = vcos_logging_categories; i ; i = i->next )
11126 + {
11127 + if (i == category)
11128 + {
11129 + i->refcount++;
11130 + break;
11131 + }
11132 + }
11133 +
11134 + if (!i)
11135 + {
11136 + /* not yet registered */
11137 + category->next = vcos_logging_categories;
11138 + vcos_logging_categories = category;
11139 + category->refcount++;
11140 +
11141 + vcos_log_platform_register(category);
11142 + }
11143 +
11144 + vcos_mutex_unlock(&lock);
11145 +
11146 + /* Check to see if this log level has been enabled. Look for
11147 + * (<category:level>,)*
11148 + *
11149 + * VC_LOGLEVEL=ilcs:info,vchiq:warn
11150 + */
11151 +
11152 + env = _VCOS_LOG_LEVEL();
11153 + if (env)
11154 + {
11155 + do
11156 + {
11157 + char env_name[64];
11158 + VCOS_LOG_LEVEL_T level;
11159 + if (read_tok(env_name, sizeof(env_name), &env, ':') &&
11160 + read_level(&level, &env, ','))
11161 + {
11162 + if (strcmp(env_name, name) == 0)
11163 + {
11164 + category->level = level;
11165 + break;
11166 + }
11167 + }
11168 + else
11169 + {
11170 + if (!warned_loglevel)
11171 + {
11172 + vcos_log("VC_LOGLEVEL format invalid at %s\n", env);
11173 + warned_loglevel = 1;
11174 + }
11175 + return;
11176 + }
11177 + } while (env[0] != '\0');
11178 + }
11179 +
11180 + vcos_log_info( "Registered log category '%s' with level %s",
11181 + category->name,
11182 + vcos_log_level_to_string( category->level ));
11183 +}
11184 +
11185 +void vcos_log_unregister(VCOS_LOG_CAT_T *category)
11186 +{
11187 + VCOS_LOG_CAT_T **pcat;
11188 + vcos_mutex_lock(&lock);
11189 + category->refcount--;
11190 + if (category->refcount == 0)
11191 + {
11192 + pcat = &vcos_logging_categories;
11193 + while (*pcat != category)
11194 + {
11195 + if (!*pcat)
11196 + break; /* possibly deregistered twice? */
11197 + if ((*pcat)->next == NULL)
11198 + {
11199 + vcos_assert(0); /* already removed! */
11200 + vcos_mutex_unlock(&lock);
11201 + return;
11202 + }
11203 + pcat = &(*pcat)->next;
11204 + }
11205 + if (*pcat)
11206 + *pcat = category->next;
11207 +
11208 + vcos_log_platform_unregister(category);
11209 + }
11210 + vcos_mutex_unlock(&lock);
11211 +}
11212 +
11213 +VCOSPRE_ const VCOS_LOG_CAT_T * VCOSPOST_ vcos_log_get_default_category(void)
11214 +{
11215 + return &dflt_log_category;
11216 +}
11217 +
11218 +void vcos_set_log_options(const char *opt)
11219 +{
11220 + (void)opt;
11221 +}
11222 +
11223 +void vcos_log_dump_mem_impl( const VCOS_LOG_CAT_T *cat,
11224 + const char *label,
11225 + uint32_t addr,
11226 + const void *voidMem,
11227 + size_t numBytes )
11228 +{
11229 + const uint8_t *mem = (const uint8_t *)voidMem;
11230 + size_t offset;
11231 + char lineBuf[ 100 ];
11232 + char *s;
11233 +
11234 + while ( numBytes > 0 )
11235 + {
11236 + s = lineBuf;
11237 +
11238 + for ( offset = 0; offset < 16; offset++ )
11239 + {
11240 + if ( offset < numBytes )
11241 + {
11242 + s += vcos_snprintf( s, 4, "%02x ", mem[ offset ]);
11243 + }
11244 + else
11245 + {
11246 + s += vcos_snprintf( s, 4, " " );
11247 + }
11248 + }
11249 +
11250 + for ( offset = 0; offset < 16; offset++ )
11251 + {
11252 + if ( offset < numBytes )
11253 + {
11254 + uint8_t ch = mem[ offset ];
11255 +
11256 + if (( ch < ' ' ) || ( ch > '~' ))
11257 + {
11258 + ch = '.';
11259 + }
11260 + *s++ = (char)ch;
11261 + }
11262 + }
11263 + *s++ = '\0';
11264 +
11265 + if (( label != NULL ) && ( *label != '\0' ))
11266 + {
11267 + vcos_log_impl( cat, VCOS_LOG_INFO, "%s: %08x: %s", label, addr, lineBuf );
11268 + }
11269 + else
11270 + {
11271 + vcos_log_impl( cat, VCOS_LOG_INFO, "%08x: %s", addr, lineBuf );
11272 + }
11273 +
11274 + addr += 16;
11275 + mem += 16;
11276 + if ( numBytes > 16 )
11277 + {
11278 + numBytes -= 16;
11279 + }
11280 + else
11281 + {
11282 + numBytes = 0;
11283 + }
11284 + }
11285 +
11286 +}
11287 +
11288 +void vcos_log_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, ...)
11289 +{
11290 + va_list ap;
11291 + va_start(ap,fmt);
11292 + vcos_vlog_impl( cat, _level, fmt, ap );
11293 + va_end(ap);
11294 +}
11295 +
11296 +void vcos_vlog_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, va_list args)
11297 +{
11298 + vcos_vlog_impl_func( cat, _level, fmt, args );
11299 +}
11300 +
11301 +void vcos_set_vlog_impl( VCOS_VLOG_IMPL_FUNC_T vlog_impl_func )
11302 +{
11303 + if ( vlog_impl_func == NULL )
11304 + {
11305 + vcos_vlog_impl_func = vcos_vlog_default_impl;
11306 + }
11307 + else
11308 + {
11309 + vcos_vlog_impl_func = vlog_impl_func;
11310 + }
11311 +}
11312 +
11313 --- /dev/null
11314 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_mem_from_malloc.c
11315 @@ -0,0 +1,73 @@
11316 +/*=============================================================================
11317 +Copyright (c) 2009 Broadcom Europe Limited.
11318 +All rights reserved.
11319 +
11320 +Project : vcfw
11321 +Module : vcos
11322 +
11323 +FILE DESCRIPTION
11324 +VideoCore OS Abstraction Layer - memory alloc implementation
11325 +=============================================================================*/
11326 +
11327 +#include "interface/vcos/vcos.h"
11328 +
11329 +#ifndef _vcos_platform_malloc
11330 +#include <stdlib.h>
11331 +#define _vcos_platform_malloc malloc
11332 +#define _vcos_platform_free free
11333 +#endif
11334 +
11335 +typedef struct malloc_header_s {
11336 + uint32_t guardword;
11337 + uint32_t size;
11338 + const char *description;
11339 + void *ptr;
11340 +} MALLOC_HEADER_T;
11341 +
11342 +
11343 +#define MIN_ALIGN sizeof(MALLOC_HEADER_T)
11344 +
11345 +#define GUARDWORDHEAP 0xa55a5aa5
11346 +
11347 +void *vcos_generic_mem_alloc_aligned(VCOS_UNSIGNED size, VCOS_UNSIGNED align, const char *desc)
11348 +{
11349 + int local_align = align == 0 ? 1 : align;
11350 + int required_size = size + local_align + sizeof(MALLOC_HEADER_T);
11351 + void *ptr = _vcos_platform_malloc(required_size);
11352 + void *ret = (void *)VCOS_ALIGN_UP(((char *)ptr)+sizeof(MALLOC_HEADER_T), local_align);
11353 + MALLOC_HEADER_T *h = ((MALLOC_HEADER_T *)ret)-1;
11354 +
11355 + h->size = size;
11356 + h->description = desc;
11357 + h->guardword = GUARDWORDHEAP;
11358 + h->ptr = ptr;
11359 +
11360 + return ret;
11361 +}
11362 +
11363 +void *vcos_generic_mem_alloc(VCOS_UNSIGNED size, const char *desc)
11364 +{
11365 + return vcos_generic_mem_alloc_aligned(size,MIN_ALIGN,desc);
11366 +}
11367 +
11368 +void *vcos_generic_mem_calloc(VCOS_UNSIGNED count, VCOS_UNSIGNED sz, const char *desc)
11369 +{
11370 + uint32_t size = count*sz;
11371 + void *ptr = vcos_generic_mem_alloc_aligned(size,MIN_ALIGN,desc);
11372 + if (ptr)
11373 + {
11374 + memset(ptr, 0, size);
11375 + }
11376 + return ptr;
11377 +}
11378 +
11379 +void vcos_generic_mem_free(void *ptr)
11380 +{
11381 + MALLOC_HEADER_T *h;
11382 + if (! ptr) return;
11383 +
11384 + h = ((MALLOC_HEADER_T *)ptr)-1;
11385 + vcos_assert(h->guardword == GUARDWORDHEAP);
11386 + _vcos_platform_free(h->ptr);
11387 +}
11388 +
11389 --- /dev/null
11390 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_mem_from_malloc.h
11391 @@ -0,0 +1,54 @@
11392 +/*=============================================================================
11393 +Copyright (c) 2009 Broadcom Europe Limited.
11394 +All rights reserved.
11395 +
11396 +Project : VMCS Host Apps
11397 +Module : Framework - VMCS
11398 +
11399 +FILE DESCRIPTION
11400 +Create the vcos_malloc API from the regular system malloc/free
11401 +=============================================================================*/
11402 +
11403 +/**
11404 + * \file
11405 + *
11406 + * Create the vcos malloc API from a regular system malloc/free library.
11407 + *
11408 + * The API lets callers specify an alignment.
11409 + *
11410 + * Under VideoCore this is not needed, as we can simply use the rtos_malloc routines.
11411 + * But on host platforms that won't be the case.
11412 + *
11413 + */
11414 +
11415 +VCOSPRE_ void * VCOSPOST_ vcos_generic_mem_alloc(VCOS_UNSIGNED sz, const char *desc);
11416 +VCOSPRE_ void * VCOSPOST_ vcos_generic_mem_calloc(VCOS_UNSIGNED count, VCOS_UNSIGNED sz, const char *descr);
11417 +VCOSPRE_ void VCOSPOST_ vcos_generic_mem_free(void *ptr);
11418 +VCOSPRE_ void * VCOSPOST_ vcos_generic_mem_alloc_aligned(VCOS_UNSIGNED sz, VCOS_UNSIGNED align, const char *desc);
11419 +
11420 +#ifdef VCOS_INLINE_BODIES
11421 +
11422 +VCOS_INLINE_IMPL
11423 +void *vcos_malloc(VCOS_UNSIGNED size, const char *description) {
11424 + return vcos_generic_mem_alloc(size, description);
11425 +}
11426 +
11427 +VCOS_INLINE_IMPL
11428 +void *vcos_calloc(VCOS_UNSIGNED num, VCOS_UNSIGNED size, const char *description) {
11429 + return vcos_generic_mem_calloc(num, size, description);
11430 +}
11431 +
11432 +VCOS_INLINE_IMPL
11433 +void vcos_free(void *ptr) {
11434 + vcos_generic_mem_free(ptr);
11435 +}
11436 +
11437 +VCOS_INLINE_IMPL
11438 +void * vcos_malloc_aligned(VCOS_UNSIGNED size, VCOS_UNSIGNED align, const char *description) {
11439 + return vcos_generic_mem_alloc_aligned(size, align, description);
11440 +}
11441 +
11442 +
11443 +#endif /* VCOS_INLINE_BODIES */
11444 +
11445 +
11446 --- /dev/null
11447 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_mutexes_are_reentrant.h
11448 @@ -0,0 +1,68 @@
11449 +/*=============================================================================
11450 +Copyright (c) 2009 Broadcom Europe Limited.
11451 +All rights reserved.
11452 +
11453 +Project : vcfw
11454 +Module : chip driver
11455 +
11456 +FILE DESCRIPTION
11457 +VideoCore OS Abstraction Layer - reentrant mutexes mapped directly to regular ones
11458 +=============================================================================*/
11459 +
11460 +#ifndef VCOS_GENERIC_REENTRANT_MUTEX_H
11461 +#define VCOS_GENERIC_REENTRANT_MUTEX_H
11462 +
11463 +#ifdef __cplusplus
11464 +extern "C" {
11465 +#endif
11466 +
11467 +#include "interface/vcos/vcos_types.h"
11468 +#include "interface/vcos/vcos_mutex.h"
11469 +
11470 +/**
11471 + * \file
11472 + *
11473 + * Reentrant Mutexes directly using the native re-entrant mutex.
11474 + *
11475 + */
11476 +
11477 +typedef VCOS_MUTEX_T VCOS_REENTRANT_MUTEX_T;
11478 +
11479 +/* Inline forwarding functions */
11480 +
11481 +#if defined(VCOS_INLINE_BODIES)
11482 +
11483 +VCOS_INLINE_IMPL
11484 +VCOS_STATUS_T vcos_reentrant_mutex_create(VCOS_REENTRANT_MUTEX_T *m, const char *name) {
11485 + return vcos_mutex_create(m,name);
11486 +}
11487 +
11488 +VCOS_INLINE_IMPL
11489 +void vcos_reentrant_mutex_delete(VCOS_REENTRANT_MUTEX_T *m) {
11490 + vcos_mutex_delete(m);
11491 +}
11492 +
11493 +VCOS_INLINE_IMPL
11494 +void vcos_reentrant_mutex_lock(VCOS_REENTRANT_MUTEX_T *m) {
11495 + vcos_mutex_lock(m);
11496 +}
11497 +
11498 +VCOS_INLINE_IMPL
11499 +void vcos_reentrant_mutex_unlock(VCOS_REENTRANT_MUTEX_T *m) {
11500 + vcos_mutex_unlock(m);
11501 +}
11502 +
11503 +VCOS_INLINE_IMPL
11504 +int vcos_reentrant_mutex_is_locked(VCOS_REENTRANT_MUTEX_T *m) {
11505 + return vcos_mutex_is_locked(m);
11506 +}
11507 +
11508 +#endif
11509 +
11510 +#ifdef __cplusplus
11511 +}
11512 +#endif
11513 +#endif
11514 +
11515 +
11516 +
11517 --- /dev/null
11518 +++ b/drivers/misc/vc04_services/interface/vcos/generic/vcos_thread_reaper.h
11519 @@ -0,0 +1,35 @@
11520 +/*=============================================================================
11521 +Copyright (c) 2010 Broadcom Europe Limited.
11522 +All rights reserved.
11523 +
11524 +Project : vcfw
11525 +Module : vcos
11526 +
11527 +FILE DESCRIPTION
11528 +VideoCore OS Abstraction Layer - thread reaping
11529 +=============================================================================*/
11530 +
11531 +#ifndef VCOS_THREAD_REAPER_H
11532 +#define VCOS_THREAD_REAPER_H
11533 +
11534 +#define VCOS_HAVE_THREAD_REAPER
11535 +
11536 +/** Initialise the thread reaper.
11537 + */
11538 +VCOS_STATUS_T vcos_thread_reaper_init(void);
11539 +
11540 +/** Reap a thread. Arranges for the thread to be automatically
11541 + * joined.
11542 + *
11543 + * @sa vcos_thread_join().
11544 + *
11545 + * @param thread the thread to terminate
11546 + * @param on_terminated called after the thread has exited
11547 + * @param cxt pass back to the callback
11548 + *
11549 + */
11550 +void vcos_thread_reap(VCOS_THREAD_T *thread, void (*on_terminated)(void*), void *cxt);
11551 +
11552 +#endif
11553 +
11554 +
11555 --- /dev/null
11556 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/stdint.h
11557 @@ -0,0 +1,17 @@
11558 +/*=============================================================================
11559 +Copyright (c) 2010 Broadcom Europe Limited.
11560 +All rights reserved.
11561 +
11562 +FILE DESCRIPTION
11563 +VideoCore OS fAbstraction Layer - stdint.h C standard header
11564 +=============================================================================*/
11565 +
11566 +#ifndef _VCOS_PLATFORM_LINUX_STDINT_H
11567 +#define _VCOS_PLATFORM_LINUX_STDINT_H
11568 +
11569 +/* The Linux kernel does not have a <stdint.h> so we have to provide one of
11570 + our own. */
11571 +
11572 +#include <linux/types.h> /* includes integer types */
11573 +
11574 +#endif /* _VCOS_PLATFORM_LINUX_STDINT_H */
11575 --- /dev/null
11576 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel.c
11577 @@ -0,0 +1,616 @@
11578 +/*=============================================================================
11579 +Copyright (c) 2009 Broadcom Europe Limited.
11580 +All rights reserved.
11581 +
11582 +Project : vcfw
11583 +Module : vcos
11584 +
11585 +FILE DESCRIPTION
11586 +VideoCore OS Abstraction Layer - pthreads types
11587 +=============================================================================*/
11588 +
11589 +#define VCOS_INLINE_BODIES
11590 +#include <linux/module.h>
11591 +#include <linux/kernel.h>
11592 +#include <linux/time.h>
11593 +#include <linux/pid.h>
11594 +#include <linux/mm.h>
11595 +#include <linux/version.h>
11596 +
11597 +#if defined( CONFIG_BCM_KNLLOG_SUPPORT )
11598 +#include <linux/broadcom/knllog.h>
11599 +#endif
11600 +#include "interface/vcos/vcos.h"
11601 +#ifdef HAVE_VCOS_VERSION
11602 +#include "interface/vcos/vcos_build_info.h"
11603 +#endif
11604 +
11605 +VCOS_CFG_ENTRY_T vcos_cfg_dir;
11606 +VCOS_CFG_ENTRY_T vcos_logging_cfg_dir;
11607 +VCOS_CFG_ENTRY_T vcos_version_cfg;
11608 +
11609 +#ifndef VCOS_DEFAULT_STACK_SIZE
11610 +#define VCOS_DEFAULT_STACK_SIZE 4096
11611 +#endif
11612 +
11613 +static VCOS_THREAD_ATTR_T default_attrs = {
11614 + 0,
11615 + VCOS_DEFAULT_STACK_SIZE,
11616 +};
11617 +
11618 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
11619 +static DEFINE_SEMAPHORE(lock);
11620 +#else
11621 +static DECLARE_MUTEX(lock);
11622 +#endif
11623 +
11624 +typedef void (*LEGACY_ENTRY_FN_T)(int, void *);
11625 +
11626 +/** Wrapper function around the real thread function. Posts the semaphore
11627 + * when completed.
11628 + */
11629 +static int vcos_thread_wrapper(void *arg)
11630 +{
11631 + void *ret;
11632 + VCOS_THREAD_T *thread = arg;
11633 +
11634 + vcos_assert(thread->magic == VCOS_THREAD_MAGIC);
11635 +
11636 + thread->thread.thread = current;
11637 +
11638 + vcos_add_thread(thread);
11639 +
11640 +#ifdef VCOS_WANT_TLS_EMULATION
11641 + vcos_tls_thread_register(&thread->_tls);
11642 +#endif
11643 +
11644 + if (thread->legacy)
11645 + {
11646 + LEGACY_ENTRY_FN_T fn = (LEGACY_ENTRY_FN_T)thread->entry;
11647 + fn(0,thread->arg);
11648 + ret = 0;
11649 + }
11650 + else
11651 + {
11652 + ret = thread->entry(thread->arg);
11653 + }
11654 +
11655 + thread->exit_data = ret;
11656 +
11657 + vcos_remove_thread(current);
11658 +
11659 + /* For join and cleanup */
11660 + vcos_semaphore_post(&thread->wait);
11661 +
11662 + return 0;
11663 +}
11664 +
11665 +VCOS_STATUS_T vcos_thread_create(VCOS_THREAD_T *thread,
11666 + const char *name,
11667 + VCOS_THREAD_ATTR_T *attrs,
11668 + VCOS_THREAD_ENTRY_FN_T entry,
11669 + void *arg)
11670 +{
11671 + VCOS_STATUS_T st;
11672 + struct task_struct *kthread;
11673 +
11674 + memset(thread, 0, sizeof(*thread));
11675 + thread->magic = VCOS_THREAD_MAGIC;
11676 + strlcpy( thread->name, name, sizeof( thread->name ));
11677 + thread->legacy = attrs ? attrs->legacy : 0;
11678 + thread->entry = entry;
11679 + thread->arg = arg;
11680 +
11681 + if (!name)
11682 + {
11683 + vcos_assert(0);
11684 + return VCOS_EINVAL;
11685 + }
11686 +
11687 + st = vcos_semaphore_create(&thread->wait, NULL, 0);
11688 + if (st != VCOS_SUCCESS)
11689 + {
11690 + return st;
11691 + }
11692 +
11693 + st = vcos_semaphore_create(&thread->suspend, NULL, 0);
11694 + if (st != VCOS_SUCCESS)
11695 + {
11696 + return st;
11697 + }
11698 +
11699 + /*required for event groups */
11700 + vcos_timer_create(&thread->_timer.timer, thread->name, NULL, NULL);
11701 +
11702 + kthread = kthread_create((int (*)(void *))vcos_thread_wrapper, (void*)thread, name);
11703 + vcos_assert(kthread != NULL);
11704 + set_user_nice(kthread, attrs->ta_priority);
11705 + thread->thread.thread = kthread;
11706 + wake_up_process(kthread);
11707 + return VCOS_SUCCESS;
11708 +}
11709 +
11710 +void vcos_thread_join(VCOS_THREAD_T *thread,
11711 + void **pData)
11712 +{
11713 + vcos_assert(thread);
11714 + vcos_assert(thread->magic == VCOS_THREAD_MAGIC);
11715 +
11716 + thread->joined = 1;
11717 +
11718 + vcos_semaphore_wait(&thread->wait);
11719 +
11720 + if (pData)
11721 + {
11722 + *pData = thread->exit_data;
11723 + }
11724 +
11725 + /* Clean up */
11726 + if (thread->stack)
11727 + vcos_free(thread->stack);
11728 +
11729 + vcos_semaphore_delete(&thread->wait);
11730 + vcos_semaphore_delete(&thread->suspend);
11731 +
11732 +}
11733 +
11734 +uint32_t vcos_getmicrosecs( void )
11735 +{
11736 + struct timeval tv;
11737 +/*XXX FIX ME! switch to ktime_get_ts to use MONOTONIC clock */
11738 + do_gettimeofday(&tv);
11739 + return (tv.tv_sec*1000000) + tv.tv_usec;
11740 +}
11741 +
11742 +VCOS_STATUS_T vcos_timer_init(void)
11743 +{
11744 + return VCOS_SUCCESS;
11745 +}
11746 +
11747 +static const char *log_prefix[] =
11748 +{
11749 + "", /* VCOS_LOG_UNINITIALIZED */
11750 + "", /* VCOS_LOG_NEVER */
11751 + KERN_ERR, /* VCOS_LOG_ERROR */
11752 + KERN_WARNING, /* VCOS_LOG_WARN */
11753 + KERN_INFO, /* VCOS_LOG_INFO */
11754 + KERN_INFO /* VCOS_LOG_TRACE */
11755 +};
11756 +
11757 +void vcos_vlog_default_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, va_list args)
11758 +{
11759 + char *newline = strchr( fmt, '\n' );
11760 + const char *prefix;
11761 + const char *real_fmt;
11762 +
11763 + preempt_disable();
11764 + {
11765 + if ( *fmt == '<' )
11766 + {
11767 + prefix = fmt;
11768 + real_fmt= &fmt[3];
11769 + }
11770 + else
11771 + {
11772 + prefix = log_prefix[_level];
11773 + real_fmt = fmt;
11774 + }
11775 +#if defined( CONFIG_BCM_KNLLOG_SUPPORT )
11776 + knllog_ventry( "vcos", real_fmt, args );
11777 +#endif
11778 + printk( "%.3svcos: [%d]: ", prefix, current->pid );
11779 + vprintk( real_fmt, args );
11780 +
11781 + if ( newline == NULL )
11782 + {
11783 + printk("\n");
11784 + }
11785 + }
11786 + preempt_enable();
11787 +}
11788 +
11789 +
11790 +const char * _vcos_log_level(void)
11791 +{
11792 + return NULL;
11793 +}
11794 +
11795 +/*****************************************************************************
11796 +*
11797 +* Displays the version information in /proc/vcos/version
11798 +*
11799 +*****************************************************************************/
11800 +
11801 +#ifdef HAVE_VCOS_VERSION
11802 +
11803 +static void show_version( VCOS_CFG_BUF_T buf, void *data )
11804 +{
11805 + static const char* copyright = "Copyright (c) 2011 Broadcom";
11806 +
11807 + vcos_cfg_buf_printf( buf, "Built %s %s on %s\n%s\nversion %s\n",
11808 + vcos_get_build_date(),
11809 + vcos_get_build_time(),
11810 + vcos_get_build_hostname(),
11811 + copyright,
11812 + vcos_get_build_version() );
11813 +}
11814 +
11815 +#endif
11816 +
11817 +/*****************************************************************************
11818 +*
11819 +* Initialises vcos
11820 +*
11821 +*****************************************************************************/
11822 +
11823 +VCOS_STATUS_T vcos_init(void)
11824 +{
11825 + if ( vcos_cfg_mkdir( &vcos_cfg_dir, NULL, "vcos" ) != VCOS_SUCCESS )
11826 + {
11827 + printk( KERN_ERR "%s: Unable to create vcos cfg entry\n", __func__ );
11828 + }
11829 + vcos_logging_init();
11830 +
11831 +#ifdef HAVE_VCOS_VERSION
11832 + if ( vcos_cfg_create_entry( &vcos_version_cfg, &vcos_cfg_dir, "version",
11833 + show_version, NULL, NULL ) != VCOS_SUCCESS )
11834 + {
11835 + printk( KERN_ERR "%s: Unable to create vcos cfg entry 'version'\n", __func__ );
11836 + }
11837 +#endif
11838 +
11839 + return VCOS_SUCCESS;
11840 +}
11841 +
11842 +/*****************************************************************************
11843 +*
11844 +* Deinitializes vcos
11845 +*
11846 +*****************************************************************************/
11847 +
11848 +void vcos_deinit(void)
11849 +{
11850 +#ifdef HAVE_VCOS_VERSION
11851 + vcos_cfg_remove_entry( &vcos_version_cfg );
11852 +#endif
11853 + vcos_cfg_remove_entry( &vcos_cfg_dir );
11854 +}
11855 +
11856 +void vcos_global_lock(void)
11857 +{
11858 + down(&lock);
11859 +}
11860 +
11861 +void vcos_global_unlock(void)
11862 +{
11863 + up(&lock);
11864 +}
11865 +
11866 +/* vcos_thread_exit() doesn't really stop this thread here
11867 + *
11868 + * At the moment, call to do_exit() will leak task_struct for
11869 + * current thread, so we let the vcos_thread_wrapper() do the
11870 + * cleanup and exit job, and we return w/o actually stopping the thread.
11871 + *
11872 + * ToDo: Kernel v2.6.31 onwards, it is considered safe to call do_exit()
11873 + * from kthread, the implementation of which is combined in 2 patches
11874 + * with commit-ids "63706172" and "cdd140bd" in oss Linux kernel tree
11875 + */
11876 +
11877 +void vcos_thread_exit(void *arg)
11878 +{
11879 + VCOS_THREAD_T *thread = vcos_thread_current();
11880 +
11881 + vcos_assert(thread);
11882 + vcos_assert(thread->magic == VCOS_THREAD_MAGIC);
11883 +
11884 + thread->exit_data = arg;
11885 +}
11886 +
11887 +void vcos_thread_attr_init(VCOS_THREAD_ATTR_T *attrs)
11888 +{
11889 + *attrs = default_attrs;
11890 +}
11891 +
11892 +void _vcos_task_timer_set(void (*pfn)(void *), void *cxt, VCOS_UNSIGNED ms)
11893 +{
11894 + VCOS_THREAD_T *self = vcos_thread_current();
11895 + vcos_assert(self);
11896 + vcos_assert(self->_timer.pfn == NULL);
11897 +
11898 + vcos_timer_create( &self->_timer.timer, "TaskTimer", pfn, cxt );
11899 + vcos_timer_set(&self->_timer.timer, ms);
11900 +}
11901 +
11902 +void _vcos_task_timer_cancel(void)
11903 +{
11904 + VCOS_THREAD_T *self = vcos_thread_current();
11905 + if (self->_timer.timer.linux_timer.function)
11906 + {
11907 + vcos_timer_cancel(&self->_timer.timer);
11908 + vcos_timer_delete(&self->_timer.timer);
11909 + }
11910 +}
11911 +
11912 +int vcos_vsnprintf( char *buf, size_t buflen, const char *fmt, va_list ap )
11913 +{
11914 + return vsnprintf( buf, buflen, fmt, ap );
11915 +}
11916 +
11917 +int vcos_snprintf(char *buf, size_t buflen, const char *fmt, ...)
11918 +{
11919 + int ret;
11920 + va_list ap;
11921 + va_start(ap,fmt);
11922 + ret = vsnprintf(buf, buflen, fmt, ap);
11923 + va_end(ap);
11924 + return ret;
11925 +}
11926 +
11927 +int vcos_llthread_running(VCOS_LLTHREAD_T *t) {
11928 + vcos_assert(0); /* this function only exists as a nasty hack for the video codecs! */
11929 + return 1;
11930 +}
11931 +
11932 +static int vcos_verify_bkpts = 1;
11933 +
11934 +int vcos_verify_bkpts_enabled(void)
11935 +{
11936 + return vcos_verify_bkpts;
11937 +}
11938 +
11939 +/*****************************************************************************
11940 +*
11941 +* _vcos_log_platform_init is called from vcos_logging_init
11942 +*
11943 +*****************************************************************************/
11944 +
11945 +void _vcos_log_platform_init(void)
11946 +{
11947 + if ( vcos_cfg_mkdir( &vcos_logging_cfg_dir, &vcos_cfg_dir, "logging" ) != VCOS_SUCCESS )
11948 + {
11949 + printk( KERN_ERR "%s: Unable to create logging cfg entry\n", __func__ );
11950 + }
11951 +}
11952 +
11953 +/*****************************************************************************
11954 +*
11955 +* Called to display the contents of a logging category.
11956 +*
11957 +*****************************************************************************/
11958 +
11959 +static void logging_show_category( VCOS_CFG_BUF_T buf, void *data )
11960 +{
11961 + VCOS_LOG_CAT_T *category = data;
11962 +
11963 + vcos_cfg_buf_printf( buf, "%s\n", vcos_log_level_to_string( category->level ));
11964 +}
11965 +
11966 +/*****************************************************************************
11967 +*
11968 +* Called to parse content for a logging category.
11969 +*
11970 +*****************************************************************************/
11971 +
11972 +static void logging_parse_category( VCOS_CFG_BUF_T buf, void *data )
11973 +{
11974 + VCOS_LOG_CAT_T *category = data;
11975 + const char *str = vcos_cfg_buf_get_str( buf );
11976 + VCOS_LOG_LEVEL_T level;
11977 +
11978 + if ( vcos_string_to_log_level( str, &level ) == VCOS_SUCCESS )
11979 + {
11980 + category->level = level;
11981 + }
11982 + else
11983 + {
11984 + printk( KERN_ERR "%s: Unrecognized logging level: '%s'\n",
11985 + __func__, str );
11986 + }
11987 +}
11988 +
11989 +/*****************************************************************************
11990 +*
11991 +* _vcos_log_platform_register is called from vcos_log_register whenever
11992 +* a new category is registered.
11993 +*
11994 +*****************************************************************************/
11995 +
11996 +void _vcos_log_platform_register(VCOS_LOG_CAT_T *category)
11997 +{
11998 + VCOS_CFG_ENTRY_T entry;
11999 +
12000 + if ( vcos_cfg_create_entry( &entry, &vcos_logging_cfg_dir, category->name,
12001 + logging_show_category, logging_parse_category,
12002 + category ) != VCOS_SUCCESS )
12003 + {
12004 + printk( KERN_ERR "%s: Unable to create cfg entry for logging category '%s'\n",
12005 + __func__, category->name );
12006 + category->platform_data = NULL;
12007 + }
12008 + else
12009 + {
12010 + category->platform_data = entry;
12011 + }
12012 +}
12013 +
12014 +/*****************************************************************************
12015 +*
12016 +* _vcos_log_platform_unregister is called from vcos_log_unregister whenever
12017 +* a new category is unregistered.
12018 +*
12019 +*****************************************************************************/
12020 +
12021 +void _vcos_log_platform_unregister(VCOS_LOG_CAT_T *category)
12022 +{
12023 + VCOS_CFG_ENTRY_T entry;
12024 +
12025 + entry = category->platform_data;
12026 + if ( entry != NULL )
12027 + {
12028 + if ( vcos_cfg_remove_entry( &entry ) != VCOS_SUCCESS )
12029 + {
12030 + printk( KERN_ERR "%s: Unable to remove cfg entry for logging category '%s'\n",
12031 + __func__, category->name );
12032 + }
12033 + }
12034 +}
12035 +
12036 +/*****************************************************************************
12037 +*
12038 +* Allocate memory.
12039 +*
12040 +*****************************************************************************/
12041 +
12042 +void *vcos_platform_malloc( VCOS_UNSIGNED required_size )
12043 +{
12044 + if ( required_size >= ( 2 * PAGE_SIZE ))
12045 + {
12046 + /* For larger allocations, use vmalloc, whose underlying allocator
12047 + * returns pages
12048 + */
12049 +
12050 + return vmalloc( required_size );
12051 + }
12052 +
12053 + /* For smaller allocation, use kmalloc */
12054 +
12055 + return kmalloc( required_size, GFP_KERNEL );
12056 +}
12057 +
12058 +/*****************************************************************************
12059 +*
12060 +* Free previously allocated memory
12061 +*
12062 +*****************************************************************************/
12063 +
12064 +void vcos_platform_free( void *ptr )
12065 +{
12066 + if (((unsigned long)ptr >= VMALLOC_START )
12067 + && ((unsigned long)ptr < VMALLOC_END ))
12068 + {
12069 + vfree( ptr );
12070 + }
12071 + else
12072 + {
12073 + kfree( ptr );
12074 + }
12075 +}
12076 +
12077 +/*****************************************************************************
12078 +*
12079 +* Execute a routine exactly once.
12080 +*
12081 +*****************************************************************************/
12082 +
12083 +VCOS_STATUS_T vcos_once(VCOS_ONCE_T *once_control,
12084 + void (*init_routine)(void))
12085 +{
12086 + /* In order to be thread-safe we need to re-test *once_control
12087 + * inside the lock. The outer test is basically an optimization
12088 + * so that once it is initialized we don't need to waste time
12089 + * trying to acquire the lock.
12090 + */
12091 +
12092 + if ( *once_control == 0 )
12093 + {
12094 + vcos_global_lock();
12095 + if ( *once_control == 0 )
12096 + {
12097 + init_routine();
12098 + *once_control = 1;
12099 + }
12100 + vcos_global_unlock();
12101 + }
12102 +
12103 + return VCOS_SUCCESS;
12104 +}
12105 +
12106 +/*****************************************************************************
12107 +*
12108 +* String duplication routine.
12109 +*
12110 +*****************************************************************************/
12111 +
12112 +char *vcos_strdup(const char *str)
12113 +{
12114 + return kstrdup(str, GFP_KERNEL);
12115 +}
12116 +
12117 +
12118 +/* Export functions for modules to use */
12119 +EXPORT_SYMBOL( vcos_init );
12120 +
12121 +EXPORT_SYMBOL( vcos_semaphore_trywait );
12122 +EXPORT_SYMBOL( vcos_semaphore_post );
12123 +EXPORT_SYMBOL( vcos_semaphore_create );
12124 +EXPORT_SYMBOL( vcos_semaphore_wait );
12125 +EXPORT_SYMBOL( vcos_semaphore_delete );
12126 +
12127 +EXPORT_SYMBOL( vcos_log_impl );
12128 +EXPORT_SYMBOL( vcos_vlog_impl );
12129 +EXPORT_SYMBOL( vcos_vlog_default_impl );
12130 +EXPORT_SYMBOL( vcos_log_get_default_category );
12131 +EXPORT_SYMBOL( vcos_log_register );
12132 +EXPORT_SYMBOL( vcos_log_unregister );
12133 +EXPORT_SYMBOL( vcos_logging_init );
12134 +EXPORT_SYMBOL( vcos_log_level_to_string );
12135 +EXPORT_SYMBOL( vcos_string_to_log_level );
12136 +EXPORT_SYMBOL( vcos_log_dump_mem_impl );
12137 +
12138 +EXPORT_SYMBOL( vcos_event_create );
12139 +EXPORT_SYMBOL( vcos_event_delete );
12140 +EXPORT_SYMBOL( vcos_event_flags_set );
12141 +EXPORT_SYMBOL( vcos_event_signal );
12142 +EXPORT_SYMBOL( vcos_event_wait );
12143 +EXPORT_SYMBOL( vcos_event_try );
12144 +
12145 +EXPORT_SYMBOL( vcos_getmicrosecs );
12146 +
12147 +EXPORT_SYMBOL( vcos_strcasecmp );
12148 +EXPORT_SYMBOL( vcos_snprintf );
12149 +EXPORT_SYMBOL( vcos_vsnprintf );
12150 +
12151 +EXPORT_SYMBOL( vcos_thread_current );
12152 +EXPORT_SYMBOL( vcos_thread_join );
12153 +EXPORT_SYMBOL( vcos_thread_create );
12154 +EXPORT_SYMBOL( vcos_thread_set_priority );
12155 +EXPORT_SYMBOL( vcos_thread_exit );
12156 +EXPORT_SYMBOL( vcos_once );
12157 +
12158 +EXPORT_SYMBOL( vcos_thread_attr_init );
12159 +EXPORT_SYMBOL( vcos_thread_attr_setpriority );
12160 +EXPORT_SYMBOL( vcos_thread_attr_settimeslice );
12161 +EXPORT_SYMBOL( vcos_thread_attr_setstacksize );
12162 +EXPORT_SYMBOL( _vcos_thread_attr_setlegacyapi );
12163 +
12164 +EXPORT_SYMBOL( vcos_event_flags_create );
12165 +EXPORT_SYMBOL( vcos_event_flags_delete );
12166 +EXPORT_SYMBOL( vcos_event_flags_get );
12167 +
12168 +EXPORT_SYMBOL( vcos_sleep );
12169 +
12170 +EXPORT_SYMBOL( vcos_calloc );
12171 +EXPORT_SYMBOL( vcos_malloc );
12172 +EXPORT_SYMBOL( vcos_malloc_aligned );
12173 +EXPORT_SYMBOL( vcos_free );
12174 +
12175 +EXPORT_SYMBOL( vcos_mutex_create );
12176 +EXPORT_SYMBOL( vcos_mutex_delete );
12177 +EXPORT_SYMBOL( vcos_mutex_lock );
12178 +EXPORT_SYMBOL( vcos_mutex_unlock );
12179 +EXPORT_SYMBOL( vcos_mutex_trylock );
12180 +
12181 +EXPORT_SYMBOL( vcos_timer_cancel );
12182 +EXPORT_SYMBOL( vcos_timer_create );
12183 +EXPORT_SYMBOL( vcos_timer_delete );
12184 +EXPORT_SYMBOL( vcos_timer_set );
12185 +
12186 +EXPORT_SYMBOL( vcos_atomic_flags_create );
12187 +EXPORT_SYMBOL( vcos_atomic_flags_delete );
12188 +EXPORT_SYMBOL( vcos_atomic_flags_or );
12189 +EXPORT_SYMBOL( vcos_atomic_flags_get_and_clear );
12190 +
12191 +EXPORT_SYMBOL( vcos_verify_bkpts_enabled );
12192 +
12193 +EXPORT_SYMBOL( vcos_strdup );
12194 --- /dev/null
12195 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel_cfg.c
12196 @@ -0,0 +1,332 @@
12197 +/*****************************************************************************
12198 +* Copyright 2009 - 2010 Broadcom Corporation. All rights reserved.
12199 +*
12200 +* Unless you and Broadcom execute a separate written software license
12201 +* agreement governing use of this software, this software is licensed to you
12202 +* under the terms of the GNU General Public License version 2, available at
12203 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
12204 +*
12205 +* Notwithstanding the above, under no circumstances may you combine this
12206 +* software in any way with any other Broadcom software provided under a
12207 +* license other than the GPL, without Broadcom's express prior written
12208 +* consent.
12209 +*****************************************************************************/
12210 +
12211 +#include "interface/vcos/vcos.h"
12212 +#include <linux/module.h>
12213 +#include <linux/proc_fs.h>
12214 +#include <linux/seq_file.h>
12215 +#include <asm/uaccess.h>
12216 +
12217 +struct opaque_vcos_cfg_buf_t
12218 +{
12219 + struct seq_file *seq;
12220 + char *charBuf;
12221 +};
12222 +
12223 +struct opaque_vcos_cfg_entry_t
12224 +{
12225 + struct proc_dir_entry *pde;
12226 + struct proc_dir_entry *parent_pde;
12227 + VCOS_CFG_SHOW_FPTR showFunc;
12228 + VCOS_CFG_PARSE_FPTR parseFunc;
12229 + void *data;
12230 + const char *name;
12231 +};
12232 +
12233 +/*****************************************************************************
12234 +*
12235 +* cfg_proc_show
12236 +*
12237 +*****************************************************************************/
12238 +
12239 +static int cfg_proc_show( struct seq_file *s, void *v )
12240 +{
12241 + VCOS_CFG_ENTRY_T entry;
12242 + struct opaque_vcos_cfg_buf_t buf;
12243 +
12244 + entry = s->private;
12245 +
12246 + if ( entry->showFunc )
12247 + {
12248 + memset( &buf, 0, sizeof( buf ));
12249 + buf.seq = s;
12250 +
12251 + entry->showFunc( &buf, entry->data );
12252 + }
12253 +
12254 + return 0;
12255 +}
12256 +
12257 +/*****************************************************************************
12258 +*
12259 +* cfg_proc_write
12260 +*
12261 +*****************************************************************************/
12262 +
12263 +static ssize_t cfg_proc_write( struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
12264 +{
12265 + VCOS_CFG_ENTRY_T entry = PDE(file->f_path.dentry->d_inode)->data;
12266 + char *charBuf;
12267 + struct opaque_vcos_cfg_buf_t buf;
12268 + size_t len;
12269 +
12270 + if ( entry->parseFunc != NULL )
12271 + {
12272 + /* The number 4000 is rather arbitrary. It just needs to be bigger than any input
12273 + * string we expect to use.
12274 + */
12275 +
12276 + len = count;
12277 + if ( count > 4000 )
12278 + {
12279 + len = 4000;
12280 + }
12281 +
12282 + /* Allocate a kernel buffer to contain the string being written. */
12283 +
12284 + charBuf = kmalloc( len + 1, GFP_KERNEL );
12285 + if ( copy_from_user( charBuf, buffer, len ))
12286 + {
12287 + kfree( charBuf );
12288 + return -EFAULT;
12289 + }
12290 +
12291 + /* echo puts a trailing newline in the buffer - strip it out. */
12292 +
12293 + if (( len > 0 ) && ( charBuf[ len - 1 ] == '\n' ))
12294 + {
12295 + len--;
12296 + }
12297 + charBuf[len] = '\0';
12298 +
12299 + memset( &buf, 0, sizeof( buf ));
12300 + buf.charBuf = charBuf;
12301 +
12302 + entry->parseFunc( &buf, entry->data );
12303 + kfree( charBuf );
12304 + }
12305 + return count;
12306 +}
12307 +
12308 +/*****************************************************************************
12309 +*
12310 +* cfg_proc_open
12311 +*
12312 +*****************************************************************************/
12313 +
12314 +static int cfg_proc_open( struct inode *inode, struct file *file )
12315 +{
12316 + return single_open( file, cfg_proc_show, PDE(inode)->data );
12317 +}
12318 +
12319 +static const struct file_operations cfg_proc_fops =
12320 +{
12321 + .open = cfg_proc_open,
12322 + .read = seq_read,
12323 + .llseek = seq_lseek,
12324 + .release = single_release,
12325 + .write = cfg_proc_write,
12326 +};
12327 +
12328 +/*****************************************************************************
12329 +*
12330 +* vcos_cfg_mkdir
12331 +*
12332 +*****************************************************************************/
12333 +
12334 +VCOS_STATUS_T vcos_cfg_mkdir( VCOS_CFG_ENTRY_T *entryp,
12335 + VCOS_CFG_ENTRY_T *parent,
12336 + const char *dirName )
12337 +{
12338 + VCOS_CFG_ENTRY_T entry;
12339 +
12340 + if (( entry = kzalloc( sizeof( *entry ), GFP_KERNEL )) == NULL )
12341 + {
12342 + return VCOS_ENOMEM;
12343 + }
12344 +
12345 + if ( parent == NULL )
12346 + {
12347 + entry->pde = proc_mkdir( dirName, NULL );
12348 + }
12349 + else
12350 + {
12351 + entry->pde = proc_mkdir( dirName, (*parent)->pde );
12352 + entry->parent_pde = (*parent)->pde;
12353 + }
12354 + if ( entry->pde == NULL )
12355 + {
12356 + kfree( entry );
12357 + return VCOS_ENOMEM;
12358 + }
12359 +
12360 + entry->name = dirName;
12361 +
12362 + *entryp = entry;
12363 + return VCOS_SUCCESS;
12364 +}
12365 +
12366 +/*****************************************************************************
12367 +*
12368 +* vcos_cfg_create_entry
12369 +*
12370 +*****************************************************************************/
12371 +
12372 +VCOS_STATUS_T vcos_cfg_create_entry( VCOS_CFG_ENTRY_T *entryp,
12373 + VCOS_CFG_ENTRY_T *parent,
12374 + const char *entryName,
12375 + VCOS_CFG_SHOW_FPTR showFunc,
12376 + VCOS_CFG_PARSE_FPTR parseFunc,
12377 + void *data )
12378 +{
12379 + VCOS_CFG_ENTRY_T entry;
12380 + mode_t mode;
12381 +
12382 + *entryp = NULL;
12383 +
12384 + if (( entry = kzalloc( sizeof( *entry ), GFP_KERNEL )) == NULL )
12385 + {
12386 + return VCOS_ENOMEM;
12387 + }
12388 +
12389 + mode = 0;
12390 + if ( showFunc != NULL )
12391 + {
12392 + mode |= 0444;
12393 + }
12394 + if ( parseFunc != NULL )
12395 + {
12396 + mode |= 0200;
12397 + }
12398 +
12399 + if ( parent == NULL )
12400 + {
12401 + entry->pde = create_proc_entry( entryName, mode, NULL );
12402 + }
12403 + else
12404 + {
12405 + entry->pde = create_proc_entry( entryName, mode, (*parent)->pde );
12406 + entry->parent_pde = (*parent)->pde;
12407 + }
12408 + if ( entry->pde == NULL )
12409 + {
12410 + kfree( entry );
12411 + return -ENOMEM;
12412 + }
12413 + entry->showFunc = showFunc;
12414 + entry->parseFunc = parseFunc;
12415 + entry->data = data;
12416 + entry->name = entryName;
12417 +
12418 + entry->pde->data = entry;
12419 + entry->pde->proc_fops = &cfg_proc_fops;
12420 +
12421 + *entryp = entry;
12422 + return VCOS_SUCCESS;
12423 +}
12424 +
12425 +/*****************************************************************************
12426 +*
12427 +* vcos_cfg_remove_entry
12428 +*
12429 +*****************************************************************************/
12430 +
12431 +VCOS_STATUS_T vcos_cfg_remove_entry( VCOS_CFG_ENTRY_T *entryp )
12432 +{
12433 + if (( entryp != NULL ) && ( *entryp != NULL ))
12434 + {
12435 + remove_proc_entry( (*entryp)->name, (*entryp)->parent_pde );
12436 +
12437 + kfree( *entryp );
12438 + *entryp = NULL;
12439 + }
12440 +
12441 + return VCOS_SUCCESS;
12442 +}
12443 +
12444 +/*****************************************************************************
12445 +*
12446 +* vcos_cfg_is_entry_created
12447 +*
12448 +*****************************************************************************/
12449 +
12450 +int vcos_cfg_is_entry_created( VCOS_CFG_ENTRY_T entry )
12451 +{
12452 + return ( entry != NULL ) && ( entry->pde != NULL );
12453 +}
12454 +
12455 +/*****************************************************************************
12456 +*
12457 +* vcos_cfg_buf_printf
12458 +*
12459 +*****************************************************************************/
12460 +
12461 +void vcos_cfg_buf_printf( VCOS_CFG_BUF_T buf, const char *fmt, ... )
12462 +{
12463 + struct seq_file *m = buf->seq;
12464 +
12465 + /* Bah - there is no seq_vprintf */
12466 +
12467 + va_list args;
12468 + int len;
12469 +
12470 + if (m->count < m->size) {
12471 + va_start(args, fmt);
12472 + len = vsnprintf(m->buf + m->count, m->size - m->count, fmt, args);
12473 + va_end(args);
12474 + if (m->count + len < m->size) {
12475 + m->count += len;
12476 + return;
12477 + }
12478 + }
12479 + m->count = m->size;
12480 +}
12481 +
12482 +/*****************************************************************************
12483 +*
12484 +* vcos_cfg_buf_get_str
12485 +*
12486 +*****************************************************************************/
12487 +
12488 +char *vcos_cfg_buf_get_str( VCOS_CFG_BUF_T buf )
12489 +{
12490 + return buf->charBuf;
12491 +}
12492 +
12493 +/*****************************************************************************
12494 +*
12495 +* vcos_cfg_get_proc_entry
12496 +*
12497 +* This function is only created for a couple of backwards compatibility '
12498 +* issues and shouldn't normally be used.
12499 +*
12500 +*****************************************************************************/
12501 +
12502 +void *vcos_cfg_get_proc_entry( VCOS_CFG_ENTRY_T entry )
12503 +{
12504 + return entry->pde;
12505 +}
12506 +
12507 +/*****************************************************************************
12508 +*
12509 +* vcos_cfg_get_entry_name
12510 +*
12511 +*****************************************************************************/
12512 +
12513 +const char *vcos_cfg_get_entry_name( VCOS_CFG_ENTRY_T entry )
12514 +{
12515 + return entry->pde->name;
12516 +}
12517 +
12518 +
12519 +EXPORT_SYMBOL( vcos_cfg_mkdir );
12520 +EXPORT_SYMBOL( vcos_cfg_create_entry );
12521 +EXPORT_SYMBOL( vcos_cfg_remove_entry );
12522 +EXPORT_SYMBOL( vcos_cfg_get_entry_name );
12523 +EXPORT_SYMBOL( vcos_cfg_is_entry_created );
12524 +EXPORT_SYMBOL( vcos_cfg_buf_printf );
12525 +EXPORT_SYMBOL( vcos_cfg_buf_get_str );
12526 +
12527 +EXPORT_SYMBOL_GPL( vcos_cfg_get_proc_entry );
12528 +
12529 --- /dev/null
12530 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_linuxkernel_misc.c
12531 @@ -0,0 +1,113 @@
12532 +// #############################################################################
12533 +// START #######################################################################
12534 +/*****************************************************************************
12535 +* Copyright 2009 - 2010 Broadcom Corporation. All rights reserved.
12536 +*
12537 +* Unless you and Broadcom execute a separate written software license
12538 +* agreement governing use of this software, this software is licensed to you
12539 +* under the terms of the GNU General Public License version 2, available at
12540 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
12541 +*
12542 +* Notwithstanding the above, under no circumstances may you combine this
12543 +* software in any way with any other Broadcom software provided under a
12544 +* license other than the GPL, without Broadcom's express prior written
12545 +* consent.
12546 +*****************************************************************************/
12547 +
12548 +#include "interface/vcos/vcos.h"
12549 +#include <linux/sched.h>
12550 +#include <linux/module.h>
12551 +#include <linux/freezer.h>
12552 +#include <linux/string.h>
12553 +#include <linux/slab.h>
12554 +
12555 +/*****************************************************************************
12556 +*
12557 +* vcos_semaphore_wait_freezable
12558 +*
12559 +*****************************************************************************/
12560 +
12561 +VCOS_STATUS_T vcos_semaphore_wait_freezable(VCOS_SEMAPHORE_T *sem)
12562 +{
12563 + int rval, sig_pended = 0;
12564 + unsigned long flags;
12565 + struct task_struct *task = current;
12566 +
12567 + while (1) {
12568 + rval = down_interruptible((struct semaphore *)sem);
12569 + if (rval == 0) { /* down now */
12570 + break;
12571 + } else {
12572 + if (freezing(current)) {
12573 + try_to_freeze();
12574 + } else {
12575 + spin_lock_irqsave(&task->sighand->siglock, flags);
12576 + if (test_tsk_thread_flag(task, TIF_SIGPENDING)) {
12577 + clear_tsk_thread_flag(task, TIF_SIGPENDING);
12578 + sig_pended = 1;
12579 + }
12580 + spin_unlock_irqrestore(&task->sighand->siglock, flags);
12581 + }
12582 + }
12583 + }
12584 +
12585 + if (sig_pended) {
12586 + spin_lock_irqsave(&task->sighand->siglock, flags);
12587 + set_tsk_thread_flag(task, TIF_SIGPENDING);
12588 + spin_unlock_irqrestore(&task->sighand->siglock, flags);
12589 + }
12590 +
12591 + return 0;
12592 +}
12593 +
12594 +EXPORT_SYMBOL( vcos_semaphore_wait_freezable );
12595 +
12596 +/*****************************************************************************
12597 +*
12598 +* vcos_kmalloc
12599 +*
12600 +* We really need to convert malloc to do kmalloc or vmalloc based on the
12601 +* size, but for now we'll add a separate function.
12602 +*
12603 +*****************************************************************************/
12604 +
12605 +void *vcos_kmalloc(VCOS_UNSIGNED size, const char *description)
12606 +{
12607 + (void)description;
12608 +
12609 + return kmalloc( size, GFP_KERNEL );
12610 +}
12611 +
12612 +/*****************************************************************************
12613 +*
12614 +* vcos_kmalloc
12615 +*
12616 +* We really need to convert malloc to do kmalloc or vmalloc based on the
12617 +* size, but for now we'll add a separate function.
12618 +*
12619 +*****************************************************************************/
12620 +
12621 +void *vcos_kcalloc(VCOS_UNSIGNED num, VCOS_UNSIGNED size, const char *description)
12622 +{
12623 + (void)description;
12624 +
12625 + return kzalloc( num * size, GFP_KERNEL );
12626 +}
12627 +
12628 +/*****************************************************************************
12629 +*
12630 +* vcos_kfree
12631 +*
12632 +*****************************************************************************/
12633 +
12634 +void vcos_kfree(void *ptr)
12635 +{
12636 + kfree( ptr );
12637 +}
12638 +
12639 +EXPORT_SYMBOL( vcos_kmalloc );
12640 +EXPORT_SYMBOL( vcos_kcalloc );
12641 +EXPORT_SYMBOL( vcos_kfree );
12642 +
12643 +// END #########################################################################
12644 +// #############################################################################
12645 --- /dev/null
12646 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_mod_init.c
12647 @@ -0,0 +1,64 @@
12648 +/*****************************************************************************
12649 +* Copyright 2006 - 2008 Broadcom Corporation. All rights reserved.
12650 +*
12651 +* Unless you and Broadcom execute a separate written software license
12652 +* agreement governing use of this software, this software is licensed to you
12653 +* under the terms of the GNU General Public License version 2, available at
12654 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
12655 +*
12656 +* Notwithstanding the above, under no circumstances may you combine this
12657 +* software in any way with any other Broadcom software provided under a
12658 +* license other than the GPL, without Broadcom's express prior written
12659 +* consent.
12660 +****************************************************************************/
12661 +
12662 +/* ---- Include Files ---------------------------------------------------- */
12663 +
12664 +#include "interface/vcos/vcos.h"
12665 +#include <linux/module.h>
12666 +
12667 +/* ---- Public Variables ------------------------------------------------- */
12668 +
12669 +/* ---- Private Constants and Types -------------------------------------- */
12670 +
12671 +/* ---- Private Variables ------------------------------------------------ */
12672 +
12673 +/* ---- Private Function Prototypes -------------------------------------- */
12674 +
12675 +/* ---- Functions -------------------------------------------------------- */
12676 +
12677 +/****************************************************************************
12678 +*
12679 +* Called to perform module initialization when the module is loaded
12680 +*
12681 +***************************************************************************/
12682 +
12683 +static int __init vcos_mod_init( void )
12684 +{
12685 + printk( KERN_INFO "VCOS Module\n" );
12686 +
12687 + vcos_init();
12688 + return 0;
12689 +}
12690 +
12691 +/****************************************************************************
12692 +*
12693 +* Called to perform module cleanup when the module is unloaded.
12694 +*
12695 +***************************************************************************/
12696 +
12697 +static void __exit vcos_mod_exit( void )
12698 +{
12699 + vcos_deinit();
12700 +}
12701 +
12702 +/****************************************************************************/
12703 +
12704 +module_init( vcos_mod_init );
12705 +module_exit( vcos_mod_exit );
12706 +
12707 +MODULE_AUTHOR("Broadcom");
12708 +MODULE_DESCRIPTION( "VCOS Module Functions" );
12709 +MODULE_LICENSE( "GPL" );
12710 +MODULE_VERSION( "1.0" );
12711 +
12712 --- /dev/null
12713 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_platform.h
12714 @@ -0,0 +1,496 @@
12715 +/*=============================================================================
12716 +Copyright (c) 2009 Broadcom Europe Limited.
12717 +All rights reserved.
12718 +
12719 +Project : vcfw
12720 +Module : vcos
12721 +
12722 +FILE DESCRIPTION
12723 +VideoCore OS Abstraction Layer - Linux kernel (partial) implementation.
12724 +=============================================================================*/
12725 +
12726 +/* Do not include this file directly - instead include it via vcos.h */
12727 +
12728 +/** @file
12729 + *
12730 + * Linux kernel (partial) implementation of VCOS.
12731 + *
12732 + */
12733 +
12734 +#ifndef VCOS_PLATFORM_H
12735 +#define VCOS_PLATFORM_H
12736 +
12737 +#include <linux/types.h>
12738 +#include <linux/semaphore.h>
12739 +#include <linux/mutex.h>
12740 +#include <asm/bitops.h>
12741 +#include <linux/kthread.h>
12742 +#include <linux/wait.h>
12743 +#include <linux/vmalloc.h>
12744 +#include <linux/jiffies.h>
12745 +#include <linux/delay.h>
12746 +#include <linux/string.h>
12747 +#include <linux/types.h>
12748 +#include <linux/interrupt.h>
12749 +#include <linux/random.h>
12750 +#include <linux/sched.h>
12751 +#include <linux/ctype.h>
12752 +#include <linux/uaccess.h>
12753 +#include <linux/time.h> /* for time_t */
12754 +#include <linux/slab.h>
12755 +#include <linux/vmalloc.h>
12756 +
12757 +#define VCOS_HAVE_RTOS 1
12758 +#define VCOS_HAVE_SEMAPHORE 1
12759 +#define VCOS_HAVE_EVENT 1
12760 +#define VCOS_HAVE_QUEUE 0
12761 +#define VCOS_HAVE_LEGACY_ISR 0
12762 +#define VCOS_HAVE_TIMER 1
12763 +#define VCOS_HAVE_CANCELLATION_SAFE_TIMER 0
12764 +#define VCOS_HAVE_MEMPOOL 0
12765 +#define VCOS_HAVE_ISR 0
12766 +#define VCOS_HAVE_ATOMIC_FLAGS 1
12767 +#define VCOS_HAVE_BLOCK_POOL 0
12768 +#define VCOS_HAVE_ONCE 1
12769 +#define VCOS_HAVE_FILE 0
12770 +#define VCOS_HAVE_USER_BUF 0
12771 +#define VCOS_HAVE_CFG 1
12772 +#define VCOS_HAVE_SPINLOCK 0
12773 +#define VCOS_HAVE_CMD 1
12774 +#define VCOS_HAVE_EVENT_FLAGS 1
12775 +
12776 +/* Exclude many VCOS classes which don't have predicates */
12777 +#define VCOS_TLS_H
12778 +#define VCOS_NAMED_MUTEX_H
12779 +#define VCOS_REENTRANT_MUTEX_H
12780 +#define VCOS_NAMED_SEMAPHORE_H
12781 +#define VCOS_QUICKSLOW_MUTEX_H
12782 +/*#define VCOS_INIT_H */
12783 +/*#define VCOS_MEM_H */
12784 +/*#define VCOS_STRING_H */
12785 +
12786 +typedef struct semaphore VCOS_SEMAPHORE_T;
12787 +typedef struct semaphore VCOS_EVENT_T;
12788 +typedef struct mutex VCOS_MUTEX_T;
12789 +typedef volatile int VCOS_ONCE_T;
12790 +
12791 +typedef unsigned int VCOS_UNSIGNED;
12792 +typedef unsigned int VCOS_OPTION;
12793 +typedef atomic_t VCOS_ATOMIC_FLAGS_T;
12794 +
12795 +typedef struct
12796 +{
12797 + struct timer_list linux_timer;
12798 + void *context;
12799 + void (*expiration_routine)(void *context);
12800 +
12801 +} VCOS_TIMER_T;
12802 +
12803 +typedef struct VCOS_LLTHREAD_T
12804 +{
12805 + struct task_struct *thread; /**< The thread itself */
12806 + VCOS_SEMAPHORE_T suspend; /**< For support event groups and similar - a per thread semaphore */
12807 +} VCOS_LLTHREAD_T;
12808 +
12809 +typedef enum
12810 +{
12811 + VCOS_O_RDONLY = 00000000,
12812 + VCOS_O_WRONLY = 00000001,
12813 + VCOS_O_RDWR = 00000002,
12814 + VCOS_O_TRUNC = 00001000,
12815 +} VCOS_FILE_FLAGS_T;
12816 +
12817 +typedef struct file *VCOS_FILE_T;
12818 +
12819 +#define VCOS_SUSPEND -1
12820 +#define VCOS_NO_SUSPEND 0
12821 +
12822 +#define VCOS_START 1
12823 +#define VCOS_NO_START 0
12824 +
12825 +#define VCOS_THREAD_PRI_MIN -20
12826 +#define VCOS_THREAD_PRI_MAX 19
12827 +
12828 +#define VCOS_THREAD_PRI_INCREASE -1
12829 +#define VCOS_THREAD_PRI_HIGHEST VCOS_THREAD_PRI_MIN
12830 +#define VCOS_THREAD_PRI_LOWEST VCOS_THREAD_PRI_MAX
12831 +#define VCOS_THREAD_PRI_NORMAL ((VCOS_THREAD_PRI_MAX+VCOS_THREAD_PRI_MIN)/2)
12832 +#define VCOS_THREAD_PRI_ABOVE_NORMAL (VCOS_THREAD_PRI_NORMAL + VCOS_THREAD_PRI_INCREASE)
12833 +#define VCOS_THREAD_PRI_REALTIME VCOS_THREAD_PRI_HIGHEST
12834 +
12835 +#define _VCOS_AFFINITY_DEFAULT 0
12836 +#define _VCOS_AFFINITY_CPU0 0
12837 +#define _VCOS_AFFINITY_CPU1 0
12838 +#define _VCOS_AFFINITY_MASK 0
12839 +#define VCOS_CAN_SET_STACK_ADDR 0
12840 +
12841 +#define VCOS_TICKS_PER_SECOND HZ
12842 +
12843 +#include "interface/vcos/generic/vcos_generic_event_flags.h"
12844 +#include "interface/vcos/generic/vcos_mem_from_malloc.h"
12845 +#include "interface/vcos/generic/vcos_joinable_thread_from_plain.h"
12846 +
12847 +/***********************************************************
12848 + *
12849 + * Memory allcoation
12850 + *
12851 + ***********************************************************/
12852 +
12853 +#define _vcos_platform_malloc vcos_platform_malloc
12854 +#define _vcos_platform_free vcos_platform_free
12855 +
12856 +void *vcos_platform_malloc( VCOS_UNSIGNED required_size );
12857 +void vcos_platform_free( void *ptr );
12858 +
12859 +#if defined(VCOS_INLINE_BODIES)
12860 +
12861 +#undef VCOS_ASSERT_LOGGING_DISABLE
12862 +#define VCOS_ASSERT_LOGGING_DISABLE 1
12863 +
12864 +/***********************************************************
12865 + *
12866 + * Counted Semaphores
12867 + *
12868 + ***********************************************************/
12869 +
12870 +VCOS_INLINE_IMPL
12871 +VCOS_STATUS_T vcos_semaphore_wait(VCOS_SEMAPHORE_T *sem) {
12872 + int ret = down_interruptible(sem);
12873 + if ( ret == 0 )
12874 + /* Success */
12875 + return VCOS_SUCCESS;
12876 + else if ( ret == -EINTR )
12877 + /* Interrupted */
12878 + return VCOS_EINTR;
12879 + else
12880 + /* Default (timeout) */
12881 + return VCOS_EAGAIN;
12882 +}
12883 +
12884 +VCOS_INLINE_IMPL
12885 +VCOS_STATUS_T vcos_semaphore_trywait(VCOS_SEMAPHORE_T *sem) {
12886 + if (down_trylock(sem) != 0)
12887 + return VCOS_EAGAIN;
12888 + return VCOS_SUCCESS;
12889 +}
12890 +
12891 +VCOS_INLINE_IMPL
12892 +VCOS_STATUS_T vcos_semaphore_create(VCOS_SEMAPHORE_T *sem,
12893 + const char *name,
12894 + VCOS_UNSIGNED initial_count) {
12895 + sema_init(sem, initial_count);
12896 + return VCOS_SUCCESS;
12897 +}
12898 +
12899 +VCOS_INLINE_IMPL
12900 +void vcos_semaphore_delete(VCOS_SEMAPHORE_T *sem) {
12901 +}
12902 +
12903 +VCOS_INLINE_IMPL
12904 +VCOS_STATUS_T vcos_semaphore_post(VCOS_SEMAPHORE_T *sem) {
12905 + up(sem);
12906 + return VCOS_SUCCESS;
12907 +}
12908 +
12909 +/***********************************************************
12910 + *
12911 + * Threads
12912 + *
12913 + ***********************************************************/
12914 +
12915 +#include "vcos_thread_map.h"
12916 +
12917 +VCOS_INLINE_IMPL
12918 +VCOS_LLTHREAD_T *vcos_llthread_current(void) {
12919 + return &vcos_kthread_current()->thread;
12920 +}
12921 +
12922 +VCOS_INLINE_IMPL
12923 +void vcos_llthread_resume(VCOS_LLTHREAD_T *thread) {
12924 + vcos_assert(0);
12925 +}
12926 +
12927 +VCOS_INLINE_IMPL
12928 +void vcos_sleep(uint32_t ms) {
12929 + msleep(ms);
12930 +}
12931 +
12932 +VCOS_INLINE_IMPL
12933 +void vcos_thread_set_priority(VCOS_THREAD_T *thread, VCOS_UNSIGNED p) {
12934 + /* not implemented */
12935 +}
12936 +VCOS_INLINE_IMPL
12937 +VCOS_UNSIGNED vcos_thread_get_priority(VCOS_THREAD_T *thread) {
12938 + /* not implemented */
12939 + return 0;
12940 +}
12941 +
12942 +/***********************************************************
12943 + *
12944 + * Miscellaneous
12945 + *
12946 + ***********************************************************/
12947 +
12948 +VCOS_INLINE_IMPL
12949 +int vcos_strcasecmp(const char *s1, const char *s2) {
12950 + return strcasecmp(s1,s2);
12951 +}
12952 +
12953 +
12954 +/***********************************************************
12955 + *
12956 + * Mutexes
12957 + *
12958 + ***********************************************************/
12959 +
12960 +VCOS_INLINE_IMPL
12961 +VCOS_STATUS_T vcos_mutex_create(VCOS_MUTEX_T *m, const char *name) {
12962 + mutex_init(m);
12963 + return VCOS_SUCCESS;
12964 +}
12965 +
12966 +VCOS_INLINE_IMPL
12967 +void vcos_mutex_delete(VCOS_MUTEX_T *m) {
12968 +}
12969 +
12970 +VCOS_INLINE_IMPL
12971 +VCOS_STATUS_T vcos_mutex_lock(VCOS_MUTEX_T *m) {
12972 + int ret = mutex_lock_interruptible(m);
12973 + if ( ret == 0 )
12974 + /* Success */
12975 + return VCOS_SUCCESS;
12976 + else if ( ret == -EINTR )
12977 + /* Interrupted */
12978 + return VCOS_EINTR;
12979 + else
12980 + /* Default */
12981 + return VCOS_EAGAIN;
12982 +}
12983 +
12984 +VCOS_INLINE_IMPL
12985 +void vcos_mutex_unlock(VCOS_MUTEX_T *m) {
12986 + mutex_unlock(m);
12987 +}
12988 +
12989 +VCOS_INLINE_IMPL
12990 +int vcos_mutex_is_locked(VCOS_MUTEX_T *m) {
12991 + if (mutex_trylock(m) != 0)
12992 + return 1; /* it was locked */
12993 + mutex_unlock(m);
12994 + /* it wasn't locked */
12995 + return 0;
12996 +}
12997 +
12998 +VCOS_INLINE_IMPL
12999 +VCOS_STATUS_T vcos_mutex_trylock(VCOS_MUTEX_T *m) {
13000 + if (mutex_trylock(m) == 0)
13001 + return VCOS_SUCCESS;
13002 + else
13003 + return VCOS_EAGAIN;
13004 +}
13005 +
13006 +/* For supporting event groups - per thread semaphore */
13007 +VCOS_INLINE_IMPL
13008 +void _vcos_thread_sem_wait(void) {
13009 + VCOS_THREAD_T *t = vcos_thread_current();
13010 + vcos_semaphore_wait(&t->suspend);
13011 +}
13012 +
13013 +VCOS_INLINE_IMPL
13014 +void _vcos_thread_sem_post(VCOS_THREAD_T *target) {
13015 + vcos_semaphore_post(&target->suspend);
13016 +}
13017 +
13018 +/***********************************************************
13019 + *
13020 + * Events
13021 + *
13022 + ***********************************************************/
13023 +
13024 +VCOS_INLINE_IMPL
13025 +VCOS_STATUS_T vcos_event_create(VCOS_EVENT_T *event, const char *debug_name)
13026 +{
13027 + sema_init(event, 0);
13028 + return VCOS_SUCCESS;
13029 +}
13030 +
13031 +VCOS_INLINE_IMPL
13032 +void vcos_event_signal(VCOS_EVENT_T *event)
13033 +{
13034 + up(event);
13035 +}
13036 +
13037 +VCOS_INLINE_IMPL
13038 +VCOS_STATUS_T vcos_event_wait(VCOS_EVENT_T *event)
13039 +{
13040 + int ret = down_interruptible(event);
13041 + if ( ret == -EINTR )
13042 + /* Interrupted */
13043 + return VCOS_EINTR;
13044 + else if (ret != 0)
13045 + /* Default (timeout) */
13046 + return VCOS_EAGAIN;
13047 + /* Emulate a maximum count of 1 by removing any extra upness */
13048 + while (down_trylock(event) == 0) continue;
13049 + return VCOS_SUCCESS;
13050 +}
13051 +
13052 +VCOS_INLINE_DECL
13053 +VCOS_STATUS_T vcos_event_try(VCOS_EVENT_T *event)
13054 +{
13055 + return (down_trylock(event) == 0) ? VCOS_SUCCESS : VCOS_EAGAIN;
13056 +}
13057 +
13058 +VCOS_INLINE_IMPL
13059 +void vcos_event_delete(VCOS_EVENT_T *event)
13060 +{
13061 +}
13062 +
13063 +/***********************************************************
13064 + *
13065 + * Timers
13066 + *
13067 + ***********************************************************/
13068 +
13069 +VCOS_INLINE_DECL
13070 +void vcos_timer_linux_func(unsigned long data)
13071 +{
13072 + VCOS_TIMER_T *vcos_timer = (VCOS_TIMER_T *)data;
13073 +
13074 + vcos_timer->expiration_routine( vcos_timer->context );
13075 +}
13076 +
13077 +VCOS_INLINE_DECL
13078 +VCOS_STATUS_T vcos_timer_create(VCOS_TIMER_T *timer,
13079 + const char *name,
13080 + void (*expiration_routine)(void *context),
13081 + void *context) {
13082 + init_timer(&timer->linux_timer);
13083 + timer->linux_timer.data = (unsigned long)timer;
13084 + timer->linux_timer.function = vcos_timer_linux_func;
13085 +
13086 + timer->context = context;
13087 + timer->expiration_routine = expiration_routine;
13088 +
13089 + return VCOS_SUCCESS;
13090 +}
13091 +
13092 +VCOS_INLINE_IMPL
13093 +void vcos_timer_set(VCOS_TIMER_T *timer, VCOS_UNSIGNED delay_ms) {
13094 + timer->linux_timer.expires = jiffies + msecs_to_jiffies(delay_ms);
13095 + add_timer(&timer->linux_timer);
13096 +}
13097 +
13098 +VCOS_INLINE_IMPL
13099 +void vcos_timer_cancel(VCOS_TIMER_T *timer) {
13100 + del_timer(&timer->linux_timer);
13101 +}
13102 +
13103 +VCOS_INLINE_IMPL
13104 +void vcos_timer_reset(VCOS_TIMER_T *timer, VCOS_UNSIGNED delay_ms) {
13105 + del_timer_sync(&timer->linux_timer);
13106 + timer->linux_timer.expires = jiffies + msecs_to_jiffies(delay_ms);
13107 + add_timer(&timer->linux_timer);
13108 +}
13109 +
13110 +VCOS_INLINE_IMPL
13111 +void vcos_timer_delete(VCOS_TIMER_T *timer) {
13112 + timer->context = NULL;
13113 + timer->expiration_routine = NULL;
13114 + timer->linux_timer.function = NULL;
13115 + timer->linux_timer.data = 0;
13116 + return;
13117 +}
13118 +
13119 +VCOS_INLINE_IMPL
13120 +VCOS_UNSIGNED vcos_process_id_current(void) {
13121 + return (VCOS_UNSIGNED)current->pid;
13122 +}
13123 +
13124 +
13125 +VCOS_INLINE_IMPL
13126 +int vcos_in_interrupt(void) {
13127 + return in_interrupt();
13128 +}
13129 +
13130 +/***********************************************************
13131 + *
13132 + * Atomic flags
13133 + *
13134 + ***********************************************************/
13135 +
13136 +VCOS_INLINE_IMPL
13137 +VCOS_STATUS_T vcos_atomic_flags_create(VCOS_ATOMIC_FLAGS_T *atomic_flags)
13138 +{
13139 + atomic_set(atomic_flags, 0);
13140 + return VCOS_SUCCESS;
13141 +}
13142 +
13143 +VCOS_INLINE_IMPL
13144 +void vcos_atomic_flags_or(VCOS_ATOMIC_FLAGS_T *atomic_flags, uint32_t flags)
13145 +{
13146 + uint32_t value;
13147 + do {
13148 + value = atomic_read(atomic_flags);
13149 + } while (atomic_cmpxchg(atomic_flags, value, value | flags) != value);
13150 +}
13151 +
13152 +VCOS_INLINE_IMPL
13153 +uint32_t vcos_atomic_flags_get_and_clear(VCOS_ATOMIC_FLAGS_T *atomic_flags)
13154 +{
13155 + return atomic_xchg(atomic_flags, 0);
13156 +}
13157 +
13158 +VCOS_INLINE_IMPL
13159 +void vcos_atomic_flags_delete(VCOS_ATOMIC_FLAGS_T *atomic_flags)
13160 +{
13161 +}
13162 +
13163 +#undef VCOS_ASSERT_LOGGING_DISABLE
13164 +#define VCOS_ASSERT_LOGGING_DISABLE 0
13165 +
13166 +#endif /* VCOS_INLINE_BODIES */
13167 +
13168 +VCOS_INLINE_DECL void _vcos_thread_sem_wait(void);
13169 +VCOS_INLINE_DECL void _vcos_thread_sem_post(VCOS_THREAD_T *);
13170 +
13171 +/***********************************************************
13172 + *
13173 + * Misc
13174 + *
13175 + ***********************************************************/
13176 +VCOS_INLINE_DECL char *vcos_strdup(const char *str);
13177 +
13178 +/***********************************************************
13179 + *
13180 + * Logging
13181 + *
13182 + ***********************************************************/
13183 +
13184 +VCOSPRE_ const char * VCOSPOST_ _vcos_log_level(void);
13185 +#define _VCOS_LOG_LEVEL() _vcos_log_level()
13186 +
13187 +#define vcos_log_platform_init() _vcos_log_platform_init()
13188 +#define vcos_log_platform_register(category) _vcos_log_platform_register(category)
13189 +#define vcos_log_platform_unregister(category) _vcos_log_platform_unregister(category)
13190 +
13191 +struct VCOS_LOG_CAT_T; /* Forward declaration since vcos_logging.h hasn't been included yet */
13192 +
13193 +void _vcos_log_platform_init(void);
13194 +void _vcos_log_platform_register(struct VCOS_LOG_CAT_T *category);
13195 +void _vcos_log_platform_unregister(struct VCOS_LOG_CAT_T *category);
13196 +
13197 +/***********************************************************
13198 + *
13199 + * Memory barriers
13200 + *
13201 + ***********************************************************/
13202 +
13203 +#define vcos_wmb(x) wmb()
13204 +#define vcos_rmb() rmb()
13205 +
13206 +#include "interface/vcos/generic/vcos_common.h"
13207 +/*#include "interface/vcos/generic/vcos_generic_quickslow_mutex.h" */
13208 +
13209 +#endif /* VCOS_PLATFORM_H */
13210 +
13211 --- /dev/null
13212 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_platform_types.h
13213 @@ -0,0 +1,47 @@
13214 +/*=============================================================================
13215 +Copyright (c) 2009 Broadcom Europe Limited.
13216 +All rights reserved.
13217 +
13218 +Project : vcfw
13219 +Module : osal
13220 +
13221 +FILE DESCRIPTION
13222 +VideoCore OS Abstraction Layer - platform-specific types and defines
13223 +=============================================================================*/
13224 +
13225 +#ifndef VCOS_PLATFORM_TYPES_H
13226 +#define VCOS_PLATFORM_TYPES_H
13227 +
13228 +#include <stddef.h>
13229 +#include <linux/types.h>
13230 +#include <linux/bug.h>
13231 +
13232 +#define VCOSPRE_ extern
13233 +#define VCOSPOST_
13234 +
13235 +#if defined(__GNUC__) && (( __GNUC__ > 2 ) || (( __GNUC__ == 2 ) && ( __GNUC_MINOR__ >= 3 )))
13236 +#define VCOS_FORMAT_ATTR_(ARCHETYPE, STRING_INDEX, FIRST_TO_CHECK) __attribute__ ((format (ARCHETYPE, STRING_INDEX, FIRST_TO_CHECK)))
13237 +#else
13238 +#define VCOS_FORMAT_ATTR_(ARCHETYPE, STRING_INDEX, FIRST_TO_CHECK)
13239 +#endif
13240 +
13241 +#if !defined( __STDC_VERSION__ )
13242 +#define __STDC_VERSION__ 199901L
13243 +#endif
13244 +
13245 +#if !defined( __STDC_VERSION )
13246 +#define __STDC_VERSION __STDC_VERSION__
13247 +#endif
13248 +
13249 +static inline void __vcos_bkpt( void ) { BUG(); }
13250 +#define VCOS_BKPT __vcos_bkpt()
13251 +
13252 +#define VCOS_ASSERT_MSG(...) printk( KERN_ERR "vcos_assert: " __VA_ARGS__ )
13253 +
13254 +#define PRId64 "lld"
13255 +#define PRIi64 "lli"
13256 +#define PRIo64 "llo"
13257 +#define PRIu64 "llu"
13258 +#define PRIx64 "llx"
13259 +
13260 +#endif
13261 --- /dev/null
13262 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_thread_map.c
13263 @@ -0,0 +1,129 @@
13264 +/*****************************************************************************
13265 +* Copyright 2009 - 2010 Broadcom Corporation. All rights reserved.
13266 +*
13267 +* Unless you and Broadcom execute a separate written software license
13268 +* agreement governing use of this software, this software is licensed to you
13269 +* under the terms of the GNU General Public License version 2, available at
13270 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
13271 +*
13272 +* Notwithstanding the above, under no circumstances may you combine this
13273 +* software in any way with any other Broadcom software provided under a
13274 +* license other than the GPL, without Broadcom's express prior written
13275 +* consent.
13276 +*****************************************************************************/
13277 +
13278 +/** Support to allow VCOS thread-related functions to be called from
13279 + * threads that were not created by VCOS.
13280 + */
13281 +
13282 +#include <linux/semaphore.h>
13283 +#include <linux/vmalloc.h>
13284 +#include <linux/list.h>
13285 +#include <linux/sched.h>
13286 +
13287 +#include "vcos_thread_map.h"
13288 +#include "interface/vcos/vcos_logging.h"
13289 +
13290 +/*
13291 + * Store the vcos_thread pointer at the end of
13292 + * current kthread stack, right after the thread_info
13293 + * structure.
13294 + *
13295 + * I belive we should be safe here to steal these 4 bytes
13296 + * from the stack, as long as the vcos thread does not use up
13297 + * all the stack available
13298 + *
13299 + * NOTE: This scheme will not work on architectures with stack growing up
13300 + */
13301 +
13302 +/* Shout, if we are not being compiled for ARM kernel */
13303 +
13304 +#ifndef CONFIG_ARM
13305 +#error " **** The vcos kthread implementation may not work for non-ARM kernel ****"
13306 +#endif
13307 +
13308 +static inline void *to_current_vcos_thread(void)
13309 +{
13310 + unsigned long *vcos_data;
13311 +
13312 + vcos_data = (unsigned long *)((char *)current_thread_info() + sizeof(struct thread_info));
13313 +
13314 + return (void *)vcos_data;
13315 +}
13316 +
13317 +
13318 +static inline void *to_vcos_thread(struct task_struct *tsk)
13319 +{
13320 + unsigned long *vcos_data;
13321 +
13322 + vcos_data = (unsigned long *)((char *)tsk->stack + sizeof(struct thread_info));
13323 +
13324 + return (void *)vcos_data;
13325 +}
13326 +
13327 +/**
13328 + @fn uint32_t vcos_add_thread(THREAD_MAP_T *vcos_thread);
13329 +*/
13330 +uint32_t vcos_add_thread(VCOS_THREAD_T *vcos_thread)
13331 +{
13332 + VCOS_THREAD_T **vcos_thread_storage = (VCOS_THREAD_T **)to_current_vcos_thread();
13333 +
13334 + *vcos_thread_storage = vcos_thread;
13335 +
13336 + return(0);
13337 +}
13338 +
13339 +
13340 +/**
13341 + @fn uint32_t vcos_remove_thread(struct task_struct * thread_id);
13342 +*/
13343 +uint32_t vcos_remove_thread(struct task_struct *thread_id)
13344 +{
13345 + /* Remove thread_id -> VCOS_THREAD_T relationship */
13346 + VCOS_THREAD_T **vcos_thread_storage;
13347 +
13348 + /*
13349 + * We want to be able to build vcos as a loadable module, which
13350 + * means that we can't call get_task_struct. So we assert if we're
13351 + * ever called with thread_id != current.
13352 + */
13353 +
13354 + BUG_ON( thread_id != current );
13355 +
13356 + vcos_thread_storage = (VCOS_THREAD_T **)to_vcos_thread(thread_id);
13357 +
13358 + *(unsigned long *)vcos_thread_storage = 0xCAFEBABE;
13359 +
13360 + return(0);
13361 +}
13362 +
13363 +
13364 +VCOS_THREAD_T *vcos_kthread_current(void)
13365 +{
13366 + VCOS_THREAD_T **vcos_thread_storage = (VCOS_THREAD_T **)to_current_vcos_thread();
13367 +
13368 + /* If we find this, either the thread is already dead or stack pages of a
13369 + * dead vcos thread are re-allocated to this one.
13370 + *
13371 + * Since there's no way to differentiate between these 2 cases, we just dump
13372 + * the current task name to the log.
13373 + *
13374 + * If the current thread is created using VCOS API, you should *never* see this
13375 + * print.
13376 + *
13377 + * If its a non-VCOS thread, just let it go ...
13378 + *
13379 + * To debug VCOS, uncomment printk's under the "if" condition below
13380 + *
13381 + */
13382 + if (*vcos_thread_storage == (void *)0xCAFEBABE)
13383 + {
13384 + #if 0
13385 + printk(KERN_DEBUG"****************************************************\n");
13386 + printk(KERN_DEBUG"%s : You have a problem, if \"%s\" is a VCOS thread\n",__func__, current->comm);
13387 + printk(KERN_DEBUG"****************************************************\n");
13388 + #endif
13389 + }
13390 +
13391 + return *vcos_thread_storage;
13392 +}
13393 --- /dev/null
13394 +++ b/drivers/misc/vc04_services/interface/vcos/linuxkernel/vcos_thread_map.h
13395 @@ -0,0 +1,39 @@
13396 +/*****************************************************************************
13397 +* Copyright 2009 - 2010 Broadcom Corporation. All rights reserved.
13398 +*
13399 +* Unless you and Broadcom execute a separate written software license
13400 +* agreement governing use of this software, this software is licensed to you
13401 +* under the terms of the GNU General Public License version 2, available at
13402 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
13403 +*
13404 +* Notwithstanding the above, under no circumstances may you combine this
13405 +* software in any way with any other Broadcom software provided under a
13406 +* license other than the GPL, without Broadcom's express prior written
13407 +* consent.
13408 +*****************************************************************************/
13409 +
13410 +
13411 +#ifndef VCOS_THREAD_MAP_H
13412 +#define VCOS_THREAD_MAP_H
13413 +
13414 +#include <linux/string.h>
13415 +
13416 +#include "vcos_platform.h"
13417 +
13418 +static inline void vcos_thread_map_init(void)
13419 +{
13420 + return;
13421 +}
13422 +
13423 +static inline void vcos_thread_map_cleanup(void)
13424 +{
13425 + return;
13426 +}
13427 +
13428 +uint32_t vcos_add_thread(VCOS_THREAD_T *vcos_thread);
13429 +
13430 +uint32_t vcos_remove_thread(struct task_struct *thread_id);
13431 +
13432 +VCOS_THREAD_T *vcos_kthread_current(void);
13433 +
13434 +#endif /*VCOS_THREAD_MAP_H */
13435 --- /dev/null
13436 +++ b/drivers/misc/vc04_services/interface/vcos/vcos.h
13437 @@ -0,0 +1,201 @@
13438 +/*=============================================================================
13439 +Copyright (c) 2009 Broadcom Europe Limited.
13440 +All rights reserved.
13441 +
13442 +Project : vcfw
13443 +Module : chip driver
13444 +
13445 +FILE DESCRIPTION
13446 +VideoCore OS Abstraction Layer - public header file
13447 +=============================================================================*/
13448 +
13449 +/**
13450 + * \mainpage OS Abstraction Layer
13451 + *
13452 + * \section intro Introduction
13453 + *
13454 + * This abstraction layer is here to allow the underlying OS to be easily changed (e.g. from
13455 + * Nucleus to ThreadX) and to aid in porting host applications to new targets.
13456 + *
13457 + * \subsection error Error handling
13458 + *
13459 + * Wherever possible, VCOS functions assert internally and return void. The only exceptions
13460 + * are creation functions (which might fail due to lack of resources) and functions that
13461 + * might timeout or fail due to lack of space. Errors that might be reported by the underlying
13462 + * OS API (e.g. invalid mutex) are treated as a programming error, and are merely asserted on.
13463 + *
13464 + * \section thread_synch Threads and synchronisation
13465 + *
13466 + * \subsection thread Threads
13467 + *
13468 + * The thread API is somewhat different to that found in Nucleus. In particular, threads
13469 + * cannot just be destroyed at arbitrary times and nor can they merely exit. This is so
13470 + * that the same API can be implemented across all interesting platforms without too much
13471 + * difficulty. See vcos_thread.h for details. Thread attributes are configured via
13472 + * the VCOS_THREAD_ATTR_T structure, found in vcos_thread_attr.h.
13473 + *
13474 + * \subsection sema Semaphores
13475 + *
13476 + * Counted semaphores (c.f. Nucleus NU_SEMAPHORE) are created with VCOS_SEMAPHORE_T.
13477 + * Under ThreadX on VideoCore, semaphores are implemented using VideoCore spinlocks, and
13478 + * so are quite a lot faster than ordinary ThreadX semaphores. See vcos_semaphore.h.
13479 + *
13480 + * \subsection mtx Mutexes
13481 + *
13482 + * Mutexes are used for locking. Attempts to take a mutex twice, or to unlock it
13483 + * in a different thread to the one in which it was locked should be expected to fail.
13484 + * Mutexes are not re-entrant (see vcos_reentrant_mutex.h for a slightly slower
13485 + * re-entrant mutex).
13486 + *
13487 + * \subsection evflags Event flags
13488 + *
13489 + * Event flags (the ThreadX name - also known as event groups under Nucleus) provide
13490 + * 32 flags which can be waited on by multiple clients, and signalled by multiple clients.
13491 + * A timeout can be specified. See vcos_event_flags.h. An alternative to this is the
13492 + * VCOS_EVENT_T (see vcos_event.h) which is akin to the Win32 auto-reset event, or a
13493 + * saturating counted semaphore.
13494 + *
13495 + * \subsection event Events
13496 + *
13497 + * A VCOS_EVENT_T is a bit like a saturating semaphore. No matter how many times it
13498 + * is signalled, the waiter will only wake up once. See vcos_event.h. You might think this
13499 + * is useful if you suspect that the cost of reading the semaphore count (perhaps via a
13500 + * system call) is expensive on your platform.
13501 + *
13502 + * \subsection tls Thread local storage
13503 + *
13504 + * Thread local storage is supported using vcos_tls.h. This is emulated on Nucleus
13505 + * and ThreadX.
13506 + *
13507 + * \section int Interrupts
13508 + *
13509 + * The legacy LISR/HISR scheme found in Nucleus is supported via the legacy ISR API,
13510 + * which is also supported on ThreadX. New code should avoid this, and old code should
13511 + * be migrated away from it, since it is slow. See vcos_legacy_isr.h.
13512 + *
13513 + * Registering an interrupt handler, and disabling/restoring interrupts, is handled
13514 + * using the functions in vcos_isr.h.
13515 + *
13516 + */
13517 +
13518 +/**
13519 + * \file vcos.h
13520 + *
13521 + * This is the top level header file. Clients include this. It pulls in the platform-specific
13522 + * header file (vcos_platform.h) together with header files defining the expected APIs, such
13523 + * as vcos_mutex.h, vcos_semaphore.h, etc. It is also possible to include these header files
13524 + * directly.
13525 + *
13526 + */
13527 +
13528 +#ifndef VCOS_H
13529 +#define VCOS_H
13530 +
13531 +#include "interface/vcos/vcos_assert.h"
13532 +#include "vcos_types.h"
13533 +#include "vcos_platform.h"
13534 +
13535 +#ifndef VCOS_INIT_H
13536 +#include "interface/vcos/vcos_init.h"
13537 +#endif
13538 +
13539 +#ifndef VCOS_SEMAPHORE_H
13540 +#include "interface/vcos/vcos_semaphore.h"
13541 +#endif
13542 +
13543 +#ifndef VCOS_THREAD_H
13544 +#include "interface/vcos/vcos_thread.h"
13545 +#endif
13546 +
13547 +#ifndef VCOS_MUTEX_H
13548 +#include "interface/vcos/vcos_mutex.h"
13549 +#endif
13550 +
13551 +#ifndef VCOS_MEM_H
13552 +#include "interface/vcos/vcos_mem.h"
13553 +#endif
13554 +
13555 +#ifndef VCOS_LOGGING_H
13556 +#include "interface/vcos/vcos_logging.h"
13557 +#endif
13558 +
13559 +#ifndef VCOS_STRING_H
13560 +#include "interface/vcos/vcos_string.h"
13561 +#endif
13562 +
13563 +#ifndef VCOS_EVENT_H
13564 +#include "interface/vcos/vcos_event.h"
13565 +#endif
13566 +
13567 +#ifndef VCOS_THREAD_ATTR_H
13568 +#include "interface/vcos/vcos_thread_attr.h"
13569 +#endif
13570 +
13571 +#ifndef VCOS_TLS_H
13572 +#include "interface/vcos/vcos_tls.h"
13573 +#endif
13574 +
13575 +#ifndef VCOS_REENTRANT_MUTEX_H
13576 +#include "interface/vcos/vcos_reentrant_mutex.h"
13577 +#endif
13578 +
13579 +#ifndef VCOS_NAMED_SEMAPHORE_H
13580 +#include "interface/vcos/vcos_named_semaphore.h"
13581 +#endif
13582 +
13583 +#ifndef VCOS_QUICKSLOW_MUTEX_H
13584 +#include "interface/vcos/vcos_quickslow_mutex.h"
13585 +#endif
13586 +
13587 +/* Headers with predicates */
13588 +
13589 +#if VCOS_HAVE_EVENT_FLAGS
13590 +#include "interface/vcos/vcos_event_flags.h"
13591 +#endif
13592 +
13593 +#if VCOS_HAVE_QUEUE
13594 +#include "interface/vcos/vcos_queue.h"
13595 +#endif
13596 +
13597 +#if VCOS_HAVE_LEGACY_ISR
13598 +#include "interface/vcos/vcos_legacy_isr.h"
13599 +#endif
13600 +
13601 +#if VCOS_HAVE_TIMER
13602 +#include "interface/vcos/vcos_timer.h"
13603 +#endif
13604 +
13605 +#if VCOS_HAVE_MEMPOOL
13606 +#include "interface/vcos/vcos_mempool.h"
13607 +#endif
13608 +
13609 +#if VCOS_HAVE_ISR
13610 +#include "interface/vcos/vcos_isr.h"
13611 +#endif
13612 +
13613 +#if VCOS_HAVE_ATOMIC_FLAGS
13614 +#include "interface/vcos/vcos_atomic_flags.h"
13615 +#endif
13616 +
13617 +#if VCOS_HAVE_ONCE
13618 +#include "interface/vcos/vcos_once.h"
13619 +#endif
13620 +
13621 +#if VCOS_HAVE_BLOCK_POOL
13622 +#include "interface/vcos/vcos_blockpool.h"
13623 +#endif
13624 +
13625 +#if VCOS_HAVE_FILE
13626 +#include "interface/vcos/vcos_file.h"
13627 +#endif
13628 +
13629 +#if VCOS_HAVE_CFG
13630 +#include "interface/vcos/vcos_cfg.h"
13631 +#endif
13632 +
13633 +#if VCOS_HAVE_CMD
13634 +#include "interface/vcos/vcos_cmd.h"
13635 +#endif
13636 +
13637 +#endif /* VCOS_H */
13638 +
13639 --- /dev/null
13640 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_assert.h
13641 @@ -0,0 +1,269 @@
13642 +/*=============================================================================
13643 +Copyright (c) 2009 Broadcom Europe Limited.
13644 +All rights reserved.
13645 +
13646 +Project : vcfw
13647 +Module : osal
13648 +
13649 +FILE DESCRIPTION
13650 +VideoCore OS Abstraction Layer - Assertion and error-handling macros.
13651 +=============================================================================*/
13652 +
13653 +
13654 +#ifndef VCOS_ASSERT_H
13655 +#define VCOS_ASSERT_H
13656 +
13657 +/*
13658 + * Macro:
13659 + * vcos_assert(cond)
13660 + * vcos_assert_msg(cond, fmt, ...)
13661 + * Use:
13662 + * Detecting programming errors by ensuring that assumptions are correct.
13663 + * On failure:
13664 + * Performs a platform-dependent "breakpoint", usually with an assert-style
13665 + * message. The '_msg' variant expects a printf-style format string and
13666 + * parameters.
13667 + * If a failure is detected, the code should be fixed and rebuilt.
13668 + * In release builds:
13669 + * Generates no code, i.e. does not evaluate 'cond'.
13670 + * Returns:
13671 + * Nothing.
13672 + *
13673 + * Macro:
13674 + * vcos_demand(cond)
13675 + * vcos_demand_msg(cond, fmt, ...)
13676 + * Use:
13677 + * Detecting fatal system errors that require a reboot.
13678 + * On failure:
13679 + * Performs a platform-dependent "breakpoint", usually with an assert-style
13680 + * message, then calls vcos_abort (see below).
13681 + * In release builds:
13682 + * Calls vcos_abort() if 'cond' is false.
13683 + * Returns:
13684 + * Nothing (never, on failure).
13685 + *
13686 + * Macro:
13687 + * vcos_verify(cond)
13688 + * vcos_verify_msg(cond, fmt, ...)
13689 + * Use:
13690 + * Detecting run-time errors and interesting conditions, normally within an
13691 + * 'if' statement to catch the failures, i.e.
13692 + * if (!vcos_verify(cond)) handle_error();
13693 + * On failure:
13694 + * Generates a message and optionally stops at a platform-dependent
13695 + * "breakpoint" (usually disabled). See vcos_verify_bkpts_enable below.
13696 + * In release builds:
13697 + * Just evaluates and returns 'cond'.
13698 + * Returns:
13699 + * Non-zero if 'cond' is true, otherwise zero.
13700 + *
13701 + * Macro:
13702 + * vcos_static_assert(cond)
13703 + * Use:
13704 + * Detecting compile-time errors.
13705 + * On failure:
13706 + * Generates a compiler error.
13707 + * In release builds:
13708 + * Generates a compiler error.
13709 + *
13710 + * Function:
13711 + * void vcos_abort(void)
13712 + * Use:
13713 + * Invokes the fatal error handling mechanism, alerting the host where
13714 + * applicable.
13715 + * Returns:
13716 + * Never.
13717 + *
13718 + * Macro:
13719 + * VCOS_VERIFY_BKPTS
13720 + * Use:
13721 + * Define in a module (before including vcos.h) to specify an alternative
13722 + * flag to control breakpoints on vcos_verify() failures.
13723 + * Returns:
13724 + * Non-zero values enable breakpoints.
13725 + *
13726 + * Function:
13727 + * int vcos_verify_bkpts_enable(int enable);
13728 + * Use:
13729 + * Sets the global flag controlling breakpoints on vcos_verify failures,
13730 + * enabling the breakpoints iff 'enable' is non-zero.
13731 + * Returns:
13732 + * The previous state of the flag.
13733 + *
13734 + * Function:
13735 + * int vcos_verify_bkpts_enabled(void);
13736 + * Use:
13737 + * Queries the state of the global flag enabling breakpoints on vcos_verify
13738 + * failures.
13739 + * Returns:
13740 + * The current state of the flag.
13741 + *
13742 + * Examples:
13743 + *
13744 + * int my_breakpoint_enable_flag = 1;
13745 + *
13746 + * #define VCOS_VERIFY_BKPTS my_breakpoint_enable_flag
13747 + *
13748 + * #include "interface/vcos/vcos.h"
13749 + *
13750 + * vcos_static_assert((sizeof(object) % 32) == 0);
13751 + *
13752 + * // ...
13753 + *
13754 + * vcos_assert_msg(postcondition_is_true, "Coding error");
13755 + *
13756 + * if (!vcos_verify_msg(buf, "Buffer allocation failed (%d bytes)", size))
13757 + * {
13758 + * // Tidy up
13759 + * // ...
13760 + * return OUT_OF_MEMORY;
13761 + * }
13762 + *
13763 + * vcos_demand(*p++==GUARDWORDHEAP);
13764 + */
13765 +
13766 +#ifdef __cplusplus
13767 +extern "C" {
13768 +#endif
13769 +
13770 +#include "interface/vcos/vcos_types.h"
13771 +
13772 +#ifdef __COVERITY__
13773 +#undef VCOS_ASSERT_BKPT
13774 +#define VCOS_ASSERT_BKPT __coverity_panic__()
13775 +#endif
13776 +
13777 +#ifndef VCOS_VERIFY_BKPTS
13778 +#define VCOS_VERIFY_BKPTS vcos_verify_bkpts_enabled()
13779 +#endif
13780 +
13781 +#ifndef VCOS_BKPT
13782 +#if defined(__VIDEOCORE__) && !defined(VCOS_ASSERT_NO_BKPTS)
13783 +#define VCOS_BKPT _bkpt()
13784 +#else
13785 +#define VCOS_BKPT (void )0
13786 +#endif
13787 +#endif
13788 +
13789 +#ifndef VCOS_ASSERT_BKPT
13790 +#define VCOS_ASSERT_BKPT VCOS_BKPT
13791 +#endif
13792 +
13793 +#ifndef VCOS_VERIFY_BKPT
13794 +#define VCOS_VERIFY_BKPT (VCOS_VERIFY_BKPTS ? VCOS_BKPT : (void)0)
13795 +#endif
13796 +
13797 +VCOSPRE_ int VCOSPOST_ vcos_verify_bkpts_enabled(void);
13798 +VCOSPRE_ int VCOSPOST_ vcos_verify_bkpts_enable(int enable);
13799 +VCOSPRE_ void VCOSPOST_ vcos_abort(void);
13800 +
13801 +#ifndef VCOS_ASSERT_MSG
13802 +#ifdef LOGGING
13803 +extern void logging_assert(const char *file, const char *func, int line, const char *format, ...);
13804 +#define VCOS_ASSERT_MSG(...) ((VCOS_ASSERT_LOGGING && !VCOS_ASSERT_LOGGING_DISABLE) ? logging_assert(__FILE__, __func__, __LINE__, __VA_ARGS__) : (void)0)
13805 +#else
13806 +#define VCOS_ASSERT_MSG(...) ((void)0)
13807 +#endif
13808 +#endif
13809 +
13810 +#ifndef VCOS_VERIFY_MSG
13811 +#define VCOS_VERIFY_MSG(...) VCOS_ASSERT_MSG(__VA_ARGS__)
13812 +#endif
13813 +
13814 +#ifndef VCOS_ASSERT_LOGGING
13815 +#define VCOS_ASSERT_LOGGING 0
13816 +#endif
13817 +
13818 +#ifndef VCOS_ASSERT_LOGGING_DISABLE
13819 +#define VCOS_ASSERT_LOGGING_DISABLE 0
13820 +#endif
13821 +
13822 +#if !defined(NDEBUG) || defined(VCOS_RELEASE_ASSERTS)
13823 +
13824 +#ifndef vcos_assert
13825 +#define vcos_assert(cond) \
13826 + ( (cond) ? (void)0 : (VCOS_ASSERT_MSG("%s", #cond), VCOS_ASSERT_BKPT) )
13827 +#endif
13828 +
13829 +#ifndef vcos_assert_msg
13830 +#define vcos_assert_msg(cond, ...) \
13831 + ( (cond) ? (void)0 : (VCOS_ASSERT_MSG(__VA_ARGS__), VCOS_ASSERT_BKPT) )
13832 +#endif
13833 +
13834 +#else /* !defined(NDEBUG) || defined(VCOS_RELEASE_ASSERTS) */
13835 +
13836 +#ifndef vcos_assert
13837 +#define vcos_assert(cond) (void)0
13838 +#endif
13839 +
13840 +#ifndef vcos_assert_msg
13841 +#define vcos_assert_msg(cond, ...) (void)0
13842 +#endif
13843 +
13844 +#endif /* !defined(NDEBUG) || defined(VCOS_RELEASE_ASSERTS) */
13845 +
13846 +#if !defined(NDEBUG)
13847 +
13848 +#ifndef vcos_demand
13849 +#define vcos_demand(cond) \
13850 + ( (cond) ? (void)0 : (VCOS_ASSERT_MSG("%s", #cond), VCOS_ASSERT_BKPT, vcos_abort()) )
13851 +#endif
13852 +
13853 +#ifndef vcos_demand_msg
13854 +#define vcos_demand_msg(cond, ...) \
13855 + ( (cond) ? (void)0 : (VCOS_ASSERT_MSG(__VA_ARGS__), VCOS_ASSERT_BKPT, vcos_abort()) )
13856 +#endif
13857 +
13858 +#ifndef vcos_verify
13859 +#define vcos_verify(cond) \
13860 + ( (cond) ? 1 : (VCOS_VERIFY_MSG("%s", #cond), VCOS_VERIFY_BKPT, 0) )
13861 +#endif
13862 +
13863 +#ifndef vcos_verify_msg
13864 +#define vcos_verify_msg(cond, ...) \
13865 + ( (cond) ? 1 : (VCOS_VERIFY_MSG(__VA_ARGS__), VCOS_VERIFY_BKPT, 0) )
13866 +#endif
13867 +
13868 +#else /* !defined(NDEBUG) */
13869 +
13870 +#ifndef vcos_demand
13871 +#define vcos_demand(cond) \
13872 + ( (cond) ? (void)0 : vcos_abort() )
13873 +#endif
13874 +
13875 +#ifndef vcos_demand_msg
13876 +#define vcos_demand_msg(cond, ...) \
13877 + ( (cond) ? (void)0 : vcos_abort() )
13878 +#endif
13879 +
13880 +#ifndef vcos_verify
13881 +#define vcos_verify(cond) (cond)
13882 +#endif
13883 +
13884 +#ifndef vcos_verify_msg
13885 +#define vcos_verify_msg(cond, ...) (cond)
13886 +#endif
13887 +
13888 +#endif /* !defined(NDEBUG) */
13889 +
13890 +#ifndef vcos_static_assert
13891 +#if defined(__GNUC__)
13892 +#define vcos_static_assert(cond) __attribute__((unused)) extern int vcos_static_assert[(cond)?1:-1]
13893 +#else
13894 +#define vcos_static_assert(cond) extern int vcos_static_assert[(cond)?1:-1]
13895 +#endif
13896 +#endif
13897 +
13898 +#ifndef vc_assert
13899 +#define vc_assert(cond) vcos_assert(cond)
13900 +#endif
13901 +
13902 +/** Print out a backtrace, on supported platforms.
13903 + */
13904 +extern void vcos_backtrace_self(void);
13905 +
13906 +#ifdef __cplusplus
13907 +}
13908 +#endif
13909 +
13910 +#endif /* VCOS_ASSERT_H */
13911 --- /dev/null
13912 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_atomic_flags.h
13913 @@ -0,0 +1,72 @@
13914 +/*=============================================================================
13915 +Copyright (c) 2009 Broadcom Europe Limited.
13916 +All rights reserved.
13917 +
13918 +Project : vcfw
13919 +Module : chip driver (just for consistency with the rest of vcos ;)
13920 +
13921 +FILE DESCRIPTION
13922 +VideoCore OS Abstraction Layer - public header file
13923 +=============================================================================*/
13924 +
13925 +#ifndef VCOS_ATOMIC_FLAGS_H
13926 +#define VCOS_ATOMIC_FLAGS_H
13927 +
13928 +#ifdef __cplusplus
13929 +extern "C" {
13930 +#endif
13931 +
13932 +#include "interface/vcos/vcos_types.h"
13933 +#include "vcos_platform.h"
13934 +
13935 +/**
13936 + * \file vcos_atomic_flags.h
13937 + *
13938 + * Defines atomic flags API.
13939 + *
13940 + * 32 flags. Atomic "or" and "get and clear" operations
13941 + */
13942 +
13943 +/**
13944 + * Create an atomic flags instance.
13945 + *
13946 + * @param atomic_flags Pointer to atomic flags instance, filled in on return
13947 + *
13948 + * @return VCOS_SUCCESS if succeeded.
13949 + */
13950 +VCOS_INLINE_DECL
13951 +VCOS_STATUS_T vcos_atomic_flags_create(VCOS_ATOMIC_FLAGS_T *atomic_flags);
13952 +
13953 +/**
13954 + * Atomically set the specified flags.
13955 + *
13956 + * @param atomic_flags Instance to set flags on
13957 + * @param flags Mask of flags to set
13958 + */
13959 +VCOS_INLINE_DECL
13960 +void vcos_atomic_flags_or(VCOS_ATOMIC_FLAGS_T *atomic_flags, uint32_t flags);
13961 +
13962 +/**
13963 + * Retrieve the current flags and then clear them. The entire operation is
13964 + * atomic.
13965 + *
13966 + * @param atomic_flags Instance to get/clear flags from/on
13967 + *
13968 + * @return Mask of flags which were set (and we cleared)
13969 + */
13970 +VCOS_INLINE_DECL
13971 +uint32_t vcos_atomic_flags_get_and_clear(VCOS_ATOMIC_FLAGS_T *atomic_flags);
13972 +
13973 +/**
13974 + * Delete an atomic flags instance.
13975 + *
13976 + * @param atomic_flags Instance to delete
13977 + */
13978 +VCOS_INLINE_DECL
13979 +void vcos_atomic_flags_delete(VCOS_ATOMIC_FLAGS_T *atomic_flags);
13980 +
13981 +#ifdef __cplusplus
13982 +}
13983 +#endif
13984 +
13985 +#endif
13986 --- /dev/null
13987 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_build_info.h
13988 @@ -0,0 +1,5 @@
13989 +const char *vcos_get_build_hostname( void );
13990 +const char *vcos_get_build_version( void );
13991 +const char *vcos_get_build_time( void );
13992 +const char *vcos_get_build_date( void );
13993 +
13994 --- /dev/null
13995 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_cfg.h
13996 @@ -0,0 +1,113 @@
13997 +/*****************************************************************************
13998 +* Copyright 2009 - 2011 Broadcom Corporation. All rights reserved.
13999 +*
14000 +* Unless you and Broadcom execute a separate written software license
14001 +* agreement governing use of this software, this software is licensed to you
14002 +* under the terms of the GNU General Public License version 2, available at
14003 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
14004 +*
14005 +* Notwithstanding the above, under no circumstances may you combine this
14006 +* software in any way with any other Broadcom software provided under a
14007 +* license other than the GPL, without Broadcom's express prior written
14008 +* consent.
14009 +*****************************************************************************/
14010 +
14011 +#if !defined( VCOS_CFG_H )
14012 +#define VCOS_CFG_H
14013 +
14014 +#ifdef __cplusplus
14015 +extern "C" {
14016 +#endif
14017 +
14018 +#include "interface/vcos/vcos_types.h"
14019 +#include "vcos_platform.h"
14020 +
14021 +typedef struct opaque_vcos_cfg_buf_t *VCOS_CFG_BUF_T;
14022 +typedef struct opaque_vcos_cfg_entry_t *VCOS_CFG_ENTRY_T;
14023 +
14024 +/** \file vcos_file.h
14025 + *
14026 + * API for accessing configuration/statistics information. This
14027 + * is loosely modelled on the linux proc entries.
14028 + */
14029 +
14030 +typedef void (*VCOS_CFG_SHOW_FPTR)( VCOS_CFG_BUF_T buf, void *data );
14031 +typedef void (*VCOS_CFG_PARSE_FPTR)( VCOS_CFG_BUF_T buf, void *data );
14032 +
14033 +/** Create a configuration directory.
14034 + *
14035 + * @param entry Place to store the created config entry.
14036 + * @param parent Parent entry (for directory like config
14037 + * options).
14038 + * @param entryName Name of the directory.
14039 + */
14040 +
14041 +VCOS_STATUS_T vcos_cfg_mkdir( VCOS_CFG_ENTRY_T *entry,
14042 + VCOS_CFG_ENTRY_T *parent,
14043 + const char *dirName );
14044 +
14045 +/** Create a configuration entry.
14046 + *
14047 + * @param entry Place to store the created config entry.
14048 + * @param parent Parent entry (for directory like config
14049 + * options).
14050 + * @param entryName Name of the configuration entry.
14051 + * @param showFunc Function pointer to show configuration
14052 + * data.
14053 + * @param parseFunc Function pointer to parse new data.
14054 + */
14055 +
14056 +VCOS_STATUS_T vcos_cfg_create_entry( VCOS_CFG_ENTRY_T *entry,
14057 + VCOS_CFG_ENTRY_T *parent,
14058 + const char *entryName,
14059 + VCOS_CFG_SHOW_FPTR showFunc,
14060 + VCOS_CFG_PARSE_FPTR parseFunc,
14061 + void *data );
14062 +
14063 +/** Determines if a configuration entry has been created or not.
14064 + *
14065 + * @param entry Configuration entry to query.
14066 + */
14067 +
14068 +int vcos_cfg_is_entry_created( VCOS_CFG_ENTRY_T entry );
14069 +
14070 +/** Returns the name of a configuration entry.
14071 + *
14072 + * @param entry Configuration entry to query.
14073 + */
14074 +
14075 +const char *vcos_cfg_get_entry_name( VCOS_CFG_ENTRY_T entry );
14076 +
14077 +/** Removes a configuration entry.
14078 + *
14079 + * @param entry Configuration entry to remove.
14080 + */
14081 +
14082 +VCOS_STATUS_T vcos_cfg_remove_entry( VCOS_CFG_ENTRY_T *entry );
14083 +
14084 +
14085 +/** Writes data into a configuration buffer. Only valid inside
14086 + * the show function.
14087 + *
14088 + * @param buf Buffer to write data into.
14089 + * @param fmt printf style format string.
14090 + */
14091 +
14092 +void vcos_cfg_buf_printf( VCOS_CFG_BUF_T buf, const char *fmt, ... );
14093 +
14094 +/** Retrieves a null terminated string of the data associated
14095 + * with the buffer. Only valid inside the parse function.
14096 + *
14097 + * @param buf Buffer to get data from.
14098 + * @param fmt printf style format string.
14099 + */
14100 +
14101 +char *vcos_cfg_buf_get_str( VCOS_CFG_BUF_T buf );
14102 +
14103 +void *vcos_cfg_get_proc_entry( VCOS_CFG_ENTRY_T entry );
14104 +
14105 +#ifdef __cplusplus
14106 +}
14107 +#endif
14108 +#endif
14109 +
14110 --- /dev/null
14111 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_cmd.h
14112 @@ -0,0 +1,98 @@
14113 +/*****************************************************************************
14114 +* Copyright 2009 - 2011 Broadcom Corporation. All rights reserved.
14115 +*
14116 +* Unless you and Broadcom execute a separate written software license
14117 +* agreement governing use of this software, this software is licensed to you
14118 +* under the terms of the GNU General Public License version 2, available at
14119 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
14120 +*
14121 +* Notwithstanding the above, under no circumstances may you combine this
14122 +* software in any way with any other Broadcom software provided under a
14123 +* license other than the GPL, without Broadcom's express prior written
14124 +* consent.
14125 +*****************************************************************************/
14126 +
14127 +#if !defined( VCOS_CMD_H )
14128 +#define VCOS_CMD_H
14129 +
14130 +/* ---- Include Files ----------------------------------------------------- */
14131 +
14132 +#include "interface/vcos/vcos.h"
14133 +#include "interface/vcos/vcos_stdint.h"
14134 +
14135 +
14136 +/* ---- Constants and Types ---------------------------------------------- */
14137 +
14138 +struct VCOS_CMD_S;
14139 +typedef struct VCOS_CMD_S VCOS_CMD_T;
14140 +
14141 +typedef struct
14142 +{
14143 + int argc; /* Number of arguments (includes the command/sub-command) */
14144 + char **argv; /* Array of arguments */
14145 + char **argv_orig; /* Original array of arguments */
14146 +
14147 + VCOS_CMD_T *cmd_entry;
14148 + VCOS_CMD_T *cmd_parent_entry;
14149 +
14150 + int use_log; /* Output being logged? */
14151 + size_t result_size; /* Size of result buffer. */
14152 + char *result_ptr; /* Next place to put output. */
14153 + char *result_buf; /* Start of the buffer. */
14154 +
14155 +} VCOS_CMD_PARAM_T;
14156 +
14157 +typedef VCOS_STATUS_T (*VCOS_CMD_FUNC_T)( VCOS_CMD_PARAM_T *param );
14158 +
14159 +struct VCOS_CMD_S
14160 +{
14161 + const char *name;
14162 + const char *args;
14163 + VCOS_CMD_FUNC_T cmd_fn;
14164 + VCOS_CMD_T *sub_cmd_entry;
14165 + const char *descr;
14166 +
14167 +};
14168 +
14169 +/* ---- Variable Externs ------------------------------------------------- */
14170 +
14171 +/* ---- Function Prototypes ---------------------------------------------- */
14172 +
14173 +/*
14174 + * Common printing routine for generating command output.
14175 + */
14176 +VCOSPRE_ void VCOSPOST_ vcos_cmd_error( VCOS_CMD_PARAM_T *param, const char *fmt, ... ) VCOS_FORMAT_ATTR_(printf, 2, 3);
14177 +VCOSPRE_ void VCOSPOST_ vcos_cmd_printf( VCOS_CMD_PARAM_T *param, const char *fmt, ... ) VCOS_FORMAT_ATTR_(printf, 2, 3);
14178 +VCOSPRE_ void VCOSPOST_ vcos_cmd_vprintf( VCOS_CMD_PARAM_T *param, const char *fmt, va_list args ) VCOS_FORMAT_ATTR_(printf, 2, 0);
14179 +
14180 +/*
14181 + * Cause vcos_cmd_error, printf and vprintf to always log to the provided
14182 + * category. When this call is made, the results buffer passed into
14183 + * vcos_cmd_execute is used as a line buffer and does not need to be
14184 + * output by the caller.
14185 + */
14186 +VCOSPRE_ void VCOSPOST_ vcos_cmd_always_log_output( VCOS_LOG_CAT_T *log_category );
14187 +
14188 +/*
14189 + * Prints command usage for the current command.
14190 + */
14191 +VCOSPRE_ void VCOSPOST_ vcos_cmd_usage( VCOS_CMD_PARAM_T *param );
14192 +
14193 +/*
14194 + * Register commands to be processed
14195 + */
14196 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_cmd_register( VCOS_CMD_T *cmd_entry );
14197 +
14198 +/*
14199 + * Registers multiple commands to be processed. The array should
14200 + * be terminated by an entry with all zeros.
14201 + */
14202 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_cmd_register_multiple( VCOS_CMD_T *cmd_entry );
14203 +
14204 +/*
14205 + * Executes a command based on a command line.
14206 + */
14207 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_cmd_execute( int argc, char **argv, size_t result_size, char *result_buf );
14208 +
14209 +#endif /* VCOS_CMD_H */
14210 +
14211 --- /dev/null
14212 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_ctype.h
14213 @@ -0,0 +1,29 @@
14214 +/*=============================================================================
14215 +Copyright (c) 2009 Broadcom Europe Limited.
14216 +All rights reserved.
14217 +
14218 +Project : vcfw
14219 +Module : chip driver
14220 +
14221 +FILE DESCRIPTION
14222 +VideoCore OS Abstraction Layer - public header file
14223 +=============================================================================*/
14224 +
14225 +#ifndef VCOS_CTYPE_H
14226 +#define VCOS_CTYPE_H
14227 +
14228 +/**
14229 + * \file
14230 + *
14231 + * ctype functions.
14232 + *
14233 + */
14234 +
14235 +#ifdef __KERNEL__
14236 +#include <linux/ctype.h>
14237 +#else
14238 +#include <ctype.h>
14239 +#endif
14240 +
14241 +#endif
14242 +
14243 --- /dev/null
14244 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_dlfcn.h
14245 @@ -0,0 +1,69 @@
14246 +/*=============================================================================
14247 +Copyright (c) 2010 Broadcom Europe Limited.
14248 +All rights reserved.
14249 +
14250 +Project : vcfw
14251 +Module : chip driver
14252 +
14253 +FILE DESCRIPTION
14254 +VCOS - abstraction over dynamic library opening
14255 +=============================================================================*/
14256 +
14257 +#ifndef VCOS_DLFCN_H
14258 +#define VCOS_DLFCN_H
14259 +
14260 +#include "interface/vcos/vcos_types.h"
14261 +#include "vcos_platform.h"
14262 +
14263 +#ifdef __cplusplus
14264 +extern "C" {
14265 +#endif
14266 +
14267 +#define VCOS_DL_LAZY 1
14268 +#define VCOS_DL_NOW 2
14269 +
14270 +/**
14271 + * \file
14272 + *
14273 + * Loading dynamic libraries. See also dlfcn.h.
14274 + */
14275 +
14276 +/** Open a dynamic library.
14277 + *
14278 + * @param name name of the library
14279 + * @param mode Load lazily or immediately (VCOS_DL_LAZY, VCOS_DL_NOW).
14280 + *
14281 + * @return A handle for use in subsequent calls.
14282 + */
14283 +VCOSPRE_ void * VCOSPOST_ vcos_dlopen(const char *name, int mode);
14284 +
14285 +/** Look up a symbol.
14286 + *
14287 + * @param handle Handle to open
14288 + * @param name Name of function
14289 + *
14290 + * @return Function pointer, or NULL.
14291 + */
14292 +VCOSPRE_ void VCOSPOST_ (*vcos_dlsym(void *handle, const char *name))(void);
14293 +
14294 +/** Close a library
14295 + *
14296 + * @param handle Handle to close
14297 + */
14298 +VCOSPRE_ int VCOSPOST_ vcos_dlclose (void *handle);
14299 +
14300 +/** Return error message from library.
14301 + *
14302 + * @param err On return, set to non-zero if an error has occurred
14303 + * @param buf Buffer to write error to
14304 + * @param len Size of buffer (including terminating NUL).
14305 + */
14306 +VCOSPRE_ int VCOSPOST_ vcos_dlerror(int *err, char *buf, size_t buflen);
14307 +
14308 +
14309 +#ifdef __cplusplus
14310 +}
14311 +#endif
14312 +#endif
14313 +
14314 +
14315 --- /dev/null
14316 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_event.h
14317 @@ -0,0 +1,97 @@
14318 +/*=============================================================================
14319 +Copyright (c) 2009 Broadcom Europe Limited.
14320 +All rights reserved.
14321 +
14322 +Project : vcfw
14323 +Module : chip driver
14324 +
14325 +FILE DESCRIPTION
14326 +VideoCore OS Abstraction Layer - public header file for events
14327 +=============================================================================*/
14328 +
14329 +#ifndef VCOS_EVENT_H
14330 +#define VCOS_EVENT_H
14331 +
14332 +#ifdef __cplusplus
14333 +extern "C" {
14334 +#endif
14335 +
14336 +#include "interface/vcos/vcos_types.h"
14337 +#include "vcos_platform.h"
14338 +
14339 +/**
14340 + * \file
14341 + *
14342 + * An event is akin to the Win32 auto-reset event.
14343 + *
14344 + *
14345 + * Signalling an event will wake up one waiting thread only. Once one
14346 + * thread has been woken the event atomically returns to the unsignalled
14347 + * state.
14348 + *
14349 + * If no threads are waiting on the event when it is signalled it remains
14350 + * signalled.
14351 + *
14352 + * This is almost, but not quite, completely unlike the "event flags"
14353 + * object based on Nucleus event groups and ThreadX event flags.
14354 + *
14355 + * In particular, it should be similar in speed to a semaphore, unlike
14356 + * the event flags.
14357 + */
14358 +
14359 +/**
14360 + * Create an event instance.
14361 + *
14362 + * @param event Filled in with constructed event.
14363 + * @param name Name of the event (for debugging)
14364 + *
14365 + * @return VCOS_SUCCESS on success, or error code.
14366 + */
14367 +VCOS_INLINE_DECL
14368 +VCOS_STATUS_T vcos_event_create(VCOS_EVENT_T *event, const char *name);
14369 +
14370 +#ifndef vcos_event_signal
14371 +
14372 +/**
14373 + * Signal the event. The event will return to being unsignalled
14374 + * after exactly one waiting thread has been woken up. If no
14375 + * threads are waiting it remains signalled.
14376 + *
14377 + * @param event The event to signal
14378 + */
14379 +VCOS_INLINE_DECL
14380 +void vcos_event_signal(VCOS_EVENT_T *event);
14381 +
14382 +/**
14383 + * Wait for the event.
14384 + *
14385 + * @param event The event to wait for
14386 + * @return VCOS_SUCCESS on success, VCOS_EAGAIN if the wait was interrupted.
14387 + */
14388 +VCOS_INLINE_DECL
14389 +VCOS_STATUS_T vcos_event_wait(VCOS_EVENT_T *event);
14390 +
14391 +/**
14392 + * Try event, but don't block.
14393 + *
14394 + * @param event The event to try
14395 + * @return VCOS_SUCCESS on success, VCOS_EAGAIN if the event is not currently signalled
14396 + */
14397 +VCOS_INLINE_DECL
14398 +VCOS_STATUS_T vcos_event_try(VCOS_EVENT_T *event);
14399 +
14400 +#endif
14401 +
14402 +/*
14403 + * Destroy an event.
14404 + */
14405 +VCOS_INLINE_DECL
14406 +void vcos_event_delete(VCOS_EVENT_T *event);
14407 +
14408 +#ifdef __cplusplus
14409 +}
14410 +#endif
14411 +
14412 +#endif
14413 +
14414 +
14415 --- /dev/null
14416 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_event_flags.h
14417 @@ -0,0 +1,98 @@
14418 +/*=============================================================================
14419 +Copyright (c) 2009 Broadcom Europe Limited.
14420 +All rights reserved.
14421 +
14422 +Project : vcfw
14423 +Module : chip driver
14424 +
14425 +FILE DESCRIPTION
14426 +VideoCore OS Abstraction Layer - public header file
14427 +=============================================================================*/
14428 +
14429 +#ifndef VCOS_EVENT_FLAGS_H
14430 +#define VCOS_EVENT_FLAGS_H
14431 +
14432 +
14433 +#ifdef __cplusplus
14434 +extern "C" {
14435 +#endif
14436 +
14437 +#include "interface/vcos/vcos_types.h"
14438 +#include "vcos_platform.h"
14439 +
14440 +#define VCOS_EVENT_FLAGS_SUSPEND VCOS_SUSPEND
14441 +#define VCOS_EVENT_FLAGS_NO_SUSPEND VCOS_NO_SUSPEND
14442 +typedef VCOS_OPTION VCOS_EVENTGROUP_OPERATION_T;
14443 +
14444 +/**
14445 + * \file vcos_event_flags.h
14446 + *
14447 + * Defines event flags API.
14448 + *
14449 + * Similar to Nucleus event groups.
14450 + *
14451 + * These have the same semantics as Nucleus event groups and ThreadX event
14452 + * flags. As such, they are quite complex internally; if speed is important
14453 + * they might not be your best choice.
14454 + *
14455 + */
14456 +
14457 +/**
14458 + * Create an event flags instance.
14459 + *
14460 + * @param flags Pointer to event flags instance, filled in on return.
14461 + * @param name Name for the event flags, used for debug.
14462 + *
14463 + * @return VCOS_SUCCESS if succeeded.
14464 + */
14465 +
14466 +VCOS_INLINE_DECL
14467 +VCOS_STATUS_T vcos_event_flags_create(VCOS_EVENT_FLAGS_T *flags, const char *name);
14468 +
14469 +/**
14470 + * Set some events.
14471 + *
14472 + * @param flags Instance to set flags on
14473 + * @param events Bitmask of the flags to actually set
14474 + * @param op How the flags should be set. VCOS_OR will OR in the flags; VCOS_AND
14475 + * will AND them in, possibly clearing existing flags.
14476 + */
14477 +VCOS_INLINE_DECL
14478 +void vcos_event_flags_set(VCOS_EVENT_FLAGS_T *flags,
14479 + VCOS_UNSIGNED events,
14480 + VCOS_OPTION op);
14481 +
14482 +/**
14483 + * Retrieve some events.
14484 + *
14485 + * Waits until the specified events have been set.
14486 + *
14487 + * @param flags Instance to wait on
14488 + * @param requested_events The bitmask to wait for
14489 + * @param op VCOS_OR - get any; VCOS_AND - get all.
14490 + * @param ms_suspend How long to wait, in milliseconds
14491 + * @param retrieved_events the events actually retrieved.
14492 + *
14493 + * @return VCOS_SUCCESS if events were retrieved. VCOS_EAGAIN if the
14494 + * timeout expired.
14495 + */
14496 +VCOS_INLINE_DECL
14497 +VCOS_STATUS_T vcos_event_flags_get(VCOS_EVENT_FLAGS_T *flags,
14498 + VCOS_UNSIGNED requested_events,
14499 + VCOS_OPTION op,
14500 + VCOS_UNSIGNED ms_suspend,
14501 + VCOS_UNSIGNED *retrieved_events);
14502 +
14503 +
14504 +/**
14505 + * Delete an event flags instance.
14506 + */
14507 +VCOS_INLINE_DECL
14508 +void vcos_event_flags_delete(VCOS_EVENT_FLAGS_T *);
14509 +
14510 +#ifdef __cplusplus
14511 +}
14512 +#endif
14513 +
14514 +#endif
14515 +
14516 --- /dev/null
14517 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_init.h
14518 @@ -0,0 +1,43 @@
14519 +/*=============================================================================
14520 +Copyright (c) 2009 Broadcom Europe Limited.
14521 +All rights reserved.
14522 +
14523 +Project : vcfw
14524 +Module : chip driver
14525 +
14526 +FILE DESCRIPTION
14527 +VideoCore OS Abstraction Layer - initialization routines
14528 +=============================================================================*/
14529 +
14530 +
14531 +#include "interface/vcos/vcos_types.h"
14532 +#include "vcos_platform.h"
14533 +
14534 +#ifdef __cplusplus
14535 +extern "C" {
14536 +#endif
14537 +
14538 +/** \file
14539 + *
14540 + * Some OS support libraries need some initialization. To support this, call this
14541 + * function at the start of day.
14542 + */
14543 +
14544 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_init(void);
14545 +VCOSPRE_ void VCOSPOST_ vcos_deinit(void);
14546 +VCOSPRE_ void VCOSPOST_ vcos_global_lock(void);
14547 +VCOSPRE_ void VCOSPOST_ vcos_global_unlock(void);
14548 +
14549 +/** Pass in the argv/argc arguments passed to main() */
14550 +VCOSPRE_ void VCOSPOST_ vcos_set_args(int argc, const char **argv);
14551 +
14552 +/** Return argc. */
14553 +VCOSPRE_ int VCOSPOST_ vcos_get_argc(void);
14554 +
14555 +/** Return argv. */
14556 +VCOSPRE_ const char ** VCOSPOST_ vcos_get_argv(void);
14557 +
14558 +#ifdef __cplusplus
14559 +}
14560 +#endif
14561 +
14562 --- /dev/null
14563 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_logging.h
14564 @@ -0,0 +1,279 @@
14565 +/*=============================================================================
14566 +Copyright (c) 2009-2011 Broadcom Europe Limited.
14567 +All rights reserved.
14568 +
14569 +Project : vcfw
14570 +Module : chip driver
14571 +
14572 +FILE DESCRIPTION
14573 +VideoCore OS Abstraction Layer - logging support
14574 +=============================================================================*/
14575 +
14576 +#ifndef VCOS_LOGGING_H
14577 +#define VCOS_LOGGING_H
14578 +
14579 +#ifdef __cplusplus
14580 +extern "C" {
14581 +#endif
14582 +
14583 +#include <stdarg.h>
14584 +
14585 +#include "interface/vcos/vcos_types.h"
14586 +#include "vcos_platform.h"
14587 +
14588 +/**
14589 + * \file
14590 + *
14591 + * Logging support
14592 + *
14593 + * This provides categorised logging. Clients register
14594 + * a category, and then get a number of logging levels for
14595 + * that category.
14596 + *
14597 + * The logging level flag is tested using a flag *before* the
14598 + * function call, which makes logging very fast when disabled - there
14599 + * is no function call overhead just to find out that this log
14600 + * message is disabled.
14601 + *
14602 + * \section VCOS_LOG_CATEGORY
14603 + *
14604 + * As a convenience, clients define VCOS_LOG_CATEGORY to point to
14605 + * their category; the various vcos_log_xxx() macros then expand to
14606 + * use this.
14607 + *
14608 + * e.g.
14609 + *
14610 + * #define VCOS_LOG_CATEGORY (&my_category)
14611 + *
14612 + * #include <interface/vcos/vcos.h>
14613 + *
14614 + * VCOS_LOG_CAT_T my_category;
14615 + *
14616 + * ....
14617 + *
14618 + * vcos_log_trace("Stuff happened: %d", n_stuff);
14619 + *
14620 + */
14621 +
14622 +/** Logging levels */
14623 +typedef enum VCOS_LOG_LEVEL_T
14624 +{
14625 + VCOS_LOG_UNINITIALIZED = 0,
14626 + VCOS_LOG_NEVER,
14627 + VCOS_LOG_ERROR,
14628 + VCOS_LOG_WARN,
14629 + VCOS_LOG_INFO,
14630 + VCOS_LOG_TRACE,
14631 +} VCOS_LOG_LEVEL_T;
14632 +
14633 +
14634 +/** Initialize a logging category without going through vcos_log_register().
14635 + *
14636 + * This is useful for the case where there is no obvious point to do the
14637 + * registration (no initialization function for the module). However, it
14638 + * means that your logging category is not registered, so cannot be easily
14639 + * changed at run-time.
14640 + */
14641 +#define VCOS_LOG_INIT(n,l) { l, n, 0, {0}, 0, 0 }
14642 +
14643 +/** A registered logging category.
14644 + */
14645 +typedef struct VCOS_LOG_CAT_T
14646 +{
14647 + VCOS_LOG_LEVEL_T level; /** Which levels are enabled for this category */
14648 + const char *name; /** Name for this category. */
14649 + struct VCOS_LOG_CAT_T *next;
14650 + struct {
14651 + unsigned int want_prefix:1;
14652 + } flags;
14653 + unsigned int refcount;
14654 + void *platform_data; /** platform specific data */
14655 +} VCOS_LOG_CAT_T;
14656 +
14657 +typedef void (*VCOS_VLOG_IMPL_FUNC_T)(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, va_list args);
14658 +
14659 +/** Convert a VCOS_LOG_LEVEL_T into a printable string.
14660 + * The platform needs to implement this function.
14661 + */
14662 +VCOSPRE_ const char * VCOSPOST_ vcos_log_level_to_string( VCOS_LOG_LEVEL_T level );
14663 +
14664 +/** Convert a string into a VCOS_LOG_LEVEL_T
14665 + * The platform needs to implement this function.
14666 + */
14667 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_string_to_log_level( const char *str, VCOS_LOG_LEVEL_T *level );
14668 +
14669 +/** Log a message. Basic API. Normal code should not use this.
14670 + * The platform needs to implement this function.
14671 + */
14672 +VCOSPRE_ void VCOSPOST_ vcos_log_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, ...) VCOS_FORMAT_ATTR_(printf, 3, 4);
14673 +
14674 +/** Log a message using a varargs parameter list. Normal code should
14675 + * not use this.
14676 + */
14677 +VCOSPRE_ void VCOSPOST_ vcos_vlog_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, va_list args) VCOS_FORMAT_ATTR_(printf, 3, 0);
14678 +
14679 +/** Set the function which does the actual logging output.
14680 + * Passing in NULL causes the default logging function to be
14681 + * used.
14682 + */
14683 +VCOSPRE_ void VCOSPOST_ vcos_set_vlog_impl( VCOS_VLOG_IMPL_FUNC_T vlog_impl_func );
14684 +
14685 +/** The default logging function, which is provided by each
14686 + * platform.
14687 + */
14688 +
14689 +VCOSPRE_ void VCOSPOST_ vcos_vlog_default_impl(const VCOS_LOG_CAT_T *cat, VCOS_LOG_LEVEL_T _level, const char *fmt, va_list args) VCOS_FORMAT_ATTR_(printf, 3, 0);
14690 +
14691 +/*
14692 + * Initialise the logging subsystem. This is called from
14693 + * vcos_init() so you don't normally need to call it.
14694 + */
14695 +VCOSPRE_ void VCOSPOST_ vcos_logging_init(void);
14696 +
14697 +/** Register a logging category.
14698 + *
14699 + * @param name the name of this category.
14700 + * @param category the category to register.
14701 + */
14702 +VCOSPRE_ void VCOSPOST_ vcos_log_register(const char *name, VCOS_LOG_CAT_T *category);
14703 +
14704 +/** Unregister a logging category.
14705 + */
14706 +VCOSPRE_ void VCOSPOST_ vcos_log_unregister(VCOS_LOG_CAT_T *category);
14707 +
14708 +/** Return a default logging category, for people too lazy to create their own.
14709 + *
14710 + * Using the default category will be slow (there's an extra function
14711 + * call overhead). Don't do this in normal code.
14712 + */
14713 +VCOSPRE_ const VCOS_LOG_CAT_T * VCOSPOST_ vcos_log_get_default_category(void);
14714 +
14715 +VCOSPRE_ void VCOSPOST_ vcos_set_log_options(const char *opt);
14716 +
14717 +/** Set the logging level for a category at run time. Without this, the level
14718 + * will be that set by vcos_log_register from a platform-specific source.
14719 + *
14720 + * @param category the category to modify.
14721 + * @param level the new logging level for this category.
14722 + */
14723 +VCOS_STATIC_INLINE void vcos_log_set_level(VCOS_LOG_CAT_T *category, VCOS_LOG_LEVEL_T level)
14724 +{
14725 + category->level = level;
14726 +}
14727 +
14728 +#define vcos_log_dump_mem(cat,label,addr,voidMem,numBytes) do { if (vcos_is_log_enabled(cat,VCOS_LOG_TRACE)) vcos_log_dump_mem_impl(cat,label,addr,voidMem,numBytes); } while (0)
14729 +
14730 +void vcos_log_dump_mem_impl( const VCOS_LOG_CAT_T *cat,
14731 + const char *label,
14732 + uint32_t addr,
14733 + const void *voidMem,
14734 + size_t numBytes );
14735 +
14736 +/*
14737 + * Platform specific hooks (optional).
14738 + */
14739 +#ifndef vcos_log_platform_init
14740 +#define vcos_log_platform_init() (void)0
14741 +#endif
14742 +
14743 +#ifndef vcos_log_platform_register
14744 +#define vcos_log_platform_register(category) (void)0
14745 +#endif
14746 +
14747 +#ifndef vcos_log_platform_unregister
14748 +#define vcos_log_platform_unregister(category) (void)0
14749 +#endif
14750 +
14751 +/* VCOS_TRACE() - deprecated macro which just outputs in a debug build and
14752 + * is a no-op in a release build.
14753 + *
14754 + * _VCOS_LOG_X() - internal macro which outputs if the current level for the
14755 + * particular category is higher than the supplied message level.
14756 + */
14757 +
14758 +#define VCOS_LOG_DFLT_CATEGORY vcos_log_get_default_category()
14759 +
14760 +#define _VCOS_LEVEL(x) (x)
14761 +
14762 +#define vcos_is_log_enabled(cat,_level) (_VCOS_LEVEL((cat)->level) >= _VCOS_LEVEL(_level))
14763 +
14764 +#if defined(_VCOS_METAWARE) || defined(__GNUC__)
14765 +
14766 +# if !defined(NDEBUG) || defined(VCOS_ALWAYS_WANT_LOGGING)
14767 +# define VCOS_LOGGING_ENABLED
14768 +# define _VCOS_LOG_X(cat, _level, fmt...) do { if (vcos_is_log_enabled(cat,_level)) vcos_log_impl(cat,_level,fmt); } while (0)
14769 +# define _VCOS_VLOG_X(cat, _level, fmt, ap) do { if (vcos_is_log_enabled(cat,_level)) vcos_vlog_impl(cat,_level,fmt,ap); } while (0)
14770 +# else
14771 +# define _VCOS_LOG_X(cat, _level, fmt...) (void)0
14772 +# define _VCOS_VLOG_X(cat, _level, fmt, ap) (void)0
14773 +# endif
14774 +
14775 +
14776 +
14777 +# define vcos_log_error(...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_ERROR, __VA_ARGS__)
14778 +# define vcos_log_warn(...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_WARN, __VA_ARGS__)
14779 +# define vcos_log_info(...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_INFO, __VA_ARGS__)
14780 +# define vcos_log_trace(...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE, __VA_ARGS__)
14781 +
14782 +# define vcos_vlog_error(fmt,ap) _VCOS_VLOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_ERROR, fmt, ap)
14783 +# define vcos_vlog_warn(fmt,ap) _VCOS_VLOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_WARN, fmt, ap)
14784 +# define vcos_vlog_info(fmt,ap) _VCOS_VLOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_INFO, fmt, ap)
14785 +# define vcos_vlog_trace(fmt,ap) _VCOS_VLOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE, fmt, ap)
14786 +
14787 +# define vcos_log(...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_INFO, __VA_ARGS__)
14788 +# define vcos_vlog(fmt,ap) _VCOS_VLOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_INFO, fmt, ap)
14789 +# define VCOS_ALERT(...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_ERROR, __VA_ARGS__)
14790 +# define VCOS_TRACE(...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_INFO, __VA_ARGS__)
14791 +
14792 +/*
14793 + * MS Visual Studio - pre 2005 does not grok variadic macros
14794 + */
14795 +#elif defined(_MSC_VER)
14796 +
14797 +# if _MSC_VER >= 1400
14798 +
14799 +# if !defined(NDEBUG) || defined(VCOS_ALWAYS_WANT_LOGGING)
14800 +# define VCOS_LOGGING_ENABLED
14801 +# define _VCOS_LOG_X(cat, _level, fmt,...) do { if (vcos_is_log_enabled(cat,_level)) vcos_log_impl(cat, _level, fmt, __VA_ARGS__); } while (0)
14802 +# else
14803 +# define _VCOS_LOG_X(cat, _level, fmt,...) (void)0
14804 +# endif
14805 +
14806 +# define vcos_log_error(fmt,...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_ERROR, fmt, __VA_ARGS__)
14807 +# define vcos_log_warn(fmt,...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_WARN, fmt, __VA_ARGS__)
14808 +# define vcos_log_info(fmt,...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_INFO, fmt, __VA_ARGS__)
14809 +# define vcos_log_trace(fmt,...) _VCOS_LOG_X(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE, fmt, __VA_ARGS__)
14810 +
14811 +# define vcos_log(fmt,...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_INFO, fmt)
14812 +# define VCOS_ALERT(fmt,...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_ERROR, fmt)
14813 +# define VCOS_TRACE(fmt,...) _VCOS_LOG_X(VCOS_LOG_DFLT_CATEGORY, VCOS_LOG_INFO, fmt)
14814 +
14815 +# else /* _MSC_VER >= 1400 */
14816 +
14817 +/* do not define these */
14818 +
14819 +# endif /* _MSC_VER >= 1400 */
14820 +
14821 +#endif
14822 +
14823 +#if VCOS_HAVE_CMD
14824 +
14825 +#include "interface/vcos/vcos_cmd.h"
14826 +
14827 +/*
14828 + * These are the log sub-commands. They're exported here for user-mode apps which
14829 + * may want to call these, since the "log" command isn't registered for user-mode
14830 + * apps (vcdbg for example, has its own log command).
14831 + */
14832 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_log_assert_cmd( VCOS_CMD_PARAM_T *param );
14833 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_log_set_cmd( VCOS_CMD_PARAM_T *param );
14834 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_log_status_cmd( VCOS_CMD_PARAM_T *param );
14835 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_log_test_cmd( VCOS_CMD_PARAM_T *param );
14836 +#endif
14837 +
14838 +#ifdef __cplusplus
14839 +}
14840 +#endif
14841 +#endif /* VCOS_LOGGING_H */
14842 +
14843 +
14844 --- /dev/null
14845 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_lowlevel_thread.h
14846 @@ -0,0 +1,107 @@
14847 +/*=============================================================================
14848 +Copyright (c) 2009 Broadcom Europe Limited.
14849 +All rights reserved.
14850 +
14851 +Project : vcfw
14852 +Module : chip driver
14853 +
14854 +FILE DESCRIPTION
14855 +VideoCore OS Abstraction Layer - low level thread support
14856 +=============================================================================*/
14857 +
14858 +#ifndef VCOS_LOWLEVEL_THREAD_H
14859 +#define VCOS_LOWLEVEL_THREAD_H
14860 +
14861 +#ifdef __cplusplus
14862 +extern "C" {
14863 +#endif
14864 +
14865 +#include "interface/vcos/vcos_types.h"
14866 +#include "vcos_platform.h"
14867 +
14868 +/**
14869 + * \file
14870 + *
14871 + * This defines a low level thread API that is supported by *some* operating systems
14872 + * and can be used to construct the regular "joinable thread" API on those operating
14873 + * systems.
14874 + *
14875 + * Most clients will not need to use this code.
14876 + *
14877 + * \sa vcos_joinable_thread.h
14878 + */
14879 +
14880 +/**
14881 + * \brief Create a thread.
14882 + *
14883 + * This creates a thread which can be stopped either by returning from the
14884 + * entry point function or by calling vcos_llthread_exit from within the entry
14885 + * point function. The thread must be cleaned up by calling
14886 + * vcos_llthread_delete. vcos_llthread_delete may or may not terminate the
14887 + * thread.
14888 + *
14889 + * The preemptible parameter familiar from Nucleus is removed, as it is unused in
14890 + * VideoCore code. Affinity is added, since we do use this.
14891 + *
14892 + * @param thread Filled in with thread instance
14893 + * @param name An optional name for the thread. "" may be used (but
14894 + * a name will aid in debugging).
14895 + * @param entry Entry point
14896 + * @param arg A single argument passed to the entry point function
14897 + * @param stack Pointer to stack address
14898 + * @param stacksz Size of stack in bytes
14899 + * @param priority Priority of task, between VCOS_PRI_LOW and VCOS_PRI_HIGH
14900 + * @param affinity CPU affinity
14901 + *
14902 + * @sa vcos_llthread_terminate vcos_llthread_delete
14903 + */
14904 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_llthread_create(VCOS_LLTHREAD_T *thread,
14905 + const char *name,
14906 + VCOS_LLTHREAD_ENTRY_FN_T entry,
14907 + void *arg,
14908 + void *stack,
14909 + VCOS_UNSIGNED stacksz,
14910 + VCOS_UNSIGNED priority,
14911 + VCOS_UNSIGNED affinity,
14912 + VCOS_UNSIGNED timeslice,
14913 + VCOS_UNSIGNED autostart);
14914 +
14915 +/**
14916 + * \brief Exits the current thread.
14917 + */
14918 +VCOSPRE_ void VCOSPOST_ vcos_llthread_exit(void);
14919 +
14920 +/**
14921 + * \brief Delete a thread. This must be called to cleanup after
14922 + * vcos_llthread_create. This may or may not terminate the thread.
14923 + * It does not clean up any resources that may have been
14924 + * allocated by the thread.
14925 + */
14926 +VCOSPRE_ void VCOSPOST_ vcos_llthread_delete(VCOS_LLTHREAD_T *thread);
14927 +
14928 +/**
14929 + * \brief Return current lowlevel thread pointer.
14930 + */
14931 +VCOS_INLINE_DECL
14932 +VCOS_LLTHREAD_T *vcos_llthread_current(void);
14933 +
14934 +/**
14935 + * Resume a thread.
14936 + */
14937 +VCOS_INLINE_DECL
14938 +void vcos_llthread_resume(VCOS_LLTHREAD_T *thread);
14939 +
14940 +VCOSPRE_ int VCOSPOST_ vcos_llthread_running(VCOS_LLTHREAD_T *thread);
14941 +
14942 +/**
14943 + * \brief Create a VCOS_LLTHREAD_T for the current thread. This is so we can
14944 + * have VCOS_LLTHREAD_Ts even for threads not originally created by VCOS (eg
14945 + * the thread that calls vcos_init).
14946 + */
14947 +extern VCOS_STATUS_T _vcos_llthread_create_attach(VCOS_LLTHREAD_T *thread);
14948 +
14949 +#ifdef __cplusplus
14950 +}
14951 +#endif
14952 +#endif
14953 +
14954 --- /dev/null
14955 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_mem.h
14956 @@ -0,0 +1,81 @@
14957 +/*=============================================================================
14958 +Copyright (c) 2009 Broadcom Europe Limited.
14959 +All rights reserved.
14960 +
14961 +Project : vcfw
14962 +Module : chip driver
14963 +
14964 +FILE DESCRIPTION
14965 +VideoCore OS Abstraction Layer - memory support
14966 +=============================================================================*/
14967 +
14968 +#ifndef VCOS_MEM_H
14969 +#define VCOS_MEM_H
14970 +
14971 +#ifdef __cplusplus
14972 +extern "C" {
14973 +#endif
14974 +
14975 +#include "interface/vcos/vcos_types.h"
14976 +#include "vcos_platform.h"
14977 +
14978 +/** \file
14979 + *
14980 + * Memory allocation api (malloc/free equivalents) is for benefit of host
14981 + * applications. VideoCore code should use rtos_XXX functions.
14982 + *
14983 + */
14984 +
14985 +
14986 +/** Allocate memory
14987 + *
14988 + * @param size Size of memory to allocate
14989 + * @param description Description, to aid in debugging. May be ignored internally on some platforms.
14990 + */
14991 +VCOS_INLINE_DECL
14992 +void *vcos_malloc(VCOS_UNSIGNED size, const char *description);
14993 +
14994 +void *vcos_kmalloc(VCOS_UNSIGNED size, const char *description);
14995 +void *vcos_kcalloc(VCOS_UNSIGNED num, VCOS_UNSIGNED size, const char *description);
14996 +
14997 +/** Allocate cleared memory
14998 + *
14999 + * @param num Number of items to allocate.
15000 + * @param size Size of each item in bytes.
15001 + * @param description Description, to aid in debugging. May be ignored internally on some platforms.
15002 + */
15003 +VCOS_INLINE_DECL
15004 +void *vcos_calloc(VCOS_UNSIGNED num, VCOS_UNSIGNED size, const char *description);
15005 +
15006 +/** Free memory
15007 + *
15008 + * Free memory that has been allocated.
15009 + */
15010 +VCOS_INLINE_DECL
15011 +void vcos_free(void *ptr);
15012 +
15013 +void vcos_kfree(void *ptr);
15014 +
15015 +/** Allocate aligned memory
15016 + *
15017 + * Allocate memory aligned on the specified boundary.
15018 + *
15019 + * @param size Size of memory to allocate
15020 + * @param description Description, to aid in debugging. May be ignored internally on some platforms.
15021 + */
15022 +VCOS_INLINE_DECL
15023 +void *vcos_malloc_aligned(VCOS_UNSIGNED size, VCOS_UNSIGNED align, const char *description);
15024 +
15025 +/** Return the amount of free heap memory
15026 + *
15027 + */
15028 +VCOS_INLINE_DECL
15029 +unsigned long vcos_get_free_mem(void);
15030 +
15031 +#ifdef __cplusplus
15032 +}
15033 +#endif
15034 +
15035 +#endif
15036 +
15037 +
15038 --- /dev/null
15039 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_msgqueue.h
15040 @@ -0,0 +1,157 @@
15041 +/*=============================================================================
15042 +Copyright (c) 2009 Broadcom Europe Limited.
15043 +All rights reserved.
15044 +
15045 +Project : vcfw
15046 +Module : chip driver
15047 +
15048 +FILE DESCRIPTION
15049 +VCOS - packet-like messages, based loosely on those found in TRIPOS.
15050 +=============================================================================*/
15051 +
15052 +#ifndef VCOS_MSGQUEUE_H
15053 +#define VCOS_MSGQUEUE_H
15054 +
15055 +#ifdef __cplusplus
15056 +extern "C" {
15057 +#endif
15058 +
15059 +#include "interface/vcos/vcos_types.h"
15060 +#include "vcos_platform.h"
15061 +
15062 +/**
15063 + * \file
15064 + *
15065 + * Packet-like messages, based loosely on those found in TRIPOS and
15066 + * derivatives thereof.
15067 + *
15068 + * A task can send a message *pointer* to another task, where it is
15069 + * queued on a linked list and the task woken up. The receiving task
15070 + * consumes all of the messages on its input queue, and optionally
15071 + * sends back replies using the original message memory.
15072 + *
15073 + * A caller can wait for the reply to a specific message - any other
15074 + * messages that arrive in the meantime are queued separately.
15075 + *
15076 + *
15077 + * All messages have a standard common layout, but the payload area can
15078 + * be used freely to extend this.
15079 + */
15080 +
15081 +/** Map the payload portion of a message to a structure pointer.
15082 + */
15083 +#define VCOS_MSG_DATA(_msg) (void*)((_msg)->data)
15084 +
15085 +/** Standard message ids - FIXME - these need to be done properly! */
15086 +#define VCOS_MSG_N_QUIT 1
15087 +#define VCOS_MSG_N_OPEN 2
15088 +#define VCOS_MSG_N_CLOSE 3
15089 +#define VCOS_MSG_N_PRIVATE (1<<20)
15090 +
15091 +#define VCOS_MSG_REPLY_BIT (1<<31)
15092 +
15093 +/** Make gnuc compiler be happy about pointer punning */
15094 +#ifdef __GNUC__
15095 +#define __VCOS_MAY_ALIAS __attribute__((__may_alias__))
15096 +#else
15097 +#define __VCOS_MAY_ALIAS
15098 +#endif
15099 +
15100 +/** A single message queue.
15101 + */
15102 +typedef struct VCOS_MSGQUEUE_T
15103 +{
15104 + struct VCOS_MSG_T *head; /**< head of linked list of messages waiting on this queue */
15105 + struct VCOS_MSG_T *tail; /**< tail of message queue */
15106 + VCOS_SEMAPHORE_T sem; /**< thread waits on this for new messages */
15107 + VCOS_MUTEX_T lock; /**< locks the messages list */
15108 +} VCOS_MSGQUEUE_T;
15109 +
15110 +/** A single message
15111 + */
15112 +typedef struct VCOS_MSG_T
15113 +{
15114 + uint32_t code; /**< message code */
15115 + int error; /**< error status signalled back to caller */
15116 + VCOS_MSGQUEUE_T *dst; /**< destination queue */
15117 + VCOS_MSGQUEUE_T *src; /**< source; replies go back to here */
15118 + struct VCOS_MSG_T *next; /**< next in queue */
15119 + VCOS_THREAD_T *src_thread; /**< for debug */
15120 + uint32_t data[25]; /**< payload area */
15121 +} VCOS_MSG_T;
15122 +
15123 +/** An endpoint
15124 + */
15125 +typedef struct VCOS_MSG_ENDPOINT_T
15126 +{
15127 + VCOS_MSGQUEUE_T primary; /**< incoming messages */
15128 + VCOS_MSGQUEUE_T secondary; /**< this is used for waitspecific */
15129 + char name[32]; /**< name of this endpoint, for find() */
15130 + struct VCOS_MSG_ENDPOINT_T *next; /**< next in global list of endpoints */
15131 +} VCOS_MSG_ENDPOINT_T;
15132 +#define MSG_REPLY_BIT (1<<31)
15133 +
15134 +/** Initalise the library. Normally called from vcos_init().
15135 + */
15136 +extern VCOS_STATUS_T vcos_msgq_init(void);
15137 +
15138 +/** Find a message queue by name and get a handle to it.
15139 + *
15140 + * @param name the name of the queue to find
15141 + *
15142 + * @return The message queue, or NULL if not found.
15143 + */
15144 +VCOSPRE_ VCOS_MSGQUEUE_T VCOSPOST_ *vcos_msgq_find(const char *name);
15145 +
15146 +/** Wait for a message queue to come into existence. If it already exists,
15147 + * return immediately, otherwise block.
15148 + *
15149 + * On the whole, if you find yourself using this, it is probably a sign
15150 + * of poor design, since you should create all the server threads first,
15151 + * and then the client threads. But it is sometimes useful.
15152 + *
15153 + * @param name the name of the queue to find
15154 + * @return The message queue
15155 + */
15156 +VCOSPRE_ VCOS_MSGQUEUE_T VCOSPOST_ *vcos_msgq_wait(const char *name);
15157 +
15158 +/** Send a message.
15159 + */
15160 +VCOSPRE_ void VCOSPOST_ vcos_msg_send(VCOS_MSGQUEUE_T *dest, uint32_t code, VCOS_MSG_T *msg);
15161 +
15162 +/** Send a message and wait for a reply.
15163 + */
15164 +VCOSPRE_ void VCOSPOST_ vcos_msg_sendwait(VCOS_MSGQUEUE_T *queue, uint32_t code, VCOS_MSG_T *msg);
15165 +
15166 +/** Wait for a message on this thread's endpoint.
15167 + */
15168 +VCOSPRE_ VCOS_MSG_T * VCOSPOST_ vcos_msg_wait(void);
15169 +
15170 +/** Wait for a specific message.
15171 + */
15172 +VCOS_MSG_T * vcos_msg_wait_specific(VCOS_MSGQUEUE_T *queue, VCOS_MSG_T *msg);
15173 +
15174 +/** Peek for a message on this thread's endpoint, if a message is not available, NULL is
15175 + returned. If a message is available it will be removed from the endpoint and returned.
15176 + */
15177 +VCOSPRE_ VCOS_MSG_T * VCOSPOST_ vcos_msg_peek(void);
15178 +
15179 +/** Send a reply to a message
15180 + */
15181 +VCOSPRE_ void VCOSPOST_ vcos_msg_reply(VCOS_MSG_T *msg);
15182 +
15183 +/** Create an endpoint. Each thread should need no more than one of these - if you
15184 + * find yourself needing a second one, you've done something wrong.
15185 + */
15186 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_msgq_endpoint_create(VCOS_MSG_ENDPOINT_T *ep, const char *name);
15187 +
15188 +/** Destroy an endpoint.
15189 + */
15190 +VCOSPRE_ void VCOSPOST_ vcos_msgq_endpoint_delete(VCOS_MSG_ENDPOINT_T *ep);
15191 +
15192 +#ifdef __cplusplus
15193 +}
15194 +#endif
15195 +#endif
15196 +
15197 +
15198 --- /dev/null
15199 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_mutex.h
15200 @@ -0,0 +1,92 @@
15201 +/*=============================================================================
15202 +Copyright (c) 2009 Broadcom Europe Limited.
15203 +All rights reserved.
15204 +
15205 +Project : vcfw
15206 +Module : chip driver
15207 +
15208 +FILE DESCRIPTION
15209 +VideoCore OS Abstraction Layer - mutex public header file
15210 +=============================================================================*/
15211 +
15212 +#ifndef VCOS_MUTEX_H
15213 +#define VCOS_MUTEX_H
15214 +
15215 +#ifdef __cplusplus
15216 +extern "C" {
15217 +#endif
15218 +
15219 +#include "interface/vcos/vcos_types.h"
15220 +#include "vcos_platform.h"
15221 +
15222 +/**
15223 + * \file vcos_mutex.h
15224 + *
15225 + * Mutex API. Mutexes are not re-entrant, as supporting this adds extra code
15226 + * that slows down clients which have been written sensibly.
15227 + *
15228 + * \sa vcos_reentrant_mutex.h
15229 + *
15230 + */
15231 +
15232 +/** Create a mutex.
15233 + *
15234 + * @param m Filled in with mutex on return
15235 + * @param name A non-null name for the mutex, used for diagnostics.
15236 + *
15237 + * @return VCOS_SUCCESS if mutex was created, or error code.
15238 + */
15239 +VCOS_INLINE_DECL
15240 +VCOS_STATUS_T vcos_mutex_create(VCOS_MUTEX_T *m, const char *name);
15241 +
15242 +/** Delete the mutex.
15243 + */
15244 +VCOS_INLINE_DECL
15245 +void vcos_mutex_delete(VCOS_MUTEX_T *m);
15246 +
15247 +/**
15248 + * \brief Wait to claim the mutex.
15249 + *
15250 + * On most platforms this always returns VCOS_SUCCESS, and so would ideally be
15251 + * a void function, however some platforms allow a wait to be interrupted so
15252 + * it remains non-void.
15253 + *
15254 + * Try to obtain the mutex.
15255 + * @param m Mutex to wait on
15256 + * @return VCOS_SUCCESS - mutex was taken.
15257 + * VCOS_EAGAIN - could not take mutex.
15258 + */
15259 +#ifndef vcos_mutex_lock
15260 +VCOS_INLINE_DECL
15261 +VCOS_STATUS_T vcos_mutex_lock(VCOS_MUTEX_T *m);
15262 +
15263 +/** Release the mutex.
15264 + */
15265 +VCOS_INLINE_DECL
15266 +void vcos_mutex_unlock(VCOS_MUTEX_T *m);
15267 +#endif
15268 +
15269 +/** Test if the mutex is already locked.
15270 + *
15271 + * @return 1 if mutex is locked, 0 if it is unlocked.
15272 + */
15273 +VCOS_INLINE_DECL
15274 +int vcos_mutex_is_locked(VCOS_MUTEX_T *m);
15275 +
15276 +/** Obtain the mutex if possible.
15277 + *
15278 + * @param m the mutex to try to obtain
15279 + *
15280 + * @return VCOS_SUCCESS if mutex is succesfully obtained, or VCOS_EAGAIN
15281 + * if it is already in use by another thread.
15282 + */
15283 +#ifndef vcos_mutex_trylock
15284 +VCOS_INLINE_DECL
15285 +VCOS_STATUS_T vcos_mutex_trylock(VCOS_MUTEX_T *m);
15286 +#endif
15287 +
15288 +
15289 +#ifdef __cplusplus
15290 +}
15291 +#endif
15292 +#endif
15293 --- /dev/null
15294 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_once.h
15295 @@ -0,0 +1,42 @@
15296 +/*=============================================================================
15297 +Copyright (c) 2011 Broadcom Europe Limited.
15298 +All rights reserved.
15299 +
15300 +Project : vcfw
15301 +Module : chip driver
15302 +
15303 +FILE DESCRIPTION
15304 +VideoCore OS Abstraction Layer - 'once'
15305 +=============================================================================*/
15306 +
15307 +#ifndef VCOS_ONCE_H
15308 +#define VCOS_ONCE_H
15309 +
15310 +#ifdef __cplusplus
15311 +extern "C" {
15312 +#endif
15313 +
15314 +#include "interface/vcos/vcos_types.h"
15315 +#include "vcos_platform.h"
15316 +
15317 +/**
15318 + * \file vcos_once.h
15319 + *
15320 + * Ensure something is called only once.
15321 + *
15322 + * Initialize once_control to VCOS_ONCE_INIT. The first
15323 + * time this is called, the init_routine will be called. Thereafter
15324 + * it won't.
15325 + *
15326 + * \sa pthread_once()
15327 + *
15328 + */
15329 +
15330 +VCOS_STATUS_T vcos_once(VCOS_ONCE_T *once_control,
15331 + void (*init_routine)(void));
15332 +
15333 +#ifdef __cplusplus
15334 +}
15335 +#endif
15336 +#endif
15337 +
15338 --- /dev/null
15339 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_semaphore.h
15340 @@ -0,0 +1,115 @@
15341 +/*=============================================================================
15342 +Copyright (c) 2009 Broadcom Europe Limited.
15343 +All rights reserved.
15344 +
15345 +Project : vcfw
15346 +Module : chip driver
15347 +
15348 +FILE DESCRIPTION
15349 +VideoCore OS Abstraction Layer - public header file
15350 +=============================================================================*/
15351 +
15352 +#ifndef VCOS_SEMAPHORE_H
15353 +#define VCOS_SEMAPHORE_H
15354 +
15355 +#ifdef __cplusplus
15356 +extern "C" {
15357 +#endif
15358 +
15359 +#include "interface/vcos/vcos_types.h"
15360 +#include "vcos_platform.h"
15361 +
15362 +/**
15363 + * \file vcos_semaphore.h
15364 + *
15365 + * \section sem Semaphores
15366 + *
15367 + * This provides counting semaphores. Semaphores are not re-entrant. On sensible
15368 + * operating systems a semaphore can always be posted but can only be taken in
15369 + * thread (not interrupt) context. Under Nucleus, a LISR cannot post a semaphore,
15370 + * although it would not be hard to lift this restriction.
15371 + *
15372 + * \subsection timeout Timeout
15373 + *
15374 + * On both Nucleus and ThreadX a semaphore can be taken with a timeout. This is
15375 + * not supported by VCOS because it makes the non-timeout code considerably more
15376 + * complicated (and hence slower). In the unlikely event that you need a timeout
15377 + * with a semaphore, and you cannot simply redesign your code to avoid it, use
15378 + * an event flag (vcos_event_flags.h).
15379 + *
15380 + * \subsection sem_nucleus Changes from Nucleus:
15381 + *
15382 + * Semaphores are always "FIFO" - i.e. sleeping threads are woken in FIFO order. That's
15383 + * because:
15384 + * \arg there's no support for NU_PRIORITY in threadx (though it can be emulated, slowly)
15385 + * \arg we don't appear to actually consciously use it - for example, Dispmanx uses
15386 + * it, but all threads waiting are the same priority.
15387 + *
15388 + */
15389 +
15390 +/**
15391 + * \brief Create a semaphore.
15392 + *
15393 + * Create a semaphore.
15394 + *
15395 + * @param sem Pointer to memory to be initialized
15396 + * @param name A name for this semaphore. The name may be truncated internally.
15397 + * @param count The initial count for the semaphore.
15398 + *
15399 + * @return VCOS_SUCCESS if the semaphore was created.
15400 + *
15401 + */
15402 +VCOS_INLINE_DECL
15403 +VCOS_STATUS_T vcos_semaphore_create(VCOS_SEMAPHORE_T *sem, const char *name, VCOS_UNSIGNED count);
15404 +
15405 +/**
15406 + * \brief Wait on a semaphore.
15407 + *
15408 + * There is no timeout option on a semaphore, as adding this will slow down
15409 + * implementations on some platforms. If you need that kind of behaviour, use
15410 + * an event group.
15411 + *
15412 + * On most platforms this always returns VCOS_SUCCESS, and so would ideally be
15413 + * a void function, however some platforms allow a wait to be interrupted so
15414 + * it remains non-void.
15415 + *
15416 + * @param sem Semaphore to wait on
15417 + * @return VCOS_SUCCESS - semaphore was taken.
15418 + * VCOS_EAGAIN - could not take semaphore
15419 + *
15420 + */
15421 +VCOS_INLINE_DECL
15422 +VCOS_STATUS_T vcos_semaphore_wait(VCOS_SEMAPHORE_T *sem);
15423 +
15424 +/**
15425 + * \brief Try to wait for a semaphore.
15426 + *
15427 + * Try to obtain the semaphore. If it is already taken, return VCOS_TIMEOUT.
15428 + * @param sem Semaphore to wait on
15429 + * @return VCOS_SUCCESS - semaphore was taken.
15430 + * VCOS_EAGAIN - could not take semaphore
15431 + */
15432 +VCOS_INLINE_DECL
15433 +VCOS_STATUS_T vcos_semaphore_trywait(VCOS_SEMAPHORE_T *sem);
15434 +
15435 +/**
15436 + * \brief Post a semaphore.
15437 + *
15438 + * @param sem Semaphore to wait on
15439 + */
15440 +VCOS_INLINE_DECL
15441 +VCOS_STATUS_T vcos_semaphore_post(VCOS_SEMAPHORE_T *sem);
15442 +
15443 +/**
15444 + * \brief Delete a semaphore, releasing any resources consumed by it.
15445 + *
15446 + * @param sem Semaphore to wait on
15447 + */
15448 +VCOS_INLINE_DECL
15449 +void vcos_semaphore_delete(VCOS_SEMAPHORE_T *sem);
15450 +
15451 +#ifdef __cplusplus
15452 +}
15453 +#endif
15454 +#endif
15455 +
15456 --- /dev/null
15457 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_stdbool.h
15458 @@ -0,0 +1,17 @@
15459 +#ifndef VCOS_STDBOOL_H
15460 +#define VCOS_STDBOOL_H
15461 +
15462 +#ifndef __cplusplus
15463 +
15464 +#if defined(__STDC__) && (__STDC_VERSION__ >= 199901L)
15465 +#include <stdbool.h>
15466 +#else
15467 +typedef enum {
15468 + false,
15469 + true
15470 +} bool;
15471 +#endif
15472 +
15473 +#endif /* __cplusplus */
15474 +
15475 +#endif
15476 --- /dev/null
15477 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_stdint.h
15478 @@ -0,0 +1,193 @@
15479 +/*=============================================================================
15480 +Copyright (c) 2011 Broadcom Europe Limited.
15481 +All rights reserved.
15482 +
15483 +FILE DESCRIPTION
15484 +
15485 +=============================================================================*/
15486 +
15487 +#ifndef VCOS_STDINT_H
15488 +#define VCOS_STDINT_H
15489 +
15490 +/* Attempt to provide the types defined in stdint.h.
15491 + *
15492 + * Ideally this would either call out to a platform-specific
15493 + * header file (e.g. stdint.h) or define the types on a
15494 + * per-architecture/compiler basis. But for now we just
15495 + * use #ifdefs.
15496 + */
15497 +
15498 +#ifdef __cplusplus
15499 +extern "C" {
15500 +#endif
15501 +
15502 +#ifdef __SYMBIAN32__
15503 +
15504 +typedef signed char int8_t;
15505 +typedef unsigned char uint8_t;
15506 +
15507 +typedef signed short int16_t;
15508 +typedef unsigned short uint16_t;
15509 +
15510 +typedef int16_t int_least16_t;
15511 +
15512 +typedef signed long int32_t;
15513 +typedef unsigned long uint32_t;
15514 +
15515 +typedef signed long long int64_t;
15516 +typedef unsigned long long uint64_t;
15517 +
15518 +typedef int32_t intptr_t;
15519 +typedef uint32_t uintptr_t;
15520 +
15521 +typedef int64_t intmax_t;
15522 +typedef uint64_t uintmax_t;
15523 +
15524 +#define INT8_MIN SCHAR_MIN
15525 +#define INT8_MAX SCHAR_MAX
15526 +#define UINT8_MAX UCHAR_MAX
15527 +#define INT16_MIN SHRT_MIN
15528 +#define INT16_MAX SHRT_MAX
15529 +#define UINT16_MAX USHRT_MAX
15530 +#define INT32_MIN LONG_MIN
15531 +#define INT32_MAX LONG_MAX
15532 +#define UINT32_MAX ULONG_MAX
15533 +#define INT64_MIN LLONG_MIN
15534 +#define INT64_MAX LLONG_MAX
15535 +#define UINT64_MAX ULLONG_MAX
15536 +
15537 +#define INTPTR_MIN INT32_MIN
15538 +#define INTPTR_MAX INT32_MAX
15539 +#define UINTPTR_MAX UINT32_MAX
15540 +#define INTMAX_MIN INT64_MIN
15541 +#define INTMAX_MAX INT64_MAX
15542 +#define INT_LEAST16_MAX INT16_MAX
15543 +#define INT_LEAST16_MAX INT16_MAX
15544 +
15545 +/*{{{ C99 types - THIS WHOLE SECTION IS INCOMPATIBLE WITH C99. IT SHOULD RESIDE IN A STDINT.H SINCE THIS FILE GETS USED ON HOST SIDE */
15546 +
15547 +#elif defined( __STDC__ ) && __STDC_VERSION__ >= 199901L
15548 +
15549 +#include <stdint.h>
15550 +
15551 +#elif defined( __GNUC__ )
15552 +
15553 +#include <stdint.h>
15554 +
15555 +#elif defined(_MSC_VER) /* Visual C define equivalent types */
15556 +
15557 +#include <stddef.h> /* Avoids intptr_t being defined in vadefs.h */
15558 +
15559 +typedef __int8 int8_t;
15560 +typedef unsigned __int8 uint8_t;
15561 +
15562 +typedef __int16 int16_t;
15563 +typedef unsigned __int16 uint16_t;
15564 +
15565 +typedef __int32 int32_t;
15566 +typedef unsigned __int32 uint32_t;
15567 +
15568 +typedef __int64 int64_t;
15569 +typedef unsigned __int64 uint64_t;
15570 +typedef uint32_t uintptr_t;
15571 +typedef int64_t intmax_t;
15572 +typedef uint64_t uintmax_t;
15573 +typedef int16_t int_least16_t;
15574 +
15575 +#elif defined (VCMODS_LCC)
15576 +#include <limits.h>
15577 +
15578 +typedef signed char int8_t;
15579 +typedef unsigned char uint8_t;
15580 +
15581 +typedef signed short int16_t;
15582 +typedef unsigned short uint16_t;
15583 +
15584 +typedef signed long int32_t;
15585 +typedef unsigned long uint32_t;
15586 +
15587 +typedef signed long int64_t; /*!!!! PFCD, this means code using 64bit numbers will be broken on the VCE */
15588 +typedef unsigned long uint64_t; /* !!!! PFCD */
15589 +
15590 +typedef int32_t intptr_t;
15591 +typedef uint32_t uintptr_t;
15592 +typedef int64_t intmax_t;
15593 +typedef uint64_t uintmax_t;
15594 +typedef int16_t int_least16_t;
15595 +
15596 +#define INT8_MIN SCHAR_MIN
15597 +#define INT8_MAX SCHAR_MAX
15598 +#define UINT8_MAX UCHAR_MAX
15599 +#define INT16_MIN SHRT_MIN
15600 +#define INT16_MAX SHRT_MAX
15601 +#define UINT16_MAX USHRT_MAX
15602 +#define INT32_MIN LONG_MIN
15603 +#define INT32_MAX LONG_MAX
15604 +#define UINT32_MAX ULONG_MAX
15605 +#define INT64_MIN LONG_MIN /* !!!! PFCD */
15606 +#define INT64_MAX LONG_MAX /* !!!! PFCD */
15607 +#define UINT64_MAX ULONG_MAX /* !!!! PFCD */
15608 +
15609 +#define INTPTR_MIN INT32_MIN
15610 +#define INTPTR_MAX INT32_MAX
15611 +#define UINTPTR_MAX UINT32_MAX
15612 +#define INTMAX_MIN INT64_MIN
15613 +#define INTMAX_MIN INT64_MIN
15614 +#define INT_LEAST16_MAX INT16_MAX
15615 +#define INT_LEAST16_MAX INT16_MAX
15616 +
15617 +#elif defined(__VIDEOCORE__)
15618 +
15619 +typedef signed char int8_t;
15620 +typedef unsigned char uint8_t;
15621 +
15622 +typedef signed short int16_t;
15623 +typedef unsigned short uint16_t;
15624 +
15625 +typedef signed long int32_t;
15626 +typedef unsigned long uint32_t;
15627 +
15628 +typedef signed long long int64_t;
15629 +typedef unsigned long long uint64_t;
15630 +
15631 +typedef int32_t intptr_t;
15632 +typedef uint32_t uintptr_t;
15633 +typedef int64_t intmax_t;
15634 +typedef uint64_t uintmax_t;
15635 +typedef int16_t int_least16_t;
15636 +
15637 +#define INT8_MIN SCHAR_MIN
15638 +#define INT8_MAX SCHAR_MAX
15639 +#define UINT8_MAX UCHAR_MAX
15640 +#define INT16_MIN SHRT_MIN
15641 +#define INT16_MAX SHRT_MAX
15642 +#define UINT16_MAX USHRT_MAX
15643 +#define INT32_MIN LONG_MIN
15644 +#define INT32_MAX LONG_MAX
15645 +#define UINT32_MAX ULONG_MAX
15646 +#define INT64_MIN LLONG_MIN
15647 +#define INT64_MAX LLONG_MAX
15648 +#define UINT64_MAX ULLONG_MAX
15649 +
15650 +#define INTPTR_MIN INT32_MIN
15651 +#define INTPTR_MAX INT32_MAX
15652 +#define UINTPTR_MAX UINT32_MAX
15653 +#define INTMAX_MIN INT64_MIN
15654 +#define INTMAX_MAX INT64_MAX
15655 +#define INT_LEAST16_MAX INT16_MAX
15656 +#define INT_LEAST16_MAX INT16_MAX
15657 +
15658 +#elif defined (__HIGHC__) && defined(_I386)
15659 +
15660 +#include <stdint.h>
15661 +
15662 +#else
15663 +#error Unknown platform
15664 +#endif
15665 +
15666 +#ifdef __cplusplus
15667 +}
15668 +#endif
15669 +#endif /* VCOS_STDINT_H */
15670 +
15671 +
15672 --- /dev/null
15673 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_string.h
15674 @@ -0,0 +1,73 @@
15675 +/*=============================================================================
15676 +Copyright (c) 2009 Broadcom Europe Limited.
15677 +All rights reserved.
15678 +
15679 +Project : vcfw
15680 +Module : chip driver
15681 +
15682 +FILE DESCRIPTION
15683 +VideoCore OS Abstraction Layer - public header file
15684 +=============================================================================*/
15685 +
15686 +#ifndef VCOS_STRING_H
15687 +#define VCOS_STRING_H
15688 +
15689 +/**
15690 + * \file
15691 + *
15692 + * String functions.
15693 + *
15694 + */
15695 +
15696 +#ifdef __cplusplus
15697 +extern "C" {
15698 +#endif
15699 +
15700 +#include "interface/vcos/vcos_types.h"
15701 +#include "vcos_platform.h"
15702 +
15703 +#ifdef __KERNEL__
15704 +#include <linux/string.h>
15705 +#else
15706 +#include <string.h>
15707 +#endif
15708 +
15709 +/** Case insensitive string comparison.
15710 + *
15711 + */
15712 +
15713 +VCOS_INLINE_DECL
15714 +int vcos_strcasecmp(const char *s1, const char *s2);
15715 +
15716 +VCOS_INLINE_DECL
15717 +int vcos_strncasecmp(const char *s1, const char *s2, size_t n);
15718 +
15719 +VCOSPRE_ int VCOSPOST_ vcos_vsnprintf( char *buf, size_t buflen, const char *fmt, va_list ap );
15720 +
15721 +VCOSPRE_ int VCOSPOST_ vcos_snprintf(char *buf, size_t buflen, const char *fmt, ...);
15722 +
15723 +VCOS_STATIC_INLINE
15724 +int vcos_strlen(const char *s) { return (int)strlen(s); }
15725 +
15726 +VCOS_STATIC_INLINE
15727 +int vcos_strcmp(const char *s1, const char *s2) { return strcmp(s1,s2); }
15728 +
15729 +VCOS_STATIC_INLINE
15730 +int vcos_strncmp(const char *cs, const char *ct, size_t count) { return strncmp(cs, ct, count); }
15731 +
15732 +VCOS_STATIC_INLINE
15733 +char *vcos_strcpy(char *dst, const char *src) { return strcpy(dst, src); }
15734 +
15735 +VCOS_STATIC_INLINE
15736 +char *vcos_strncpy(char *dst, const char *src, size_t count) { return strncpy(dst, src, count); }
15737 +
15738 +VCOS_STATIC_INLINE
15739 +void *vcos_memcpy(void *dst, const void *src, size_t n) { memcpy(dst, src, n); return dst; }
15740 +
15741 +VCOS_STATIC_INLINE
15742 +void *vcos_memset(void *p, int c, size_t n) { return memset(p, c, n); }
15743 +
15744 +#ifdef __cplusplus
15745 +}
15746 +#endif
15747 +#endif
15748 --- /dev/null
15749 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_thread.h
15750 @@ -0,0 +1,259 @@
15751 +/*=============================================================================
15752 +Copyright (c) 2009 Broadcom Europe Limited.
15753 +All rights reserved.
15754 +
15755 +Project : vcfw
15756 +Module : chip driver
15757 +
15758 +FILE DESCRIPTION
15759 +VideoCore OS Abstraction Layer - public header file
15760 +=============================================================================*/
15761 +
15762 +#ifndef VCOS_THREAD_H
15763 +#define VCOS_THREAD_H
15764 +
15765 +#ifdef __cplusplus
15766 +extern "C" {
15767 +#endif
15768 +
15769 +#include "interface/vcos/vcos_types.h"
15770 +#include "vcos_platform.h"
15771 +
15772 +/**
15773 + * \file vcos_thread.h
15774 + *
15775 + * \section thread Threads
15776 + *
15777 + * Under Nucleus, a thread is created by NU_Create_Task, passing in the stack
15778 + * and various other parameters. To stop the thread, NU_Terminate_Thread() and
15779 + * NU_Delete_Thread() are called.
15780 + *
15781 + * Unfortunately it's not possible to emulate this API under some fairly common
15782 + * operating systems. Under Windows you can't pass in the stack, and you can't
15783 + * safely terminate a thread.
15784 + *
15785 + * Therefore, an API which is similar to the pthreads API is used instead. This
15786 + * API can (mostly) be emulated under all interesting operating systems.
15787 + *
15788 + * Obviously this makes the code somewhat more complicated on VideoCore than it
15789 + * would otherwise be - we end up with an extra mutex per thread, and some code
15790 + * that waits for it. The benefit is that we have a single way of creating
15791 + * threads that works consistently on all platforms (apart from stack supplying).
15792 + *
15793 + * \subsection stack Stack
15794 + *
15795 + * It's still not possible to pass in the stack address, but this can be made
15796 + * much more obvious in the API: the relevant function is missing and the
15797 + * CPP symbol VCOS_CAN_SET_STACK_ADDR is zero rather than one.
15798 + *
15799 + * \subsection thr_create Creating a thread
15800 + *
15801 + * The simplest way to create a thread is with vcos_thread_create() passing in a
15802 + * NULL thread parameter argument. To wait for the thread to exit, call
15803 + * vcos_thread_join().
15804 + *
15805 + * \subsection back Backward compatibility
15806 + *
15807 + * To ease migration, a "classic" thread creation API is provided for code
15808 + * that used to make use of Nucleus, vcos_thread_create_classic(). The
15809 + * arguments are not exactly the same, as the PREEMPT parameter is dropped.
15810 + *
15811 + */
15812 +
15813 +#define VCOS_AFFINITY_CPU0 _VCOS_AFFINITY_CPU0
15814 +#define VCOS_AFFINITY_CPU1 _VCOS_AFFINITY_CPU1
15815 +#define VCOS_AFFINITY_MASK _VCOS_AFFINITY_MASK
15816 +#define VCOS_AFFINITY_DEFAULT _VCOS_AFFINITY_DEFAULT
15817 +#define VCOS_AFFINITY_THISCPU _VCOS_AFFINITY_THISCPU
15818 +
15819 +/** Report whether or not we have an RTOS at all, and hence the ability to
15820 + * create threads.
15821 + */
15822 +VCOSPRE_ int VCOSPOST_ vcos_have_rtos(void);
15823 +
15824 +/** Create a thread. It must be cleaned up by calling vcos_thread_join().
15825 + *
15826 + * @param thread Filled in on return with thread
15827 + * @param name A name for the thread. May be the empty string.
15828 + * @param attrs Attributes; default attributes will be used if this is NULL.
15829 + * @param entry Entry point.
15830 + * @param arg Argument passed to the entry point.
15831 + */
15832 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_thread_create(VCOS_THREAD_T *thread,
15833 + const char *name,
15834 + VCOS_THREAD_ATTR_T *attrs,
15835 + VCOS_THREAD_ENTRY_FN_T entry,
15836 + void *arg);
15837 +
15838 +/** Exit the thread from within the thread function itself.
15839 + * Resources must still be cleaned up via a call to thread_join().
15840 + *
15841 + * The thread can also be terminated by simply exiting the thread function.
15842 + *
15843 + * @param data Data passed to thread_join. May be NULL.
15844 + */
15845 +VCOSPRE_ void VCOSPOST_ vcos_thread_exit(void *data);
15846 +
15847 +/** Wait for a thread to terminate and then clean up its resources.
15848 + *
15849 + * @param thread Thread to wait for
15850 + * @param pData Updated to point at data provided in vcos_thread_exit or exit
15851 + * code of thread function.
15852 + */
15853 +VCOSPRE_ void VCOSPOST_ vcos_thread_join(VCOS_THREAD_T *thread,
15854 + void **pData);
15855 +
15856 +
15857 +/**
15858 + * \brief Create a thread using an API similar to the one "traditionally"
15859 + * used under Nucleus.
15860 + *
15861 + * This creates a thread which must be cleaned up by calling vcos_thread_join().
15862 + * The thread cannot be simply terminated (as in Nucleus and ThreadX) as thread
15863 + * termination is not universally supported.
15864 + *
15865 + * @param thread Filled in with thread instance
15866 + * @param name An optional name for the thread. NULL or "" may be used (but
15867 + * a name will aid in debugging).
15868 + * @param entry Entry point
15869 + * @param arg A single argument passed to the entry point function
15870 + * @param stack Pointer to stack address
15871 + * @param stacksz Size of stack in bytes
15872 + * @param priaff Priority of task, between VCOS_PRI_LOW and VCOS_PRI_HIGH, ORed with the CPU affinity
15873 + * @param autostart If non-zero the thread will start immediately.
15874 + * @param timeslice Timeslice (system ticks) for this thread.
15875 + *
15876 + * @sa vcos_thread_terminate vcos_thread_delete
15877 + */
15878 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_thread_create_classic(VCOS_THREAD_T *thread,
15879 + const char *name,
15880 + void *(*entry)(void *arg),
15881 + void *arg,
15882 + void *stack,
15883 + VCOS_UNSIGNED stacksz,
15884 + VCOS_UNSIGNED priaff,
15885 + VCOS_UNSIGNED timeslice,
15886 + VCOS_UNSIGNED autostart);
15887 +
15888 +/**
15889 + * \brief Set a thread's priority
15890 + *
15891 + * Set the priority for a thread.
15892 + *
15893 + * @param thread The thread
15894 + * @param pri Thread priority in VCOS_PRI_MASK bits; affinity in VCOS_AFFINITY_MASK bits.
15895 + */
15896 +VCOS_INLINE_DECL
15897 +void vcos_thread_set_priority(VCOS_THREAD_T *thread, VCOS_UNSIGNED pri);
15898 +
15899 +/**
15900 + * \brief Return the currently executing thread.
15901 + *
15902 + */
15903 +VCOS_INLINE_DECL
15904 +VCOS_THREAD_T *vcos_thread_current(void);
15905 +
15906 +/**
15907 + * \brief Return the thread's priority.
15908 + */
15909 +VCOS_INLINE_DECL
15910 +VCOS_UNSIGNED vcos_thread_get_priority(VCOS_THREAD_T *thread);
15911 +
15912 +/**
15913 + * \brief Return the thread's cpu affinity.
15914 + */
15915 +VCOS_INLINE_DECL
15916 +VCOS_UNSIGNED vcos_thread_get_affinity(VCOS_THREAD_T *thread);
15917 +
15918 +/**
15919 + * \brief Set the thread's cpu affinity.
15920 + */
15921 +
15922 +VCOS_INLINE_DECL
15923 +void vcos_thread_set_affinity(VCOS_THREAD_T *thread, VCOS_UNSIGNED affinity);
15924 +
15925 +/**
15926 + * \brief Query whether we are in an interrupt.
15927 + *
15928 + * @return 1 if in interrupt context.
15929 + */
15930 +VCOS_INLINE_DECL
15931 +int vcos_in_interrupt(void);
15932 +
15933 +/**
15934 + * \brief Sleep a while.
15935 + *
15936 + * @param ms Number of milliseconds to sleep for
15937 + *
15938 + * This may actually sleep a whole number of ticks.
15939 + */
15940 +VCOS_INLINE_DECL
15941 +void vcos_sleep(uint32_t ms);
15942 +
15943 +/**
15944 + * \brief Return the value of the hardware microsecond counter.
15945 + *
15946 + */
15947 +VCOS_INLINE_DECL
15948 +uint32_t vcos_getmicrosecs(void);
15949 +
15950 +#define vcos_get_ms() (vcos_getmicrosecs()/1000)
15951 +
15952 +/**
15953 + * \brief Return a unique identifier for the current process
15954 + *
15955 + */
15956 +VCOS_INLINE_DECL
15957 +VCOS_UNSIGNED vcos_process_id_current(void);
15958 +
15959 +/** Relinquish this time slice. */
15960 +VCOS_INLINE_DECL
15961 +void vcos_thread_relinquish(void);
15962 +
15963 +/** Return the name of the given thread.
15964 + */
15965 +VCOSPRE_ const char * VCOSPOST_ vcos_thread_get_name(const VCOS_THREAD_T *thread);
15966 +
15967 +/** Change preemption. This is almost certainly not what you want, as it won't
15968 + * work reliably in a multicore system: although you can affect the preemption
15969 + * on *this* core, you won't affect what's happening on the other core(s).
15970 + *
15971 + * It's mainly here to ease migration. If you're using it in new code, you
15972 + * probably need to think again.
15973 + *
15974 + * @param pe New preemption, VCOS_PREEMPT or VCOS_NO_PREEMPT
15975 + * @return Old value of preemption.
15976 + */
15977 +VCOS_INLINE_DECL
15978 +VCOS_UNSIGNED vcos_change_preemption(VCOS_UNSIGNED pe);
15979 +
15980 +/** Is a thread still running, or has it exited?
15981 + *
15982 + * Note: this exists for some fairly scary code in the video codec tests. Don't
15983 + * try to use it for anything else, as it may well not do what you expect.
15984 + *
15985 + * @param thread thread to query
15986 + * @return non-zero if thread is running, or zero if it has exited.
15987 + */
15988 +VCOS_INLINE_DECL
15989 +int vcos_thread_running(VCOS_THREAD_T *thread);
15990 +
15991 +/** Resume a thread.
15992 + *
15993 + * @param thread thread to resume
15994 + */
15995 +VCOS_INLINE_DECL
15996 +void vcos_thread_resume(VCOS_THREAD_T *thread);
15997 +
15998 +/*
15999 + * Internal APIs - may not always be present and should not be used in
16000 + * client code.
16001 + */
16002 +
16003 +extern void _vcos_task_timer_set(void (*pfn)(void*), void *, VCOS_UNSIGNED ms);
16004 +extern void _vcos_task_timer_cancel(void);
16005 +
16006 +#ifdef __cplusplus
16007 +}
16008 +#endif
16009 +#endif
16010 --- /dev/null
16011 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_thread_attr.h
16012 @@ -0,0 +1,73 @@
16013 +/*=============================================================================
16014 +Copyright (c) 2009 Broadcom Europe Limited.
16015 +All rights reserved.
16016 +
16017 +FILE DESCRIPTION
16018 +VideoCore OS Abstraction Layer - thread attributes
16019 +=============================================================================*/
16020 +
16021 +#ifndef VCOS_THREAD_ATTR_H
16022 +#define VCOS_THREAD_ATTR_H
16023 +
16024 +#ifdef __cplusplus
16025 +extern "C" {
16026 +#endif
16027 +
16028 +/**
16029 + * \file
16030 + *
16031 + * Attributes for thread creation.
16032 + *
16033 + */
16034 +
16035 +/** Initialize thread attribute struct. This call does not allocate memory,
16036 + * and so cannot fail.
16037 + *
16038 + */
16039 +VCOSPRE_ void VCOSPOST_ vcos_thread_attr_init(VCOS_THREAD_ATTR_T *attrs);
16040 +
16041 +/** Set the stack address and size. If not set, a stack will be allocated automatically.
16042 + *
16043 + * This can only be set on some platforms. It will always be possible to set the stack
16044 + * address on VideoCore, but on host platforms, support may well not be available.
16045 + */
16046 +#if VCOS_CAN_SET_STACK_ADDR
16047 +VCOS_INLINE_DECL
16048 +void vcos_thread_attr_setstack(VCOS_THREAD_ATTR_T *attrs, void *addr, VCOS_UNSIGNED sz);
16049 +#endif
16050 +
16051 +/** Set the stack size. If not set, a default size will be used. Attempting to call this after having
16052 + * set the stack location with vcos_thread_attr_setstack() will result in undefined behaviour.
16053 + */
16054 +VCOS_INLINE_DECL
16055 +void vcos_thread_attr_setstacksize(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED sz);
16056 +
16057 +/** Set the task priority. If not set, a default value will be used.
16058 + */
16059 +VCOS_INLINE_DECL
16060 +void vcos_thread_attr_setpriority(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED pri);
16061 +
16062 +/** Set the task cpu affinity. If not set, the default will be used.
16063 + */
16064 +VCOS_INLINE_DECL
16065 +void vcos_thread_attr_setaffinity(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED aff);
16066 +
16067 +/** Set the timeslice. If not set the default will be used.
16068 + */
16069 +VCOS_INLINE_DECL
16070 +void vcos_thread_attr_settimeslice(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED ts);
16071 +
16072 +/** The thread entry function takes (argc,argv), as per Nucleus, with
16073 + * argc being 0. This may be withdrawn in a future release and should not
16074 + * be used in new code.
16075 + */
16076 +VCOS_INLINE_DECL
16077 +void _vcos_thread_attr_setlegacyapi(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED legacy);
16078 +
16079 +VCOS_INLINE_DECL
16080 +void vcos_thread_attr_setautostart(VCOS_THREAD_ATTR_T *attrs, VCOS_UNSIGNED autostart);
16081 +
16082 +#ifdef __cplusplus
16083 +}
16084 +#endif
16085 +#endif
16086 --- /dev/null
16087 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_timer.h
16088 @@ -0,0 +1,95 @@
16089 +/*=============================================================================
16090 +Copyright (c) 2009 Broadcom Europe Limited.
16091 +All rights reserved.
16092 +
16093 +Project : vcfw
16094 +Module : chip driver
16095 +
16096 +FILE DESCRIPTION
16097 +VideoCore OS Abstraction Layer - timer support
16098 +=============================================================================*/
16099 +
16100 +#ifndef VCOS_TIMER_H
16101 +#define VCOS_TIMER_H
16102 +
16103 +#ifdef __cplusplus
16104 +extern "C" {
16105 +#endif
16106 +
16107 +#include "interface/vcos/vcos_types.h"
16108 +#include "vcos_platform.h"
16109 +
16110 +/** \file vcos_timer.h
16111 + *
16112 + * Timers are single shot.
16113 + *
16114 + * Timer times are in milliseconds.
16115 + *
16116 + * \note that timer callback functions are called from an arbitrary thread
16117 + * context. The expiration function should do its work as quickly as possible;
16118 + * blocking should be avoided.
16119 + *
16120 + * \note On Windows, the separate function vcos_timer_init() must be called
16121 + * as timer initialization from DllMain is not possible.
16122 + */
16123 +
16124 +/** Perform timer subsystem initialization. This function is not needed
16125 + * on non-Windows platforms but is still present so that it can be
16126 + * called. On Windows it is needed because vcos_init() gets called
16127 + * from DLL initialization where it is not possible to create a
16128 + * time queue (deadlock occurs if you try).
16129 + *
16130 + * @return VCOS_SUCCESS on success. VCOS_EEXIST if this has already been called
16131 + * once. VCOS_ENOMEM if resource allocation failed.
16132 + */
16133 +VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_timer_init(void);
16134 +
16135 +/** Create a timer in a disabled state.
16136 + *
16137 + * The timer is initially disabled.
16138 + *
16139 + * @param timer timer handle
16140 + * @param name name for timer
16141 + * @param expiration_routine function to call when timer expires
16142 + * @param context context passed to expiration routine
16143 + *
16144 + */
16145 +VCOS_INLINE_DECL
16146 +VCOS_STATUS_T vcos_timer_create(VCOS_TIMER_T *timer,
16147 + const char *name,
16148 + void (*expiration_routine)(void *context),
16149 + void *context);
16150 +
16151 +
16152 +
16153 +/** Start a timer running.
16154 + *
16155 + * Timer must be stopped.
16156 + *
16157 + * @param timer timer handle
16158 + * @param delay Delay to wait for, in ms
16159 + */
16160 +VCOS_INLINE_DECL
16161 +void vcos_timer_set(VCOS_TIMER_T *timer, VCOS_UNSIGNED delay);
16162 +
16163 +/** Stop an already running timer.
16164 + *
16165 + * @param timer timer handle
16166 + */
16167 +VCOS_INLINE_DECL
16168 +void vcos_timer_cancel(VCOS_TIMER_T *timer);
16169 +
16170 +/** Stop a timer and restart it.
16171 + * @param timer timer handle
16172 + * @param delay delay in ms
16173 + */
16174 +VCOS_INLINE_DECL
16175 +void vcos_timer_reset(VCOS_TIMER_T *timer, VCOS_UNSIGNED delay);
16176 +
16177 +VCOS_INLINE_DECL
16178 +void vcos_timer_delete(VCOS_TIMER_T *timer);
16179 +
16180 +#ifdef __cplusplus
16181 +}
16182 +#endif
16183 +#endif
16184 --- /dev/null
16185 +++ b/drivers/misc/vc04_services/interface/vcos/vcos_types.h
16186 @@ -0,0 +1,197 @@
16187 +/*=============================================================================
16188 +Copyright (c) 2009 Broadcom Europe Limited.
16189 +All rights reserved.
16190 +
16191 +FILE DESCRIPTION
16192 +VideoCore OS Abstraction Layer - basic types
16193 +=============================================================================*/
16194 +
16195 +#ifndef VCOS_TYPES_H
16196 +#define VCOS_TYPES_H
16197 +
16198 +#define VCOS_VERSION 1
16199 +
16200 +#include "vcos_platform_types.h"
16201 +
16202 +#if !defined(VCOSPRE_) || !defined(VCOSPOST_)
16203 +#error VCOSPRE_ and VCOSPOST_ not defined!
16204 +#endif
16205 +
16206 +/* Redefine these here; this means that existing header files can carry on
16207 + * using the VCHPOST/VCHPRE macros rather than having huge changes, which
16208 + * could cause nasty merge problems.
16209 + */
16210 +#ifndef VCHPOST_
16211 +#define VCHPOST_ VCOSPOST_
16212 +#endif
16213 +#ifndef VCHPRE_
16214 +#define VCHPRE_ VCOSPRE_
16215 +#endif
16216 +
16217 +/** Entry function for a lowlevel thread.
16218 + *
16219 + * Returns void for consistency with Nucleus/ThreadX.
16220 + */
16221 +typedef void (*VCOS_LLTHREAD_ENTRY_FN_T)(void *);
16222 +
16223 +/** Thread entry point. Returns a void* for consistency
16224 + * with pthreads.
16225 + */
16226 +typedef void *(*VCOS_THREAD_ENTRY_FN_T)(void*);
16227 +
16228 +
16229 +/* Error return codes - chosen to be similar to errno values */
16230 +typedef enum
16231 +{
16232 + VCOS_SUCCESS,
16233 + VCOS_EAGAIN,
16234 + VCOS_ENOENT,
16235 + VCOS_ENOSPC,
16236 + VCOS_EINVAL,
16237 + VCOS_EACCESS,
16238 + VCOS_ENOMEM,
16239 + VCOS_ENOSYS,
16240 + VCOS_EEXIST,
16241 + VCOS_ENXIO,
16242 + VCOS_EINTR
16243 +} VCOS_STATUS_T;
16244 +
16245 +/* Some compilers (MetaWare) won't inline with -g turned on, which then results
16246 + * in a lot of code bloat. To overcome this, inline functions are forward declared
16247 + * with the prefix VCOS_INLINE_DECL, and implemented with the prefix VCOS_INLINE_IMPL.
16248 + *
16249 + * That then means that in a release build, "static inline" can be used in the obvious
16250 + * way, but in a debug build the implementations can be skipped in all but one file,
16251 + * by using VCOS_INLINE_BODIES.
16252 + *
16253 + * VCOS_INLINE_DECL - put this at the start of an inline forward declaration of a VCOS
16254 + * function.
16255 + *
16256 + * VCOS_INLINE_IMPL - put this at the start of an inlined implementation of a VCOS
16257 + * function.
16258 + *
16259 + */
16260 +
16261 +/* VCOS_EXPORT - it turns out that in some circumstances we need the implementation of
16262 + * a function even if it is usually inlined.
16263 + *
16264 + * In particular, if we have a codec that is usually provided in object form, if it
16265 + * was built for a debug build it will be full of calls to vcos_XXX(). If this is used
16266 + * in a *release* build, then there won't be any of these calls around in the main image
16267 + * as they will all have been inlined. The problem also exists for vcos functions called
16268 + * from assembler.
16269 + *
16270 + * VCOS_EXPORT ensures that the named function will be emitted as a regular (not static-inline)
16271 + * function inside vcos_<platform>.c so that it can be linked against. Doing this for every
16272 + * VCOS function would be a bit code-bloat-tastic, so it is only done for those that need it.
16273 + *
16274 + */
16275 +
16276 +#ifdef __cplusplus
16277 +#define _VCOS_INLINE inline
16278 +#else
16279 +#define _VCOS_INLINE __inline
16280 +#endif
16281 +
16282 +#if defined(NDEBUG)
16283 +
16284 +#ifdef __GNUC__
16285 +# define VCOS_INLINE_DECL extern __inline__
16286 +# define VCOS_INLINE_IMPL static __inline__
16287 +#else
16288 +# define VCOS_INLINE_DECL static _VCOS_INLINE /* declare a func */
16289 +# define VCOS_INLINE_IMPL static _VCOS_INLINE /* implement a func inline */
16290 +#endif
16291 +
16292 +# if defined(VCOS_WANT_IMPL)
16293 +# define VCOS_EXPORT
16294 +# else
16295 +# define VCOS_EXPORT VCOS_INLINE_IMPL
16296 +# endif /* VCOS_WANT_IMPL */
16297 +
16298 +#define VCOS_INLINE_BODIES
16299 +
16300 +#else /* NDEBUG */
16301 +
16302 +#if !defined(VCOS_INLINE_DECL)
16303 + #define VCOS_INLINE_DECL extern
16304 +#endif
16305 +#if !defined(VCOS_INLINE_IMPL)
16306 + #define VCOS_INLINE_IMPL
16307 +#endif
16308 +#define VCOS_EXPORT VCOS_INLINE_IMPL
16309 +#endif
16310 +
16311 +#define VCOS_STATIC_INLINE static _VCOS_INLINE
16312 +
16313 +#if defined(__HIGHC__) || defined(__HIGHC_ANSI__)
16314 +#define _VCOS_METAWARE
16315 +#endif
16316 +
16317 +/** It seems that __FUNCTION__ isn't standard!
16318 + */
16319 +#if __STDC_VERSION__ < 199901L
16320 +# if __GNUC__ >= 2 || defined(__VIDEOCORE__)
16321 +# define VCOS_FUNCTION __FUNCTION__
16322 +# else
16323 +# define VCOS_FUNCTION "<unknown>"
16324 +# endif
16325 +#else
16326 +# define VCOS_FUNCTION __func__
16327 +#endif
16328 +
16329 +#define _VCOS_MS_PER_TICK (1000/VCOS_TICKS_PER_SECOND)
16330 +
16331 +/* Convert a number of milliseconds to a tick count. Internal use only - fails to
16332 + * convert VCOS_SUSPEND correctly.
16333 + */
16334 +#define _VCOS_MS_TO_TICKS(ms) (((ms)+_VCOS_MS_PER_TICK-1)/_VCOS_MS_PER_TICK)
16335 +
16336 +#define VCOS_TICKS_TO_MS(ticks) ((ticks) * _VCOS_MS_PER_TICK)
16337 +
16338 +/** VCOS version of DATESTR, from pcdisk.h. Used by the hostreq service.
16339 + */
16340 +typedef struct vcos_datestr
16341 +{
16342 + uint8_t cmsec; /**< Centesimal mili second */
16343 + uint16_t date; /**< Date */
16344 + uint16_t time; /**< Time */
16345 +
16346 +} VCOS_DATESTR;
16347 +
16348 +/* Compile-time assert - declares invalid array length if condition
16349 + * not met, or array of length one if OK.
16350 + */
16351 +#define VCOS_CASSERT(e) extern char vcos_compile_time_check[1/(e)]
16352 +
16353 +#define vcos_min(x,y) ((x) < (y) ? (x) : (y))
16354 +#define vcos_max(x,y) ((x) > (y) ? (x) : (y))
16355 +
16356 +/** Return the count of an array. FIXME: under gcc we could make
16357 + * this report an error for pointers using __builtin_types_compatible().
16358 + */
16359 +#define vcos_countof(x) (sizeof((x)) / sizeof((x)[0]))
16360 +
16361 +/* for backward compatibility */
16362 +#define countof(x) (sizeof((x)) / sizeof((x)[0]))
16363 +
16364 +#define VCOS_ALIGN_DOWN(p,n) (((ptrdiff_t)(p)) & ~((n)-1))
16365 +#define VCOS_ALIGN_UP(p,n) VCOS_ALIGN_DOWN((ptrdiff_t)(p)+(n)-1,(n))
16366 +
16367 +/** bool_t is not a POSIX type so cannot rely on it. Define it here.
16368 + * It's not even defined in stdbool.h.
16369 + */
16370 +typedef int32_t vcos_bool_t;
16371 +typedef int32_t vcos_fourcc_t;
16372 +
16373 +#define VCOS_FALSE 0
16374 +#define VCOS_TRUE (!VCOS_FALSE)
16375 +
16376 +/** Mark unused arguments to keep compilers quiet */
16377 +#define vcos_unused(x) (void)(x)
16378 +
16379 +/** For backward compatibility */
16380 +typedef vcos_fourcc_t fourcc_t;
16381 +typedef vcos_fourcc_t FOURCC_T;
16382 +
16383 +#endif
OpenWrt SVN history