Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 : : /* Copyright (c) 2010-2012 Broadcom. All rights reserved. */
3 : :
4 : : #include <linux/kernel.h>
5 : : #include <linux/types.h>
6 : : #include <linux/errno.h>
7 : : #include <linux/interrupt.h>
8 : : #include <linux/pagemap.h>
9 : : #include <linux/dma-mapping.h>
10 : : #include <linux/dmapool.h>
11 : : #include <linux/io.h>
12 : : #include <linux/platform_device.h>
13 : : #include <linux/uaccess.h>
14 : : #include <linux/mm.h>
15 : : #include <linux/of.h>
16 : : #include <soc/bcm2835/raspberrypi-firmware.h>
17 : :
18 : : #define TOTAL_SLOTS (VCHIQ_SLOT_ZERO_SLOTS + 2 * 32)
19 : :
20 : : #include "vchiq_arm.h"
21 : : #include "vchiq_connected.h"
22 : : #include "vchiq_killable.h"
23 : : #include "vchiq_pagelist.h"
24 : :
25 : : #define MAX_FRAGMENTS (VCHIQ_NUM_CURRENT_BULKS * 2)
26 : :
27 : : #define VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX 0
28 : : #define VCHIQ_PLATFORM_FRAGMENTS_COUNT_IDX 1
29 : :
30 : : #define BELL0 0x00
31 : : #define BELL2 0x08
32 : :
33 : : #define VCHIQ_DMA_POOL_SIZE PAGE_SIZE
34 : :
35 : : struct vchiq_2835_state {
36 : : int inited;
37 : : struct vchiq_arm_state arm_state;
38 : : };
39 : :
40 : : struct vchiq_pagelist_info {
41 : : struct pagelist *pagelist;
42 : : size_t pagelist_buffer_size;
43 : : dma_addr_t dma_addr;
44 : : bool is_from_pool;
45 : : enum dma_data_direction dma_dir;
46 : : unsigned int num_pages;
47 : : unsigned int pages_need_release;
48 : : struct page **pages;
49 : : struct scatterlist *scatterlist;
50 : : unsigned int scatterlist_mapped;
51 : : };
52 : :
53 : : static void __iomem *g_regs;
54 : : /* This value is the size of the L2 cache lines as understood by the
55 : : * VPU firmware, which determines the required alignment of the
56 : : * offsets/sizes in pagelists.
57 : : *
58 : : * Modern VPU firmware looks for a DT "cache-line-size" property in
59 : : * the VCHIQ node and will overwrite it with the actual L2 cache size,
60 : : * which the kernel must then respect. That property was rejected
61 : : * upstream, so we have to use the VPU firmware's compatibility value
62 : : * of 32.
63 : : */
64 : : static unsigned int g_cache_line_size = 32;
65 : : static struct dma_pool *g_dma_pool;
66 : : static unsigned int g_use_36bit_addrs = 0;
67 : : static unsigned int g_fragments_size;
68 : : static char *g_fragments_base;
69 : : static char *g_free_fragments;
70 : : static struct semaphore g_free_fragments_sema;
71 : : static struct device *g_dev;
72 : : static struct device *g_dma_dev;
73 : :
74 : : static DEFINE_SEMAPHORE(g_free_fragments_mutex);
75 : :
76 : : static irqreturn_t
77 : : vchiq_doorbell_irq(int irq, void *dev_id);
78 : :
79 : : static struct vchiq_pagelist_info *
80 : : create_pagelist(char __user *buf, size_t count, unsigned short type);
81 : :
82 : : static void
83 : : free_pagelist(struct vchiq_pagelist_info *pagelistinfo,
84 : : int actual);
85 : :
86 : 207 : int vchiq_platform_init(struct platform_device *pdev, struct vchiq_state *state)
87 : : {
88 : 207 : struct device *dev = &pdev->dev;
89 : : struct device *dma_dev = NULL;
90 : : struct vchiq_drvdata *drvdata = platform_get_drvdata(pdev);
91 : 207 : struct rpi_firmware *fw = drvdata->fw;
92 : : struct vchiq_slot_zero *vchiq_slot_zero;
93 : : struct resource *res;
94 : : void *slot_mem;
95 : : dma_addr_t slot_phys;
96 : : u32 channelbase;
97 : : int slot_mem_size, frag_mem_size;
98 : : int err, irq, i;
99 : :
100 : : /*
101 : : * VCHI messages between the CPU and firmware use
102 : : * 32-bit bus addresses.
103 : : */
104 : 207 : err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
105 : :
106 [ + - ]: 207 : if (err < 0)
107 : : return err;
108 : :
109 : 207 : g_cache_line_size = drvdata->cache_line_size;
110 : 207 : g_fragments_size = 2 * g_cache_line_size;
111 : :
112 [ - + ]: 207 : if (drvdata->use_36bit_addrs) {
113 : 0 : struct device_node *dma_node =
114 : : of_find_compatible_node(NULL, NULL, "brcm,bcm2711-dma");
115 : :
116 [ # # ]: 0 : if (dma_node) {
117 : : struct platform_device *pdev;
118 : :
119 : 0 : pdev = of_find_device_by_node(dma_node);
120 [ # # ]: 0 : if (pdev)
121 : 0 : dma_dev = &pdev->dev;
122 : 0 : of_node_put(dma_node);
123 : 0 : g_use_36bit_addrs = true;
124 : : } else {
125 : 0 : dev_err(dev, "40-bit DMA controller not found\n");
126 : 0 : return -EINVAL;
127 : : }
128 : : }
129 : :
130 : : /* Allocate space for the channels in coherent memory */
131 : : slot_mem_size = PAGE_ALIGN(TOTAL_SLOTS * VCHIQ_SLOT_SIZE);
132 : 207 : frag_mem_size = PAGE_ALIGN(g_fragments_size * MAX_FRAGMENTS);
133 : :
134 : 207 : slot_mem = dmam_alloc_coherent(dev, slot_mem_size + frag_mem_size,
135 : : &slot_phys, GFP_KERNEL);
136 [ - + ]: 207 : if (!slot_mem) {
137 : 0 : dev_err(dev, "could not allocate DMA memory\n");
138 : 0 : return -ENOMEM;
139 : : }
140 : :
141 [ - + ]: 207 : WARN_ON(((unsigned long)slot_mem & (PAGE_SIZE - 1)) != 0);
142 : 207 : channelbase = slot_phys;
143 : :
144 : 207 : vchiq_slot_zero = vchiq_init_slots(slot_mem, slot_mem_size);
145 [ + - ]: 207 : if (!vchiq_slot_zero)
146 : : return -EINVAL;
147 : :
148 : 207 : vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX] =
149 : 207 : channelbase + slot_mem_size;
150 : 207 : vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_COUNT_IDX] =
151 : : MAX_FRAGMENTS;
152 : :
153 : 207 : g_fragments_base = (char *)slot_mem + slot_mem_size;
154 : :
155 : 207 : g_free_fragments = g_fragments_base;
156 [ + + ]: 13455 : for (i = 0; i < (MAX_FRAGMENTS - 1); i++) {
157 : 26082 : *(char **)&g_fragments_base[i*g_fragments_size] =
158 : 13041 : &g_fragments_base[(i + 1)*g_fragments_size];
159 : : }
160 : 207 : *(char **)&g_fragments_base[i * g_fragments_size] = NULL;
161 : : sema_init(&g_free_fragments_sema, MAX_FRAGMENTS);
162 : :
163 [ + - ]: 207 : if (vchiq_init_state(state, vchiq_slot_zero) != VCHIQ_SUCCESS)
164 : : return -EINVAL;
165 : :
166 : 207 : res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
167 : 207 : g_regs = devm_ioremap_resource(&pdev->dev, res);
168 [ - + ]: 207 : if (IS_ERR(g_regs))
169 : 0 : return PTR_ERR(g_regs);
170 : :
171 : 207 : irq = platform_get_irq(pdev, 0);
172 [ + - ]: 207 : if (irq <= 0)
173 : : return irq;
174 : :
175 : 207 : err = devm_request_irq(dev, irq, vchiq_doorbell_irq, IRQF_IRQPOLL,
176 : : "VCHIQ doorbell", state);
177 [ - + ]: 207 : if (err) {
178 : 0 : dev_err(dev, "failed to register irq=%d\n", irq);
179 : 0 : return err;
180 : : }
181 : :
182 : : /* Send the base address of the slots to VideoCore */
183 : 207 : err = rpi_firmware_property(fw, RPI_FIRMWARE_VCHIQ_INIT,
184 : : &channelbase, sizeof(channelbase));
185 [ + - - + ]: 207 : if (err || channelbase) {
186 : 0 : dev_err(dev, "failed to set channelbase\n");
187 [ # # ]: 0 : return err ? : -ENXIO;
188 : : }
189 : :
190 : 207 : g_dev = dev;
191 [ + - ]: 207 : g_dma_dev = dma_dev ?: dev;
192 : 207 : g_dma_pool = dmam_pool_create("vchiq_scatter_pool", dev,
193 : : VCHIQ_DMA_POOL_SIZE, g_cache_line_size,
194 : : 0);
195 [ - + ]: 207 : if (!g_dma_pool) {
196 : 0 : dev_err(dev, "failed to create dma pool");
197 : 0 : return -ENOMEM;
198 : : }
199 : :
200 [ - + ]: 207 : vchiq_log_info(vchiq_arm_log_level,
201 : : "vchiq_init - done (slots %pK, phys %pad)",
202 : : vchiq_slot_zero, &slot_phys);
203 : :
204 : 207 : vchiq_call_connected_callbacks();
205 : :
206 : 207 : return 0;
207 : : }
208 : :
209 : : VCHIQ_STATUS_T
210 : 207 : vchiq_platform_init_state(struct vchiq_state *state)
211 : : {
212 : : VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
213 : : struct vchiq_2835_state *platform_state;
214 : :
215 : 207 : state->platform_state = kzalloc(sizeof(*platform_state), GFP_KERNEL);
216 [ + - ]: 207 : if (!state->platform_state)
217 : : return VCHIQ_ERROR;
218 : :
219 : : platform_state = (struct vchiq_2835_state *)state->platform_state;
220 : :
221 : 207 : platform_state->inited = 1;
222 : 207 : status = vchiq_arm_init_state(state, &platform_state->arm_state);
223 : :
224 [ - + ]: 207 : if (status != VCHIQ_SUCCESS)
225 : 0 : platform_state->inited = 0;
226 : :
227 : 207 : return status;
228 : : }
229 : :
230 : : struct vchiq_arm_state*
231 : 48639 : vchiq_platform_get_arm_state(struct vchiq_state *state)
232 : : {
233 : : struct vchiq_2835_state *platform_state;
234 : :
235 : 48639 : platform_state = (struct vchiq_2835_state *)state->platform_state;
236 : :
237 [ - + # # ]: 48639 : WARN_ON_ONCE(!platform_state->inited);
238 : :
239 : 48639 : return &platform_state->arm_state;
240 : : }
241 : :
242 : : void
243 : 10143 : remote_event_signal(struct remote_event *event)
244 : : {
245 : 10143 : wmb();
246 : :
247 : 10143 : event->fired = 1;
248 : :
249 : 10143 : dsb(sy); /* data barrier operation */
250 : :
251 [ + + ]: 10143 : if (event->armed)
252 : 10096 : writel(0, g_regs + BELL2); /* trigger vc interrupt */
253 : 10143 : }
254 : :
255 : : VCHIQ_STATUS_T
256 : 0 : vchiq_prepare_bulk_data(struct vchiq_bulk *bulk, void *offset, int size,
257 : : int dir)
258 : : {
259 : : struct vchiq_pagelist_info *pagelistinfo;
260 : :
261 : 0 : pagelistinfo = create_pagelist((char __user *)offset, size,
262 : : (dir == VCHIQ_BULK_RECEIVE)
263 : : ? PAGELIST_READ
264 : : : PAGELIST_WRITE);
265 : :
266 [ # # ]: 0 : if (!pagelistinfo)
267 : : return VCHIQ_ERROR;
268 : :
269 : 0 : bulk->data = (void *)(uintptr_t)pagelistinfo->dma_addr;
270 : :
271 : : /*
272 : : * Store the pagelistinfo address in remote_data,
273 : : * which isn't used by the slave.
274 : : */
275 : 0 : bulk->remote_data = pagelistinfo;
276 : :
277 : 0 : return VCHIQ_SUCCESS;
278 : : }
279 : :
280 : : void
281 : 0 : vchiq_complete_bulk(struct vchiq_bulk *bulk)
282 : : {
283 [ # # # # : 0 : if (bulk && bulk->remote_data && bulk->actual)
# # ]
284 : 0 : free_pagelist((struct vchiq_pagelist_info *)bulk->remote_data,
285 : : bulk->actual);
286 : 0 : }
287 : :
288 : : void
289 : 0 : vchiq_dump_platform_state(void *dump_context)
290 : : {
291 : : char buf[80];
292 : : int len;
293 : :
294 : 0 : len = snprintf(buf, sizeof(buf),
295 : : " Platform: 2835 (VC master)");
296 : 0 : vchiq_dump(dump_context, buf, len + 1);
297 : 0 : }
298 : :
299 : : VCHIQ_STATUS_T
300 : 0 : vchiq_platform_suspend(struct vchiq_state *state)
301 : : {
302 : 0 : return VCHIQ_ERROR;
303 : : }
304 : :
305 : : VCHIQ_STATUS_T
306 : 0 : vchiq_platform_resume(struct vchiq_state *state)
307 : : {
308 : 0 : return VCHIQ_SUCCESS;
309 : : }
310 : :
311 : : void
312 : 0 : vchiq_platform_paused(struct vchiq_state *state)
313 : : {
314 : 0 : }
315 : :
316 : : void
317 : 0 : vchiq_platform_resumed(struct vchiq_state *state)
318 : : {
319 : 0 : }
320 : :
321 : : int
322 : 9653 : vchiq_platform_videocore_wanted(struct vchiq_state *state)
323 : : {
324 : 9653 : return 1; // autosuspend not supported - videocore always wanted
325 : : }
326 : :
327 : : int
328 : 0 : vchiq_platform_use_suspend_timer(void)
329 : : {
330 : 0 : return 0;
331 : : }
332 : : void
333 : 0 : vchiq_dump_platform_use_state(struct vchiq_state *state)
334 : : {
335 [ # # ]: 0 : vchiq_log_info(vchiq_arm_log_level, "Suspend timer not in use");
336 : 0 : }
337 : : void
338 : 0 : vchiq_platform_handle_timeout(struct vchiq_state *state)
339 : : {
340 : : (void)state;
341 : 0 : }
342 : : /*
343 : : * Local functions
344 : : */
345 : :
346 : : static irqreturn_t
347 : 9634 : vchiq_doorbell_irq(int irq, void *dev_id)
348 : : {
349 : : struct vchiq_state *state = dev_id;
350 : : irqreturn_t ret = IRQ_NONE;
351 : : unsigned int status;
352 : :
353 : : /* Read (and clear) the doorbell */
354 : 19268 : status = readl(g_regs + BELL0);
355 : :
356 [ + - ]: 9634 : if (status & 0x4) { /* Was the doorbell rung? */
357 : 9634 : remote_event_pollall(state);
358 : : ret = IRQ_HANDLED;
359 : : }
360 : :
361 : 9634 : return ret;
362 : : }
363 : :
364 : : static void
365 : 0 : cleanup_pagelistinfo(struct vchiq_pagelist_info *pagelistinfo)
366 : : {
367 [ # # ]: 0 : if (pagelistinfo->scatterlist_mapped) {
368 : 0 : dma_unmap_sg(g_dma_dev, pagelistinfo->scatterlist,
369 : : pagelistinfo->num_pages, pagelistinfo->dma_dir);
370 : : }
371 : :
372 [ # # ]: 0 : if (pagelistinfo->pages_need_release) {
373 : : unsigned int i;
374 : :
375 [ # # ]: 0 : for (i = 0; i < pagelistinfo->num_pages; i++)
376 : 0 : put_page(pagelistinfo->pages[i]);
377 : : }
378 [ # # ]: 0 : if (pagelistinfo->is_from_pool) {
379 : 0 : dma_pool_free(g_dma_pool, pagelistinfo->pagelist,
380 : : pagelistinfo->dma_addr);
381 : : } else {
382 : 0 : dma_free_coherent(g_dev, pagelistinfo->pagelist_buffer_size,
383 : 0 : pagelistinfo->pagelist,
384 : : pagelistinfo->dma_addr);
385 : : }
386 : 0 : }
387 : :
388 : : /* There is a potential problem with partial cache lines (pages?)
389 : : * at the ends of the block when reading. If the CPU accessed anything in
390 : : * the same line (page?) then it may have pulled old data into the cache,
391 : : * obscuring the new data underneath. We can solve this by transferring the
392 : : * partial cache lines separately, and allowing the ARM to copy into the
393 : : * cached area.
394 : : */
395 : :
396 : : static struct vchiq_pagelist_info *
397 : 0 : create_pagelist(char __user *buf, size_t count, unsigned short type)
398 : : {
399 : : struct pagelist *pagelist;
400 : : struct vchiq_pagelist_info *pagelistinfo;
401 : : struct page **pages;
402 : : u32 *addrs;
403 : : unsigned int num_pages, offset, i, k;
404 : : int actual_pages;
405 : : bool is_from_pool;
406 : : size_t pagelist_size;
407 : : struct scatterlist *scatterlist, *sg;
408 : : int dma_buffers;
409 : : dma_addr_t dma_addr;
410 : :
411 [ # # ]: 0 : if (count >= INT_MAX - PAGE_SIZE)
412 : : return NULL;
413 : :
414 : 0 : offset = ((unsigned int)(unsigned long)buf & (PAGE_SIZE - 1));
415 : 0 : num_pages = DIV_ROUND_UP(count + offset, PAGE_SIZE);
416 : :
417 : : if (num_pages > (SIZE_MAX - sizeof(struct pagelist) -
418 : : sizeof(struct vchiq_pagelist_info)) /
419 : : (sizeof(u32) + sizeof(pages[0]) +
420 : : sizeof(struct scatterlist)))
421 : : return NULL;
422 : :
423 : 0 : pagelist_size = sizeof(struct pagelist) +
424 : : (num_pages * sizeof(u32)) +
425 : : (num_pages * sizeof(pages[0]) +
426 : 0 : (num_pages * sizeof(struct scatterlist))) +
427 : : sizeof(struct vchiq_pagelist_info);
428 : :
429 : : /* Allocate enough storage to hold the page pointers and the page
430 : : * list
431 : : */
432 [ # # ]: 0 : if (pagelist_size > VCHIQ_DMA_POOL_SIZE) {
433 : 0 : pagelist = dma_alloc_coherent(g_dev,
434 : : pagelist_size,
435 : : &dma_addr,
436 : : GFP_KERNEL);
437 : : is_from_pool = false;
438 : : } else {
439 : 0 : pagelist = dma_pool_alloc(g_dma_pool, GFP_KERNEL, &dma_addr);
440 : : is_from_pool = true;
441 : : }
442 : :
443 [ # # ]: 0 : vchiq_log_trace(vchiq_arm_log_level, "%s - %pK", __func__, pagelist);
444 : :
445 [ # # ]: 0 : if (!pagelist)
446 : : return NULL;
447 : :
448 : 0 : addrs = pagelist->addrs;
449 : 0 : pages = (struct page **)(addrs + num_pages);
450 : 0 : scatterlist = (struct scatterlist *)(pages + num_pages);
451 : 0 : pagelistinfo = (struct vchiq_pagelist_info *)
452 : 0 : (scatterlist + num_pages);
453 : :
454 : 0 : pagelist->length = count;
455 : 0 : pagelist->type = type;
456 : 0 : pagelist->offset = offset;
457 : :
458 : : /* Populate the fields of the pagelistinfo structure */
459 : 0 : pagelistinfo->pagelist = pagelist;
460 : 0 : pagelistinfo->pagelist_buffer_size = pagelist_size;
461 : 0 : pagelistinfo->dma_addr = dma_addr;
462 : 0 : pagelistinfo->is_from_pool = is_from_pool;
463 [ # # ]: 0 : pagelistinfo->dma_dir = (type == PAGELIST_WRITE) ?
464 : : DMA_TO_DEVICE : DMA_FROM_DEVICE;
465 : 0 : pagelistinfo->num_pages = num_pages;
466 : 0 : pagelistinfo->pages_need_release = 0;
467 : 0 : pagelistinfo->pages = pages;
468 : 0 : pagelistinfo->scatterlist = scatterlist;
469 : 0 : pagelistinfo->scatterlist_mapped = 0;
470 : :
471 [ # # ]: 0 : if (is_vmalloc_addr(buf)) {
472 : : unsigned long length = count;
473 : : unsigned int off = offset;
474 : :
475 [ # # ]: 0 : for (actual_pages = 0; actual_pages < num_pages;
476 : 0 : actual_pages++) {
477 : 0 : struct page *pg = vmalloc_to_page(buf + (actual_pages *
478 : : PAGE_SIZE));
479 : : size_t bytes = PAGE_SIZE - off;
480 : :
481 [ # # ]: 0 : if (!pg) {
482 : 0 : cleanup_pagelistinfo(pagelistinfo);
483 : 0 : return NULL;
484 : : }
485 : :
486 : : if (bytes > length)
487 : : bytes = length;
488 : 0 : pages[actual_pages] = pg;
489 : : length -= bytes;
490 : : off = 0;
491 : : }
492 : : /* do not try and release vmalloc pages */
493 : : } else {
494 : 0 : actual_pages = get_user_pages_fast(
495 : : (unsigned long)buf & PAGE_MASK,
496 : : num_pages,
497 : : type == PAGELIST_READ,
498 : : pages);
499 : :
500 [ # # ]: 0 : if (actual_pages != num_pages) {
501 [ # # ]: 0 : vchiq_log_info(vchiq_arm_log_level,
502 : : "%s - only %d/%d pages locked",
503 : : __func__, actual_pages, num_pages);
504 : :
505 : : /* This is probably due to the process being killed */
506 [ # # ]: 0 : while (actual_pages > 0) {
507 : 0 : actual_pages--;
508 : 0 : put_page(pages[actual_pages]);
509 : : }
510 : 0 : cleanup_pagelistinfo(pagelistinfo);
511 : 0 : return NULL;
512 : : }
513 : : /* release user pages */
514 : 0 : pagelistinfo->pages_need_release = 1;
515 : : }
516 : :
517 : : /*
518 : : * Initialize the scatterlist so that the magic cookie
519 : : * is filled if debugging is enabled
520 : : */
521 : 0 : sg_init_table(scatterlist, num_pages);
522 : : /* Now set the pages for each scatterlist */
523 [ # # ]: 0 : for (i = 0; i < num_pages; i++) {
524 : 0 : unsigned int len = PAGE_SIZE - offset;
525 : :
526 [ # # ]: 0 : if (len > count)
527 : : len = count;
528 : 0 : sg_set_page(scatterlist + i, pages[i], len, offset);
529 : : offset = 0;
530 : 0 : count -= len;
531 : : }
532 : :
533 : 0 : dma_buffers = dma_map_sg(g_dma_dev,
534 : : scatterlist,
535 : : num_pages,
536 : : pagelistinfo->dma_dir);
537 : :
538 [ # # ]: 0 : if (dma_buffers == 0) {
539 : 0 : cleanup_pagelistinfo(pagelistinfo);
540 : 0 : return NULL;
541 : : }
542 : :
543 : 0 : pagelistinfo->scatterlist_mapped = 1;
544 : :
545 : : /* Combine adjacent blocks for performance */
546 : : k = 0;
547 [ # # ]: 0 : if (g_use_36bit_addrs) {
548 [ # # ]: 0 : for_each_sg(scatterlist, sg, dma_buffers, i) {
549 : 0 : u32 len = sg_dma_len(sg);
550 : 0 : u64 addr = sg_dma_address(sg);
551 : 0 : u32 page_id = (u32)((addr >> 4) & ~0xff);
552 : 0 : u32 sg_pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
553 : :
554 : : /* Note: addrs is the address + page_count - 1
555 : : * The firmware expects blocks after the first to be page-
556 : : * aligned and a multiple of the page size
557 : : */
558 [ # # ]: 0 : WARN_ON(len == 0);
559 [ # # # # : 0 : WARN_ON(i &&
# # # # ]
560 : : (i != (dma_buffers - 1)) && (len & ~PAGE_MASK));
561 [ # # # # : 0 : WARN_ON(i && (addr & ~PAGE_MASK));
# # ]
562 [ # # ]: 0 : WARN_ON(upper_32_bits(addr) > 0xf);
563 [ # # # # ]: 0 : if (k > 0 &&
564 : 0 : ((addrs[k - 1] & ~0xff) +
565 : 0 : (((addrs[k - 1] & 0xff) + 1) << 8)
566 : : == page_id)) {
567 : 0 : u32 inc_pages = min(sg_pages,
568 : : 0xff - (addrs[k - 1] & 0xff));
569 : 0 : addrs[k - 1] += inc_pages;
570 : 0 : page_id += inc_pages << 8;
571 : 0 : sg_pages -= inc_pages;
572 : : }
573 [ # # ]: 0 : while (sg_pages) {
574 : 0 : u32 inc_pages = min(sg_pages, 0x100u);
575 : 0 : addrs[k++] = page_id | (inc_pages - 1);
576 : 0 : page_id += inc_pages << 8;
577 : 0 : sg_pages -= inc_pages;
578 : : }
579 : : }
580 : : } else {
581 [ # # ]: 0 : for_each_sg(scatterlist, sg, dma_buffers, i) {
582 : 0 : u32 len = sg_dma_len(sg);
583 : 0 : u32 addr = sg_dma_address(sg);
584 : 0 : u32 new_pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
585 : :
586 : : /* Note: addrs is the address + page_count - 1
587 : : * The firmware expects blocks after the first to be page-
588 : : * aligned and a multiple of the page size
589 : : */
590 [ # # ]: 0 : WARN_ON(len == 0);
591 [ # # # # : 0 : WARN_ON(i && (i != (dma_buffers - 1)) && (len & ~PAGE_MASK));
# # # # ]
592 [ # # # # : 0 : WARN_ON(i && (addr & ~PAGE_MASK));
# # ]
593 [ # # # # ]: 0 : if (k > 0 &&
594 : 0 : ((addrs[k - 1] & PAGE_MASK) +
595 : 0 : (((addrs[k - 1] & ~PAGE_MASK) + 1) << PAGE_SHIFT))
596 : 0 : == (addr & PAGE_MASK))
597 : 0 : addrs[k - 1] += new_pages;
598 : : else
599 : 0 : addrs[k++] = (addr & PAGE_MASK) | (new_pages - 1);
600 : : }
601 : : }
602 : :
603 : : /* Partial cache lines (fragments) require special measures */
604 [ # # # # ]: 0 : if ((type == PAGELIST_READ) &&
605 [ # # ]: 0 : ((pagelist->offset & (g_cache_line_size - 1)) ||
606 : 0 : ((pagelist->offset + pagelist->length) &
607 : : (g_cache_line_size - 1)))) {
608 : : char *fragments;
609 : :
610 [ # # ]: 0 : if (down_interruptible(&g_free_fragments_sema)) {
611 : 0 : cleanup_pagelistinfo(pagelistinfo);
612 : 0 : return NULL;
613 : : }
614 : :
615 [ # # ]: 0 : WARN_ON(g_free_fragments == NULL);
616 : :
617 : 0 : down(&g_free_fragments_mutex);
618 : 0 : fragments = g_free_fragments;
619 [ # # ]: 0 : WARN_ON(fragments == NULL);
620 : 0 : g_free_fragments = *(char **) g_free_fragments;
621 : 0 : up(&g_free_fragments_mutex);
622 : 0 : pagelist->type = PAGELIST_READ_WITH_FRAGMENTS +
623 : 0 : (fragments - g_fragments_base) / g_fragments_size;
624 : : }
625 : :
626 : 0 : return pagelistinfo;
627 : : }
628 : :
629 : : static void
630 : 0 : free_pagelist(struct vchiq_pagelist_info *pagelistinfo,
631 : : int actual)
632 : : {
633 : 0 : struct pagelist *pagelist = pagelistinfo->pagelist;
634 : 0 : struct page **pages = pagelistinfo->pages;
635 : 0 : unsigned int num_pages = pagelistinfo->num_pages;
636 : :
637 [ # # ]: 0 : vchiq_log_trace(vchiq_arm_log_level, "%s - %pK, %d",
638 : : __func__, pagelistinfo->pagelist, actual);
639 : :
640 : : /*
641 : : * NOTE: dma_unmap_sg must be called before the
642 : : * cpu can touch any of the data/pages.
643 : : */
644 : 0 : dma_unmap_sg(g_dma_dev, pagelistinfo->scatterlist,
645 : : pagelistinfo->num_pages, pagelistinfo->dma_dir);
646 : 0 : pagelistinfo->scatterlist_mapped = 0;
647 : :
648 : : /* Deal with any partial cache lines (fragments) */
649 [ # # ]: 0 : if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS) {
650 : 0 : char *fragments = g_fragments_base +
651 : 0 : (pagelist->type - PAGELIST_READ_WITH_FRAGMENTS) *
652 : : g_fragments_size;
653 : : int head_bytes, tail_bytes;
654 : :
655 : 0 : head_bytes = (g_cache_line_size - pagelist->offset) &
656 : 0 : (g_cache_line_size - 1);
657 : 0 : tail_bytes = (pagelist->offset + actual) &
658 : : (g_cache_line_size - 1);
659 : :
660 [ # # ]: 0 : if ((actual >= 0) && (head_bytes != 0)) {
661 [ # # ]: 0 : if (head_bytes > actual)
662 : : head_bytes = actual;
663 : :
664 : 0 : memcpy((char *)kmap(pages[0]) +
665 : 0 : pagelist->offset,
666 : : fragments,
667 : : head_bytes);
668 : : kunmap(pages[0]);
669 : : }
670 [ # # # # ]: 0 : if ((actual >= 0) && (head_bytes < actual) &&
671 : : (tail_bytes != 0)) {
672 : 0 : memcpy((char *)kmap(pages[num_pages - 1]) +
673 : 0 : ((pagelist->offset + actual) &
674 : 0 : (PAGE_SIZE - 1) & ~(g_cache_line_size - 1)),
675 : : fragments + g_cache_line_size,
676 : : tail_bytes);
677 : : kunmap(pages[num_pages - 1]);
678 : : }
679 : :
680 : 0 : down(&g_free_fragments_mutex);
681 : 0 : *(char **)fragments = g_free_fragments;
682 : 0 : g_free_fragments = fragments;
683 : 0 : up(&g_free_fragments_mutex);
684 : 0 : up(&g_free_fragments_sema);
685 : : }
686 : :
687 : : /* Need to mark all the pages dirty. */
688 [ # # # # ]: 0 : if (pagelist->type != PAGELIST_WRITE &&
689 : 0 : pagelistinfo->pages_need_release) {
690 : : unsigned int i;
691 : :
692 [ # # ]: 0 : for (i = 0; i < num_pages; i++)
693 : 0 : set_page_dirty(pages[i]);
694 : : }
695 : :
696 : 0 : cleanup_pagelistinfo(pagelistinfo);
697 : 0 : }
|
