projects / openwrt / openwrt.git / blob
? search:


c9485340bf591e6fd10b418beb302a96a64908eb
[openwrt/openwrt.git] / target / linux / brcm2708 / patches-3.10 / 0006-cma-Add-vc_cma-driver-to-enable-use-of-CMA.patch
1 From ff28398a53a45795382bdb25db71f2a8b3394dab Mon Sep 17 00:00:00 2001
2 From: popcornmix <popcornmix@gmail.com>
3 Date: Wed, 3 Jul 2013 00:31:47 +0100
4 Subject: [PATCH 006/174] cma: Add vc_cma driver to enable use of CMA
5
6 Signed-off-by: popcornmix <popcornmix@gmail.com>
7 ---
8 drivers/char/Kconfig | 2 +
9 drivers/char/Makefile | 3 +
10 drivers/char/broadcom/Kconfig | 16 +
11 drivers/char/broadcom/Makefile | 2 +
12 drivers/char/broadcom/vc_cma/Makefile | 15 +
13 drivers/char/broadcom/vc_cma/vc_cma.c | 1143 +++++++++++++++++++++++++++++++++
14 drivers/misc/Makefile | 2 +-
15 include/linux/broadcom/vc_cma.h | 30 +
16 8 files changed, 1212 insertions(+), 1 deletion(-)
17 create mode 100644 drivers/char/broadcom/Kconfig
18 create mode 100644 drivers/char/broadcom/Makefile
19 create mode 100644 drivers/char/broadcom/vc_cma/Makefile
20 create mode 100644 drivers/char/broadcom/vc_cma/vc_cma.c
21 create mode 100644 include/linux/broadcom/vc_cma.h
22
23 --- a/drivers/char/Kconfig
24 +++ b/drivers/char/Kconfig
25 @@ -586,6 +586,8 @@ config DEVPORT
26
27 source "drivers/s390/char/Kconfig"
28
29 +source "drivers/char/broadcom/Kconfig"
30 +
31 config MSM_SMD_PKT
32 bool "Enable device interface for some SMD packet ports"
33 default n
34 --- a/drivers/char/Makefile
35 +++ b/drivers/char/Makefile
36 @@ -62,3 +62,6 @@ obj-$(CONFIG_JS_RTC) += js-rtc.o
37 js-rtc-y = rtc.o
38
39 obj-$(CONFIG_TILE_SROM) += tile-srom.o
40 +
41 +obj-$(CONFIG_BRCM_CHAR_DRIVERS) += broadcom/
42 +
43 --- /dev/null
44 +++ b/drivers/char/broadcom/Kconfig
45 @@ -0,0 +1,16 @@
46 +#
47 +# Broadcom char driver config
48 +#
49 +
50 +menuconfig BRCM_CHAR_DRIVERS
51 + bool "Broadcom Char Drivers"
52 + help
53 + Broadcom's char drivers
54 +
55 +config BCM_VC_CMA
56 + bool "Videocore CMA"
57 + depends on CMA && BRCM_CHAR_DRIVERS
58 + default n
59 + help
60 + Helper for videocore CMA access.
61 +
62 --- /dev/null
63 +++ b/drivers/char/broadcom/Makefile
64 @@ -0,0 +1,2 @@
65 +obj-$(CONFIG_BCM_VC_CMA) += vc_cma/
66 +
67 --- /dev/null
68 +++ b/drivers/char/broadcom/vc_cma/Makefile
69 @@ -0,0 +1,15 @@
70 +EXTRA_CFLAGS += -Wall -Wstrict-prototypes -Wno-trigraphs
71 +EXTRA_CFLAGS += -Werror
72 +EXTRA_CFLAGS += -I"include/linux/broadcom"
73 +EXTRA_CFLAGS += -I"drivers/misc/vc04_services"
74 +EXTRA_CFLAGS += -I"drivers/misc/vc04_services/interface/vchi"
75 +EXTRA_CFLAGS += -I"drivers/misc/vc04_services/interface/vchiq_arm"
76 +
77 +EXTRA_CFLAGS += -D__KERNEL__
78 +EXTRA_CFLAGS += -D__linux__
79 +EXTRA_CFLAGS += -Werror
80 +
81 +obj-$(CONFIG_BCM_VC_CMA) += vc-cma.o
82 +
83 +vc-cma-objs := vc_cma.o
84 +
85 --- /dev/null
86 +++ b/drivers/char/broadcom/vc_cma/vc_cma.c
87 @@ -0,0 +1,1143 @@
88 +/**
89 + * Copyright (c) 2010-2012 Broadcom. All rights reserved.
90 + *
91 + * Redistribution and use in source and binary forms, with or without
92 + * modification, are permitted provided that the following conditions
93 + * are met:
94 + * 1. Redistributions of source code must retain the above copyright
95 + * notice, this list of conditions, and the following disclaimer,
96 + * without modification.
97 + * 2. Redistributions in binary form must reproduce the above copyright
98 + * notice, this list of conditions and the following disclaimer in the
99 + * documentation and/or other materials provided with the distribution.
100 + * 3. The names of the above-listed copyright holders may not be used
101 + * to endorse or promote products derived from this software without
102 + * specific prior written permission.
103 + *
104 + * ALTERNATIVELY, this software may be distributed under the terms of the
105 + * GNU General Public License ("GPL") version 2, as published by the Free
106 + * Software Foundation.
107 + *
108 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
109 + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
110 + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
111 + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
112 + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
113 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
114 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
115 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
116 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
117 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
118 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
119 + */
120 +
121 +#include <linux/kernel.h>
122 +#include <linux/module.h>
123 +#include <linux/kthread.h>
124 +#include <linux/fs.h>
125 +#include <linux/device.h>
126 +#include <linux/cdev.h>
127 +#include <linux/mm.h>
128 +#include <linux/proc_fs.h>
129 +#include <linux/seq_file.h>
130 +#include <linux/dma-mapping.h>
131 +#include <linux/dma-contiguous.h>
132 +#include <linux/platform_device.h>
133 +#include <linux/uaccess.h>
134 +#include <asm/cacheflush.h>
135 +
136 +#include "vc_cma.h"
137 +
138 +#include "vchiq_util.h"
139 +#include "vchiq_connected.h"
140 +//#include "debug_sym.h"
141 +//#include "vc_mem.h"
142 +
143 +#define DRIVER_NAME "vc-cma"
144 +
145 +#define LOG_DBG(fmt, ...) \
146 + if (vc_cma_debug) \
147 + printk(KERN_INFO fmt "\n", ##__VA_ARGS__)
148 +#define LOG_ERR(fmt, ...) \
149 + printk(KERN_ERR fmt "\n", ##__VA_ARGS__)
150 +
151 +#define VC_CMA_FOURCC VCHIQ_MAKE_FOURCC('C', 'M', 'A', ' ')
152 +#define VC_CMA_VERSION 2
153 +
154 +#define VC_CMA_CHUNK_ORDER 6 /* 256K */
155 +#define VC_CMA_CHUNK_SIZE (4096 << VC_CMA_CHUNK_ORDER)
156 +#define VC_CMA_MAX_PARAMS_PER_MSG \
157 + ((VCHIQ_MAX_MSG_SIZE - sizeof(unsigned short))/sizeof(unsigned short))
158 +#define VC_CMA_RESERVE_COUNT_MAX 16
159 +
160 +#define PAGES_PER_CHUNK (VC_CMA_CHUNK_SIZE / PAGE_SIZE)
161 +
162 +#define VCADDR_TO_PHYSADDR(vcaddr) (mm_vc_mem_phys_addr + vcaddr)
163 +
164 +#define loud_error(...) \
165 + LOG_ERR("===== " __VA_ARGS__)
166 +
167 +enum {
168 + VC_CMA_MSG_QUIT,
169 + VC_CMA_MSG_OPEN,
170 + VC_CMA_MSG_TICK,
171 + VC_CMA_MSG_ALLOC, /* chunk count */
172 + VC_CMA_MSG_FREE, /* chunk, chunk, ... */
173 + VC_CMA_MSG_ALLOCATED, /* chunk, chunk, ... */
174 + VC_CMA_MSG_REQUEST_ALLOC, /* chunk count */
175 + VC_CMA_MSG_REQUEST_FREE, /* chunk count */
176 + VC_CMA_MSG_RESERVE, /* bytes lo, bytes hi */
177 + VC_CMA_MSG_UPDATE_RESERVE,
178 + VC_CMA_MSG_MAX
179 +};
180 +
181 +struct cma_msg {
182 + unsigned short type;
183 + unsigned short params[VC_CMA_MAX_PARAMS_PER_MSG];
184 +};
185 +
186 +struct vc_cma_reserve_user {
187 + unsigned int pid;
188 + unsigned int reserve;
189 +};
190 +
191 +/* Device (/dev) related variables */
192 +static dev_t vc_cma_devnum;
193 +static struct class *vc_cma_class;
194 +static struct cdev vc_cma_cdev;
195 +static int vc_cma_inited;
196 +static int vc_cma_debug;
197 +
198 +/* Proc entry */
199 +static struct proc_dir_entry *vc_cma_proc_entry;
200 +
201 +phys_addr_t vc_cma_base;
202 +struct page *vc_cma_base_page;
203 +unsigned int vc_cma_size;
204 +EXPORT_SYMBOL(vc_cma_size);
205 +unsigned int vc_cma_initial;
206 +unsigned int vc_cma_chunks;
207 +unsigned int vc_cma_chunks_used;
208 +unsigned int vc_cma_chunks_reserved;
209 +
210 +static int in_loud_error;
211 +
212 +unsigned int vc_cma_reserve_total;
213 +unsigned int vc_cma_reserve_count;
214 +struct vc_cma_reserve_user vc_cma_reserve_users[VC_CMA_RESERVE_COUNT_MAX];
215 +static DEFINE_SEMAPHORE(vc_cma_reserve_mutex);
216 +static DEFINE_SEMAPHORE(vc_cma_worker_queue_push_mutex);
217 +
218 +static u64 vc_cma_dma_mask = DMA_BIT_MASK(32);
219 +static struct platform_device vc_cma_device = {
220 + .name = "vc-cma",
221 + .id = 0,
222 + .dev = {
223 + .dma_mask = &vc_cma_dma_mask,
224 + .coherent_dma_mask = DMA_BIT_MASK(32),
225 + },
226 +};
227 +
228 +static VCHIQ_INSTANCE_T cma_instance;
229 +static VCHIQ_SERVICE_HANDLE_T cma_service;
230 +static VCHIU_QUEUE_T cma_msg_queue;
231 +static struct task_struct *cma_worker;
232 +
233 +static int vc_cma_set_reserve(unsigned int reserve, unsigned int pid);
234 +static int vc_cma_alloc_chunks(int num_chunks, struct cma_msg *reply);
235 +static VCHIQ_STATUS_T cma_service_callback(VCHIQ_REASON_T reason,
236 + VCHIQ_HEADER_T * header,
237 + VCHIQ_SERVICE_HANDLE_T service,
238 + void *bulk_userdata);
239 +static void send_vc_msg(unsigned short type,
240 + unsigned short param1, unsigned short param2);
241 +static bool send_worker_msg(VCHIQ_HEADER_T * msg);
242 +
243 +static int early_vc_cma_mem(char *p)
244 +{
245 + unsigned int new_size;
246 + printk(KERN_NOTICE "early_vc_cma_mem(%s)", p);
247 + vc_cma_size = memparse(p, &p);
248 + vc_cma_initial = vc_cma_size;
249 + if (*p == '/')
250 + vc_cma_size = memparse(p + 1, &p);
251 + if (*p == '@')
252 + vc_cma_base = memparse(p + 1, &p);
253 +
254 + new_size = (vc_cma_size - ((-vc_cma_base) & (VC_CMA_CHUNK_SIZE - 1)))
255 + & ~(VC_CMA_CHUNK_SIZE - 1);
256 + if (new_size > vc_cma_size)
257 + vc_cma_size = 0;
258 + vc_cma_initial = (vc_cma_initial + VC_CMA_CHUNK_SIZE - 1)
259 + & ~(VC_CMA_CHUNK_SIZE - 1);
260 + if (vc_cma_initial > vc_cma_size)
261 + vc_cma_initial = vc_cma_size;
262 + vc_cma_base = (vc_cma_base + VC_CMA_CHUNK_SIZE - 1)
263 + & ~(VC_CMA_CHUNK_SIZE - 1);
264 +
265 + printk(KERN_NOTICE " -> initial %x, size %x, base %x", vc_cma_initial,
266 + vc_cma_size, (unsigned int)vc_cma_base);
267 +
268 + return 0;
269 +}
270 +
271 +early_param("vc-cma-mem", early_vc_cma_mem);
272 +
273 +void vc_cma_early_init(void)
274 +{
275 + LOG_DBG("vc_cma_early_init - vc_cma_chunks = %d", vc_cma_chunks);
276 + if (vc_cma_size) {
277 + int rc = platform_device_register(&vc_cma_device);
278 + LOG_DBG("platform_device_register -> %d", rc);
279 + }
280 +}
281 +
282 +void vc_cma_reserve(void)
283 +{
284 + /* if vc_cma_size is set, then declare vc CMA area of the same
285 + * size from the end of memory
286 + */
287 + if (vc_cma_size) {
288 + if (dma_declare_contiguous(NULL /*&vc_cma_device.dev*/, vc_cma_size,
289 + vc_cma_base, 0) == 0) {
290 + } else {
291 + LOG_ERR("vc_cma: dma_declare_contiguous(%x,%x) failed",
292 + vc_cma_size, (unsigned int)vc_cma_base);
293 + vc_cma_size = 0;
294 + }
295 + }
296 + vc_cma_chunks = vc_cma_size / VC_CMA_CHUNK_SIZE;
297 +}
298 +
299 +/****************************************************************************
300 +*
301 +* vc_cma_open
302 +*
303 +***************************************************************************/
304 +
305 +static int vc_cma_open(struct inode *inode, struct file *file)
306 +{
307 + (void)inode;
308 + (void)file;
309 +
310 + return 0;
311 +}
312 +
313 +/****************************************************************************
314 +*
315 +* vc_cma_release
316 +*
317 +***************************************************************************/
318 +
319 +static int vc_cma_release(struct inode *inode, struct file *file)
320 +{
321 + (void)inode;
322 + (void)file;
323 +
324 + vc_cma_set_reserve(0, current->tgid);
325 +
326 + return 0;
327 +}
328 +
329 +/****************************************************************************
330 +*
331 +* vc_cma_ioctl
332 +*
333 +***************************************************************************/
334 +
335 +static long vc_cma_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
336 +{
337 + int rc = 0;
338 +
339 + (void)cmd;
340 + (void)arg;
341 +
342 + switch (cmd) {
343 + case VC_CMA_IOC_RESERVE:
344 + rc = vc_cma_set_reserve((unsigned int)arg, current->tgid);
345 + if (rc >= 0)
346 + rc = 0;
347 + break;
348 + default:
349 + LOG_ERR("vc-cma: Unknown ioctl %x", cmd);
350 + return -ENOTTY;
351 + }
352 +
353 + return rc;
354 +}
355 +
356 +/****************************************************************************
357 +*
358 +* File Operations for the driver.
359 +*
360 +***************************************************************************/
361 +
362 +static const struct file_operations vc_cma_fops = {
363 + .owner = THIS_MODULE,
364 + .open = vc_cma_open,
365 + .release = vc_cma_release,
366 + .unlocked_ioctl = vc_cma_ioctl,
367 +};
368 +
369 +/****************************************************************************
370 +*
371 +* vc_cma_proc_open
372 +*
373 +***************************************************************************/
374 +
375 +static int vc_cma_show_info(struct seq_file *m, void *v)
376 +{
377 + int i;
378 +
379 + seq_printf(m, "Videocore CMA:\n");
380 + seq_printf(m, " Base : %08x\n", (unsigned int)vc_cma_base);
381 + seq_printf(m, " Length : %08x\n", vc_cma_size);
382 + seq_printf(m, " Initial : %08x\n", vc_cma_initial);
383 + seq_printf(m, " Chunk size : %08x\n", VC_CMA_CHUNK_SIZE);
384 + seq_printf(m, " Chunks : %4d (%d bytes)\n",
385 + (int)vc_cma_chunks,
386 + (int)(vc_cma_chunks * VC_CMA_CHUNK_SIZE));
387 + seq_printf(m, " Used : %4d (%d bytes)\n",
388 + (int)vc_cma_chunks_used,
389 + (int)(vc_cma_chunks_used * VC_CMA_CHUNK_SIZE));
390 + seq_printf(m, " Reserved : %4d (%d bytes)\n",
391 + (unsigned int)vc_cma_chunks_reserved,
392 + (int)(vc_cma_chunks_reserved * VC_CMA_CHUNK_SIZE));
393 +
394 + for (i = 0; i < vc_cma_reserve_count; i++) {
395 + struct vc_cma_reserve_user *user = &vc_cma_reserve_users[i];
396 + seq_printf(m, " PID %5d: %d bytes\n", user->pid,
397 + user->reserve);
398 + }
399 +
400 + seq_printf(m, "\n");
401 +
402 + return 0;
403 +}
404 +
405 +static int vc_cma_proc_open(struct inode *inode, struct file *file)
406 +{
407 + return single_open(file, vc_cma_show_info, NULL);
408 +}
409 +
410 +/****************************************************************************
411 +*
412 +* vc_cma_proc_write
413 +*
414 +***************************************************************************/
415 +
416 +static int vc_cma_proc_write(struct file *file,
417 + const char __user *buffer,
418 + size_t size, loff_t *ppos)
419 +{
420 + int rc = -EFAULT;
421 + char input_str[20];
422 +
423 + memset(input_str, 0, sizeof(input_str));
424 +
425 + if (size > sizeof(input_str)) {
426 + LOG_ERR("%s: input string length too long", __func__);
427 + goto out;
428 + }
429 +
430 + if (copy_from_user(input_str, buffer, size - 1)) {
431 + LOG_ERR("%s: failed to get input string", __func__);
432 + goto out;
433 + }
434 +#define ALLOC_STR "alloc"
435 +#define FREE_STR "free"
436 +#define DEBUG_STR "debug"
437 +#define RESERVE_STR "reserve"
438 + if (strncmp(input_str, ALLOC_STR, strlen(ALLOC_STR)) == 0) {
439 + int size;
440 + char *p = input_str + strlen(ALLOC_STR);
441 +
442 + while (*p == ' ')
443 + p++;
444 + size = memparse(p, NULL);
445 + LOG_ERR("/proc/vc-cma: alloc %d", size);
446 + if (size)
447 + send_vc_msg(VC_CMA_MSG_REQUEST_FREE,
448 + size / VC_CMA_CHUNK_SIZE, 0);
449 + else
450 + LOG_ERR("invalid size '%s'", p);
451 + rc = size;
452 + } else if (strncmp(input_str, FREE_STR, strlen(FREE_STR)) == 0) {
453 + int size;
454 + char *p = input_str + strlen(FREE_STR);
455 +
456 + while (*p == ' ')
457 + p++;
458 + size = memparse(p, NULL);
459 + LOG_ERR("/proc/vc-cma: free %d", size);
460 + if (size)
461 + send_vc_msg(VC_CMA_MSG_REQUEST_ALLOC,
462 + size / VC_CMA_CHUNK_SIZE, 0);
463 + else
464 + LOG_ERR("invalid size '%s'", p);
465 + rc = size;
466 + } else if (strncmp(input_str, DEBUG_STR, strlen(DEBUG_STR)) == 0) {
467 + char *p = input_str + strlen(DEBUG_STR);
468 + while (*p == ' ')
469 + p++;
470 + if ((strcmp(p, "on") == 0) || (strcmp(p, "1") == 0))
471 + vc_cma_debug = 1;
472 + else if ((strcmp(p, "off") == 0) || (strcmp(p, "0") == 0))
473 + vc_cma_debug = 0;
474 + LOG_ERR("/proc/vc-cma: debug %s", vc_cma_debug ? "on" : "off");
475 + rc = size;
476 + } else if (strncmp(input_str, RESERVE_STR, strlen(RESERVE_STR)) == 0) {
477 + int size;
478 + int reserved;
479 + char *p = input_str + strlen(RESERVE_STR);
480 + while (*p == ' ')
481 + p++;
482 + size = memparse(p, NULL);
483 +
484 + reserved = vc_cma_set_reserve(size, current->tgid);
485 + rc = (reserved >= 0) ? size : reserved;
486 + }
487 +
488 +out:
489 + return rc;
490 +}
491 +
492 +/****************************************************************************
493 +*
494 +* File Operations for /proc interface.
495 +*
496 +***************************************************************************/
497 +
498 +static const struct file_operations vc_cma_proc_fops = {
499 + .open = vc_cma_proc_open,
500 + .read = seq_read,
501 + .write = vc_cma_proc_write,
502 + .llseek = seq_lseek,
503 + .release = single_release
504 +};
505 +
506 +static int vc_cma_set_reserve(unsigned int reserve, unsigned int pid)
507 +{
508 + struct vc_cma_reserve_user *user = NULL;
509 + int delta = 0;
510 + int i;
511 +
512 + if (down_interruptible(&vc_cma_reserve_mutex))
513 + return -ERESTARTSYS;
514 +
515 + for (i = 0; i < vc_cma_reserve_count; i++) {
516 + if (pid == vc_cma_reserve_users[i].pid) {
517 + user = &vc_cma_reserve_users[i];
518 + delta = reserve - user->reserve;
519 + if (reserve)
520 + user->reserve = reserve;
521 + else {
522 + /* Remove this entry by copying downwards */
523 + while ((i + 1) < vc_cma_reserve_count) {
524 + user[0].pid = user[1].pid;
525 + user[0].reserve = user[1].reserve;
526 + user++;
527 + i++;
528 + }
529 + vc_cma_reserve_count--;
530 + user = NULL;
531 + }
532 + break;
533 + }
534 + }
535 +
536 + if (reserve && !user) {
537 + if (vc_cma_reserve_count == VC_CMA_RESERVE_COUNT_MAX) {
538 + LOG_ERR("vc-cma: Too many reservations - "
539 + "increase CMA_RESERVE_COUNT_MAX");
540 + up(&vc_cma_reserve_mutex);
541 + return -EBUSY;
542 + }
543 + user = &vc_cma_reserve_users[vc_cma_reserve_count];
544 + user->pid = pid;
545 + user->reserve = reserve;
546 + delta = reserve;
547 + vc_cma_reserve_count++;
548 + }
549 +
550 + vc_cma_reserve_total += delta;
551 +
552 + send_vc_msg(VC_CMA_MSG_RESERVE,
553 + vc_cma_reserve_total & 0xffff, vc_cma_reserve_total >> 16);
554 +
555 + send_worker_msg((VCHIQ_HEADER_T *) VC_CMA_MSG_UPDATE_RESERVE);
556 +
557 + LOG_DBG("/proc/vc-cma: reserve %d (PID %d) - total %u",
558 + reserve, pid, vc_cma_reserve_total);
559 +
560 + up(&vc_cma_reserve_mutex);
561 +
562 + return vc_cma_reserve_total;
563 +}
564 +
565 +static VCHIQ_STATUS_T cma_service_callback(VCHIQ_REASON_T reason,
566 + VCHIQ_HEADER_T * header,
567 + VCHIQ_SERVICE_HANDLE_T service,
568 + void *bulk_userdata)
569 +{
570 + switch (reason) {
571 + case VCHIQ_MESSAGE_AVAILABLE:
572 + if (!send_worker_msg(header))
573 + return VCHIQ_RETRY;
574 + break;
575 + case VCHIQ_SERVICE_CLOSED:
576 + LOG_DBG("CMA service closed");
577 + break;
578 + default:
579 + LOG_ERR("Unexpected CMA callback reason %d", reason);
580 + break;
581 + }
582 + return VCHIQ_SUCCESS;
583 +}
584 +
585 +static void send_vc_msg(unsigned short type,
586 + unsigned short param1, unsigned short param2)
587 +{
588 + unsigned short msg[] = { type, param1, param2 };
589 + VCHIQ_ELEMENT_T elem = { &msg, sizeof(msg) };
590 + VCHIQ_STATUS_T ret;
591 + vchiq_use_service(cma_service);
592 + ret = vchiq_queue_message(cma_service, &elem, 1);
593 + vchiq_release_service(cma_service);
594 + if (ret != VCHIQ_SUCCESS)
595 + LOG_ERR("vchiq_queue_message returned %x", ret);
596 +}
597 +
598 +static bool send_worker_msg(VCHIQ_HEADER_T * msg)
599 +{
600 + if (down_interruptible(&vc_cma_worker_queue_push_mutex))
601 + return false;
602 + vchiu_queue_push(&cma_msg_queue, msg);
603 + up(&vc_cma_worker_queue_push_mutex);
604 + return true;
605 +}
606 +
607 +static int vc_cma_alloc_chunks(int num_chunks, struct cma_msg *reply)
608 +{
609 + int i;
610 + for (i = 0; i < num_chunks; i++) {
611 + struct page *chunk;
612 + unsigned int chunk_num;
613 + uint8_t *chunk_addr;
614 + size_t chunk_size = PAGES_PER_CHUNK << PAGE_SHIFT;
615 +
616 + chunk = dma_alloc_from_contiguous(NULL /*&vc_cma_device.dev*/,
617 + PAGES_PER_CHUNK,
618 + VC_CMA_CHUNK_ORDER);
619 + if (!chunk)
620 + break;
621 +
622 + chunk_addr = page_address(chunk);
623 + dmac_flush_range(chunk_addr, chunk_addr + chunk_size);
624 + outer_inv_range(__pa(chunk_addr), __pa(chunk_addr) +
625 + chunk_size);
626 +
627 + chunk_num =
628 + (page_to_phys(chunk) - vc_cma_base) / VC_CMA_CHUNK_SIZE;
629 + BUG_ON(((page_to_phys(chunk) - vc_cma_base) %
630 + VC_CMA_CHUNK_SIZE) != 0);
631 + if (chunk_num >= vc_cma_chunks) {
632 + LOG_ERR("%s: ===============================",
633 + __func__);
634 + LOG_ERR("%s: chunk phys %x, vc_cma %x-%x - "
635 + "bad SPARSEMEM configuration?",
636 + __func__, (unsigned int)page_to_phys(chunk),
637 + vc_cma_base, vc_cma_base + vc_cma_size - 1);
638 + LOG_ERR("%s: dev->cma_area = %p\n", __func__,
639 + vc_cma_device.dev.cma_area);
640 + LOG_ERR("%s: ===============================",
641 + __func__);
642 + break;
643 + }
644 + reply->params[i] = chunk_num;
645 + vc_cma_chunks_used++;
646 + }
647 +
648 + if (i < num_chunks) {
649 + LOG_ERR("%s: dma_alloc_from_contiguous failed "
650 + "for %x bytes (alloc %d of %d, %d free)",
651 + __func__, VC_CMA_CHUNK_SIZE, i,
652 + num_chunks, vc_cma_chunks - vc_cma_chunks_used);
653 + num_chunks = i;
654 + }
655 +
656 + LOG_DBG("CMA allocated %d chunks -> %d used",
657 + num_chunks, vc_cma_chunks_used);
658 + reply->type = VC_CMA_MSG_ALLOCATED;
659 +
660 + {
661 + VCHIQ_ELEMENT_T elem = {
662 + reply,
663 + offsetof(struct cma_msg, params[0]) +
664 + num_chunks * sizeof(reply->params[0])
665 + };
666 + VCHIQ_STATUS_T ret;
667 + vchiq_use_service(cma_service);
668 + ret = vchiq_queue_message(cma_service, &elem, 1);
669 + vchiq_release_service(cma_service);
670 + if (ret != VCHIQ_SUCCESS)
671 + LOG_ERR("vchiq_queue_message return " "%x", ret);
672 + }
673 +
674 + return num_chunks;
675 +}
676 +
677 +static int cma_worker_proc(void *param)
678 +{
679 + static struct cma_msg reply;
680 + (void)param;
681 +
682 + while (1) {
683 + VCHIQ_HEADER_T *msg;
684 + static struct cma_msg msg_copy;
685 + struct cma_msg *cma_msg = &msg_copy;
686 + int type, msg_size;
687 +
688 + msg = vchiu_queue_pop(&cma_msg_queue);
689 + if ((unsigned int)msg >= VC_CMA_MSG_MAX) {
690 + msg_size = msg->size;
691 + memcpy(&msg_copy, msg->data, msg_size);
692 + type = cma_msg->type;
693 + vchiq_release_message(cma_service, msg);
694 + } else {
695 + msg_size = 0;
696 + type = (int)msg;
697 + if (type == VC_CMA_MSG_QUIT)
698 + break;
699 + else if (type == VC_CMA_MSG_UPDATE_RESERVE) {
700 + msg = NULL;
701 + cma_msg = NULL;
702 + } else {
703 + BUG();
704 + continue;
705 + }
706 + }
707 +
708 + switch (type) {
709 + case VC_CMA_MSG_ALLOC:{
710 + int num_chunks, free_chunks;
711 + num_chunks = cma_msg->params[0];
712 + free_chunks =
713 + vc_cma_chunks - vc_cma_chunks_used;
714 + LOG_DBG("CMA_MSG_ALLOC(%d chunks)", num_chunks);
715 + if (num_chunks > VC_CMA_MAX_PARAMS_PER_MSG) {
716 + LOG_ERR
717 + ("CMA_MSG_ALLOC - chunk count (%d) "
718 + "exceeds VC_CMA_MAX_PARAMS_PER_MSG (%d)",
719 + num_chunks,
720 + VC_CMA_MAX_PARAMS_PER_MSG);
721 + num_chunks = VC_CMA_MAX_PARAMS_PER_MSG;
722 + }
723 +
724 + if (num_chunks > free_chunks) {
725 + LOG_ERR
726 + ("CMA_MSG_ALLOC - chunk count (%d) "
727 + "exceeds free chunks (%d)",
728 + num_chunks, free_chunks);
729 + num_chunks = free_chunks;
730 + }
731 +
732 + vc_cma_alloc_chunks(num_chunks, &reply);
733 + }
734 + break;
735 +
736 + case VC_CMA_MSG_FREE:{
737 + int chunk_count =
738 + (msg_size -
739 + offsetof(struct cma_msg,
740 + params)) /
741 + sizeof(cma_msg->params[0]);
742 + int i;
743 + BUG_ON(chunk_count <= 0);
744 +
745 + LOG_DBG("CMA_MSG_FREE(%d chunks - %x, ...)",
746 + chunk_count, cma_msg->params[0]);
747 + for (i = 0; i < chunk_count; i++) {
748 + int chunk_num = cma_msg->params[i];
749 + struct page *page = vc_cma_base_page +
750 + chunk_num * PAGES_PER_CHUNK;
751 + if (chunk_num >= vc_cma_chunks) {
752 + LOG_ERR
753 + ("CMA_MSG_FREE - chunk %d of %d"
754 + " (value %x) exceeds maximum "
755 + "(%x)", i, chunk_count,
756 + chunk_num,
757 + vc_cma_chunks - 1);
758 + break;
759 + }
760 +
761 + if (!dma_release_from_contiguous
762 + (NULL /*&vc_cma_device.dev*/, page,
763 + PAGES_PER_CHUNK)) {
764 + LOG_ERR
765 + ("CMA_MSG_FREE - failed to "
766 + "release chunk %d (phys %x, "
767 + "page %x)", chunk_num,
768 + page_to_phys(page),
769 + (unsigned int)page);
770 + }
771 + vc_cma_chunks_used--;
772 + }
773 + LOG_DBG("CMA released %d chunks -> %d used",
774 + i, vc_cma_chunks_used);
775 + }
776 + break;
777 +
778 + case VC_CMA_MSG_UPDATE_RESERVE:{
779 + int chunks_needed =
780 + ((vc_cma_reserve_total + VC_CMA_CHUNK_SIZE -
781 + 1)
782 + / VC_CMA_CHUNK_SIZE) -
783 + vc_cma_chunks_reserved;
784 +
785 + LOG_DBG
786 + ("CMA_MSG_UPDATE_RESERVE(%d chunks needed)",
787 + chunks_needed);
788 +
789 + /* Cap the reservations to what is available */
790 + if (chunks_needed > 0) {
791 + if (chunks_needed >
792 + (vc_cma_chunks -
793 + vc_cma_chunks_used))
794 + chunks_needed =
795 + (vc_cma_chunks -
796 + vc_cma_chunks_used);
797 +
798 + chunks_needed =
799 + vc_cma_alloc_chunks(chunks_needed,
800 + &reply);
801 + }
802 +
803 + LOG_DBG
804 + ("CMA_MSG_UPDATE_RESERVE(%d chunks allocated)",
805 + chunks_needed);
806 + vc_cma_chunks_reserved += chunks_needed;
807 + }
808 + break;
809 +
810 + default:
811 + LOG_ERR("unexpected msg type %d", type);
812 + break;
813 + }
814 + }
815 +
816 + LOG_DBG("quitting...");
817 + return 0;
818 +}
819 +
820 +/****************************************************************************
821 +*
822 +* vc_cma_connected_init
823 +*
824 +* This function is called once the videocore has been connected.
825 +*
826 +***************************************************************************/
827 +
828 +static void vc_cma_connected_init(void)
829 +{
830 + VCHIQ_SERVICE_PARAMS_T service_params;
831 +
832 + LOG_DBG("vc_cma_connected_init");
833 +
834 + if (!vchiu_queue_init(&cma_msg_queue, 16)) {
835 + LOG_ERR("could not create CMA msg queue");
836 + goto fail_queue;
837 + }
838 +
839 + if (vchiq_initialise(&cma_instance) != VCHIQ_SUCCESS)
840 + goto fail_vchiq_init;
841 +
842 + vchiq_connect(cma_instance);
843 +
844 + service_params.fourcc = VC_CMA_FOURCC;
845 + service_params.callback = cma_service_callback;
846 + service_params.userdata = NULL;
847 + service_params.version = VC_CMA_VERSION;
848 + service_params.version_min = VC_CMA_VERSION;
849 +
850 + if (vchiq_open_service(cma_instance, &service_params,
851 + &cma_service) != VCHIQ_SUCCESS) {
852 + LOG_ERR("failed to open service - already in use?");
853 + goto fail_vchiq_open;
854 + }
855 +
856 + vchiq_release_service(cma_service);
857 +
858 + cma_worker = kthread_create(cma_worker_proc, NULL, "cma_worker");
859 + if (!cma_worker) {
860 + LOG_ERR("could not create CMA worker thread");
861 + goto fail_worker;
862 + }
863 + set_user_nice(cma_worker, -20);
864 + wake_up_process(cma_worker);
865 +
866 + return;
867 +
868 +fail_worker:
869 + vchiq_close_service(cma_service);
870 +fail_vchiq_open:
871 + vchiq_shutdown(cma_instance);
872 +fail_vchiq_init:
873 + vchiu_queue_delete(&cma_msg_queue);
874 +fail_queue:
875 + return;
876 +}
877 +
878 +void
879 +loud_error_header(void)
880 +{
881 + if (in_loud_error)
882 + return;
883 +
884 + LOG_ERR("============================================================"
885 + "================");
886 + LOG_ERR("============================================================"
887 + "================");
888 + LOG_ERR("=====");
889 +
890 + in_loud_error = 1;
891 +}
892 +
893 +void
894 +loud_error_footer(void)
895 +{
896 + if (!in_loud_error)
897 + return;
898 +
899 + LOG_ERR("=====");
900 + LOG_ERR("============================================================"
901 + "================");
902 + LOG_ERR("============================================================"
903 + "================");
904 +
905 + in_loud_error = 0;
906 +}
907 +
908 +#if 1
909 +static int check_cma_config(void) { return 1; }
910 +#else
911 +static int
912 +read_vc_debug_var(VC_MEM_ACCESS_HANDLE_T handle,
913 + const char *symbol,
914 + void *buf, size_t bufsize)
915 +{
916 + VC_MEM_ADDR_T vcMemAddr;
917 + size_t vcMemSize;
918 + uint8_t *mapAddr;
919 + off_t vcMapAddr;
920 +
921 + if (!LookupVideoCoreSymbol(handle, symbol,
922 + &vcMemAddr,
923 + &vcMemSize)) {
924 + loud_error_header();
925 + loud_error(
926 + "failed to find VC symbol \"%s\".",
927 + symbol);
928 + loud_error_footer();
929 + return 0;
930 + }
931 +
932 + if (vcMemSize != bufsize) {
933 + loud_error_header();
934 + loud_error(
935 + "VC symbol \"%s\" is the wrong size.",
936 + symbol);
937 + loud_error_footer();
938 + return 0;
939 + }
940 +
941 + vcMapAddr = (off_t)vcMemAddr & VC_MEM_TO_ARM_ADDR_MASK;
942 + vcMapAddr += mm_vc_mem_phys_addr;
943 + mapAddr = ioremap_nocache(vcMapAddr, vcMemSize);
944 + if (mapAddr == 0) {
945 + loud_error_header();
946 + loud_error(
947 + "failed to ioremap \"%s\" @ 0x%x "
948 + "(phys: 0x%x, size: %u).",
949 + symbol,
950 + (unsigned int)vcMapAddr,
951 + (unsigned int)vcMemAddr,
952 + (unsigned int)vcMemSize);
953 + loud_error_footer();
954 + return 0;
955 + }
956 +
957 + memcpy(buf, mapAddr, bufsize);
958 + iounmap(mapAddr);
959 +
960 + return 1;
961 +}
962 +
963 +
964 +static int
965 +check_cma_config(void)
966 +{
967 + VC_MEM_ACCESS_HANDLE_T mem_hndl;
968 + VC_MEM_ADDR_T mempool_start;
969 + VC_MEM_ADDR_T mempool_end;
970 + VC_MEM_ADDR_T mempool_offline_start;
971 + VC_MEM_ADDR_T mempool_offline_end;
972 + VC_MEM_ADDR_T cam_alloc_base;
973 + VC_MEM_ADDR_T cam_alloc_size;
974 + VC_MEM_ADDR_T cam_alloc_end;
975 + int success = 0;
976 +
977 + if (OpenVideoCoreMemory(&mem_hndl) != 0)
978 + goto out;
979 +
980 + /* Read the relevant VideoCore variables */
981 + if (!read_vc_debug_var(mem_hndl, "__MEMPOOL_START",
982 + &mempool_start,
983 + sizeof(mempool_start)))
984 + goto close;
985 +
986 + if (!read_vc_debug_var(mem_hndl, "__MEMPOOL_END",
987 + &mempool_end,
988 + sizeof(mempool_end)))
989 + goto close;
990 +
991 + if (!read_vc_debug_var(mem_hndl, "__MEMPOOL_OFFLINE_START",
992 + &mempool_offline_start,
993 + sizeof(mempool_offline_start)))
994 + goto close;
995 +
996 + if (!read_vc_debug_var(mem_hndl, "__MEMPOOL_OFFLINE_END",
997 + &mempool_offline_end,
998 + sizeof(mempool_offline_end)))
999 + goto close;
1000 +
1001 + if (!read_vc_debug_var(mem_hndl, "cam_alloc_base",
1002 + &cam_alloc_base,
1003 + sizeof(cam_alloc_base)))
1004 + goto close;
1005 +
1006 + if (!read_vc_debug_var(mem_hndl, "cam_alloc_size",
1007 + &cam_alloc_size,
1008 + sizeof(cam_alloc_size)))
1009 + goto close;
1010 +
1011 + cam_alloc_end = cam_alloc_base + cam_alloc_size;
1012 +
1013 + success = 1;
1014 +
1015 + /* Now the sanity checks */
1016 + if (!mempool_offline_start)
1017 + mempool_offline_start = mempool_start;
1018 + if (!mempool_offline_end)
1019 + mempool_offline_end = mempool_end;
1020 +
1021 + if (VCADDR_TO_PHYSADDR(mempool_offline_start) != vc_cma_base) {
1022 + loud_error_header();
1023 + loud_error(
1024 + "__MEMPOOL_OFFLINE_START(%x -> %lx) doesn't match "
1025 + "vc_cma_base(%x)",
1026 + mempool_offline_start,
1027 + VCADDR_TO_PHYSADDR(mempool_offline_start),
1028 + vc_cma_base);
1029 + success = 0;
1030 + }
1031 +
1032 + if (VCADDR_TO_PHYSADDR(mempool_offline_end) !=
1033 + (vc_cma_base + vc_cma_size)) {
1034 + loud_error_header();
1035 + loud_error(
1036 + "__MEMPOOL_OFFLINE_END(%x -> %lx) doesn't match "
1037 + "vc_cma_base(%x) + vc_cma_size(%x) = %x",
1038 + mempool_offline_start,
1039 + VCADDR_TO_PHYSADDR(mempool_offline_end),
1040 + vc_cma_base, vc_cma_size, vc_cma_base + vc_cma_size);
1041 + success = 0;
1042 + }
1043 +
1044 + if (mempool_end < mempool_start) {
1045 + loud_error_header();
1046 + loud_error(
1047 + "__MEMPOOL_END(%x) must not be before "
1048 + "__MEMPOOL_START(%x)",
1049 + mempool_end,
1050 + mempool_start);
1051 + success = 0;
1052 + }
1053 +
1054 + if (mempool_offline_end < mempool_offline_start) {
1055 + loud_error_header();
1056 + loud_error(
1057 + "__MEMPOOL_OFFLINE_END(%x) must not be before "
1058 + "__MEMPOOL_OFFLINE_START(%x)",
1059 + mempool_offline_end,
1060 + mempool_offline_start);
1061 + success = 0;
1062 + }
1063 +
1064 + if (mempool_offline_start < mempool_start) {
1065 + loud_error_header();
1066 + loud_error(
1067 + "__MEMPOOL_OFFLINE_START(%x) must not be before "
1068 + "__MEMPOOL_START(%x)",
1069 + mempool_offline_start,
1070 + mempool_start);
1071 + success = 0;
1072 + }
1073 +
1074 + if (mempool_offline_end > mempool_end) {
1075 + loud_error_header();
1076 + loud_error(
1077 + "__MEMPOOL_OFFLINE_END(%x) must not be after "
1078 + "__MEMPOOL_END(%x)",
1079 + mempool_offline_end,
1080 + mempool_end);
1081 + success = 0;
1082 + }
1083 +
1084 + if ((cam_alloc_base < mempool_end) &&
1085 + (cam_alloc_end > mempool_start)) {
1086 + loud_error_header();
1087 + loud_error(
1088 + "cam_alloc pool(%x-%x) overlaps "
1089 + "mempool(%x-%x)",
1090 + cam_alloc_base, cam_alloc_end,
1091 + mempool_start, mempool_end);
1092 + success = 0;
1093 + }
1094 +
1095 + loud_error_footer();
1096 +
1097 +close:
1098 + CloseVideoCoreMemory(mem_hndl);
1099 +
1100 +out:
1101 + return success;
1102 +}
1103 +#endif
1104 +
1105 +static int vc_cma_init(void)
1106 +{
1107 + int rc = -EFAULT;
1108 + struct device *dev;
1109 +
1110 + if (!check_cma_config())
1111 + goto out_release;
1112 +
1113 + printk(KERN_INFO "vc-cma: Videocore CMA driver\n");
1114 + printk(KERN_INFO "vc-cma: vc_cma_base = 0x%08x\n", vc_cma_base);
1115 + printk(KERN_INFO "vc-cma: vc_cma_size = 0x%08x (%u MiB)\n",
1116 + vc_cma_size, vc_cma_size / (1024 * 1024));
1117 + printk(KERN_INFO "vc-cma: vc_cma_initial = 0x%08x (%u MiB)\n",
1118 + vc_cma_initial, vc_cma_initial / (1024 * 1024));
1119 +
1120 + vc_cma_base_page = phys_to_page(vc_cma_base);
1121 +
1122 + if (vc_cma_chunks) {
1123 + int chunks_needed = vc_cma_initial / VC_CMA_CHUNK_SIZE;
1124 +
1125 + for (vc_cma_chunks_used = 0;
1126 + vc_cma_chunks_used < chunks_needed; vc_cma_chunks_used++) {
1127 + struct page *chunk;
1128 + chunk = dma_alloc_from_contiguous(NULL /*&vc_cma_device.dev*/,
1129 + PAGES_PER_CHUNK,
1130 + VC_CMA_CHUNK_ORDER);
1131 + if (!chunk)
1132 + break;
1133 + BUG_ON(((page_to_phys(chunk) - vc_cma_base) %
1134 + VC_CMA_CHUNK_SIZE) != 0);
1135 + }
1136 + if (vc_cma_chunks_used != chunks_needed) {
1137 + LOG_ERR("%s: dma_alloc_from_contiguous failed (%d "
1138 + "bytes, allocation %d of %d)",
1139 + __func__, VC_CMA_CHUNK_SIZE,
1140 + vc_cma_chunks_used, chunks_needed);
1141 + goto out_release;
1142 + }
1143 +
1144 + vchiq_add_connected_callback(vc_cma_connected_init);
1145 + }
1146 +
1147 + rc = alloc_chrdev_region(&vc_cma_devnum, 0, 1, DRIVER_NAME);
1148 + if (rc < 0) {
1149 + LOG_ERR("%s: alloc_chrdev_region failed (rc=%d)", __func__, rc);
1150 + goto out_release;
1151 + }
1152 +
1153 + cdev_init(&vc_cma_cdev, &vc_cma_fops);
1154 + rc = cdev_add(&vc_cma_cdev, vc_cma_devnum, 1);
1155 + if (rc != 0) {
1156 + LOG_ERR("%s: cdev_add failed (rc=%d)", __func__, rc);
1157 + goto out_unregister;
1158 + }
1159 +
1160 + vc_cma_class = class_create(THIS_MODULE, DRIVER_NAME);
1161 + if (IS_ERR(vc_cma_class)) {
1162 + rc = PTR_ERR(vc_cma_class);
1163 + LOG_ERR("%s: class_create failed (rc=%d)", __func__, rc);
1164 + goto out_cdev_del;
1165 + }
1166 +
1167 + dev = device_create(vc_cma_class, NULL, vc_cma_devnum, NULL,
1168 + DRIVER_NAME);
1169 + if (IS_ERR(dev)) {
1170 + rc = PTR_ERR(dev);
1171 + LOG_ERR("%s: device_create failed (rc=%d)", __func__, rc);
1172 + goto out_class_destroy;
1173 + }
1174 +
1175 + vc_cma_proc_entry = proc_create(DRIVER_NAME, 0444, NULL, &vc_cma_proc_fops);
1176 + if (vc_cma_proc_entry == NULL) {
1177 + rc = -EFAULT;
1178 + LOG_ERR("%s: proc_create failed", __func__);
1179 + goto out_device_destroy;
1180 + }
1181 +
1182 + vc_cma_inited = 1;
1183 + return 0;
1184 +
1185 +out_device_destroy:
1186 + device_destroy(vc_cma_class, vc_cma_devnum);
1187 +
1188 +out_class_destroy:
1189 + class_destroy(vc_cma_class);
1190 + vc_cma_class = NULL;
1191 +
1192 +out_cdev_del:
1193 + cdev_del(&vc_cma_cdev);
1194 +
1195 +out_unregister:
1196 + unregister_chrdev_region(vc_cma_devnum, 1);
1197 +
1198 +out_release:
1199 + /* It is tempting to try to clean up by calling
1200 + dma_release_from_contiguous for all allocated chunks, but it isn't
1201 + a very safe thing to do. If vc_cma_initial is non-zero it is because
1202 + VideoCore is already using that memory, so giving it back to Linux
1203 + is likely to be fatal.
1204 + */
1205 + return -1;
1206 +}
1207 +
1208 +/****************************************************************************
1209 +*
1210 +* vc_cma_exit
1211 +*
1212 +***************************************************************************/
1213 +
1214 +static void __exit vc_cma_exit(void)
1215 +{
1216 + LOG_DBG("%s: called", __func__);
1217 +
1218 + if (vc_cma_inited) {
1219 + remove_proc_entry(DRIVER_NAME, NULL);
1220 + device_destroy(vc_cma_class, vc_cma_devnum);
1221 + class_destroy(vc_cma_class);
1222 + cdev_del(&vc_cma_cdev);
1223 + unregister_chrdev_region(vc_cma_devnum, 1);
1224 + }
1225 +}
1226 +
1227 +module_init(vc_cma_init);
1228 +module_exit(vc_cma_exit);
1229 +MODULE_LICENSE("GPL");
1230 +MODULE_AUTHOR("Broadcom Corporation");
1231 --- a/drivers/misc/Makefile
1232 +++ b/drivers/misc/Makefile
1233 @@ -53,4 +53,4 @@ obj-$(CONFIG_INTEL_MEI) += mei/
1234 obj-$(CONFIG_VMWARE_VMCI) += vmw_vmci/
1235 obj-$(CONFIG_LATTICE_ECP3_CONFIG) += lattice-ecp3-config.o
1236 obj-$(CONFIG_SRAM) += sram.o
1237 -obj-y += vc04_services/
1238 +obj-$(CONFIG_BCM2708_VCHIQ) += vc04_services/
1239 --- /dev/null
1240 +++ b/include/linux/broadcom/vc_cma.h
1241 @@ -0,0 +1,30 @@
1242 +/*****************************************************************************
1243 +* Copyright 2012 Broadcom Corporation. All rights reserved.
1244 +*
1245 +* Unless you and Broadcom execute a separate written software license
1246 +* agreement governing use of this software, this software is licensed to you
1247 +* under the terms of the GNU General Public License version 2, available at
1248 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
1249 +*
1250 +* Notwithstanding the above, under no circumstances may you combine this
1251 +* software in any way with any other Broadcom software provided under a
1252 +* license other than the GPL, without Broadcom's express prior written
1253 +* consent.
1254 +*****************************************************************************/
1255 +
1256 +#if !defined( VC_CMA_H )
1257 +#define VC_CMA_H
1258 +
1259 +#include <linux/ioctl.h>
1260 +
1261 +#define VC_CMA_IOC_MAGIC 0xc5
1262 +
1263 +#define VC_CMA_IOC_RESERVE _IO(VC_CMA_IOC_MAGIC, 0)
1264 +
1265 +#ifdef __KERNEL__
1266 +extern void __init vc_cma_early_init(void);
1267 +extern void __init vc_cma_reserve(void);
1268 +#endif
1269 +
1270 +#endif /* VC_CMA_H */
1271 +
OpenWrt Source Repository