2 * arch/arm/common/dmabounce.c
4 * Special dma_{map/unmap/dma_sync}_* routines for systems that have
5 * limited DMA windows. These functions utilize bounce buffers to
6 * copy data to/from buffers located outside the DMA region. This
7 * only works for systems in which DMA memory is at the bottom of
8 * RAM, the remainder of memory is at the top and the DMA memory
9 * can be marked as ZONE_DMA. Anything beyond that such as discontiguous
10 * DMA windows will require custom implementations that reserve memory
11 * areas at early bootup.
13 * Original version by Brad Parker (brad@heeltoe.com)
14 * Re-written by Christopher Hoover <ch@murgatroid.com>
15 * Made generic by Deepak Saxena <dsaxena@plexity.net>
17 * Copyright (C) 2002 Hewlett Packard Company.
18 * Copyright (C) 2004 MontaVista Software, Inc.
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * version 2 as published by the Free Software Foundation.
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/device.h>
29 #include <linux/dma-mapping.h>
30 #include <linux/dmapool.h>
31 #include <linux/list.h>
32 #include <linux/scatterlist.h>
34 #include <asm/cacheflush.h>
39 #define DO_STATS(X) do { X ; } while (0)
41 #define DO_STATS(X) do { } while (0)
44 /* ************************************************** */
47 struct list_head node
;
49 /* original request */
54 /* safe buffer info */
55 struct dmabounce_pool
*pool
;
57 dma_addr_t safe_dma_addr
;
60 struct dmabounce_pool
{
62 struct dma_pool
*pool
;
68 struct dmabounce_device_info
{
70 struct list_head safe_buffers
;
72 unsigned long total_allocs
;
73 unsigned long map_op_count
;
74 unsigned long bounce_count
;
77 struct dmabounce_pool small
;
78 struct dmabounce_pool large
;
84 static ssize_t
dmabounce_show(struct device
*dev
, struct device_attribute
*attr
,
87 struct dmabounce_device_info
*device_info
= dev
->archdata
.dmabounce
;
88 return sprintf(buf
, "%lu %lu %lu %lu %lu %lu\n",
89 device_info
->small
.allocs
,
90 device_info
->large
.allocs
,
91 device_info
->total_allocs
- device_info
->small
.allocs
-
92 device_info
->large
.allocs
,
93 device_info
->total_allocs
,
94 device_info
->map_op_count
,
95 device_info
->bounce_count
);
98 static DEVICE_ATTR(dmabounce_stats
, 0400, dmabounce_show
, NULL
);
102 /* allocate a 'safe' buffer and keep track of it */
103 static inline struct safe_buffer
*
104 alloc_safe_buffer(struct dmabounce_device_info
*device_info
, void *ptr
,
105 size_t size
, enum dma_data_direction dir
)
107 struct safe_buffer
*buf
;
108 struct dmabounce_pool
*pool
;
109 struct device
*dev
= device_info
->dev
;
112 dev_dbg(dev
, "%s(ptr=%p, size=%d, dir=%d)\n",
113 __func__
, ptr
, size
, dir
);
115 if (size
<= device_info
->small
.size
) {
116 pool
= &device_info
->small
;
117 } else if (size
<= device_info
->large
.size
) {
118 pool
= &device_info
->large
;
123 buf
= kmalloc(sizeof(struct safe_buffer
), GFP_ATOMIC
);
125 dev_warn(dev
, "%s: kmalloc failed\n", __func__
);
131 buf
->direction
= dir
;
135 buf
->safe
= dma_pool_alloc(pool
->pool
, GFP_ATOMIC
,
136 &buf
->safe_dma_addr
);
138 buf
->safe
= dma_alloc_coherent(dev
, size
, &buf
->safe_dma_addr
,
142 if (buf
->safe
== NULL
) {
144 "%s: could not alloc dma memory (size=%d)\n",
153 device_info
->total_allocs
++;
156 write_lock_irqsave(&device_info
->lock
, flags
);
158 list_add(&buf
->node
, &device_info
->safe_buffers
);
160 write_unlock_irqrestore(&device_info
->lock
, flags
);
165 /* determine if a buffer is from our "safe" pool */
166 static inline struct safe_buffer
*
167 find_safe_buffer(struct dmabounce_device_info
*device_info
, dma_addr_t safe_dma_addr
)
169 struct safe_buffer
*b
, *rb
= NULL
;
172 read_lock_irqsave(&device_info
->lock
, flags
);
174 list_for_each_entry(b
, &device_info
->safe_buffers
, node
)
175 if (b
->safe_dma_addr
== safe_dma_addr
) {
180 read_unlock_irqrestore(&device_info
->lock
, flags
);
185 free_safe_buffer(struct dmabounce_device_info
*device_info
, struct safe_buffer
*buf
)
189 dev_dbg(device_info
->dev
, "%s(buf=%p)\n", __func__
, buf
);
191 write_lock_irqsave(&device_info
->lock
, flags
);
193 list_del(&buf
->node
);
195 write_unlock_irqrestore(&device_info
->lock
, flags
);
198 dma_pool_free(buf
->pool
->pool
, buf
->safe
, buf
->safe_dma_addr
);
200 dma_free_coherent(device_info
->dev
, buf
->size
, buf
->safe
,
206 /* ************************************************** */
208 static inline dma_addr_t
209 map_single(struct device
*dev
, void *ptr
, size_t size
,
210 enum dma_data_direction dir
)
212 struct dmabounce_device_info
*device_info
= dev
->archdata
.dmabounce
;
214 int needs_bounce
= 0;
217 DO_STATS ( device_info
->map_op_count
++ );
219 dma_addr
= virt_to_dma(dev
, ptr
);
222 unsigned long mask
= *dev
->dma_mask
;
225 limit
= (mask
+ 1) & ~mask
;
226 if (limit
&& size
> limit
) {
227 dev_err(dev
, "DMA mapping too big (requested %#x "
228 "mask %#Lx)\n", size
, *dev
->dma_mask
);
233 * Figure out if we need to bounce from the DMA mask.
235 needs_bounce
= (dma_addr
| (dma_addr
+ size
- 1)) & ~mask
;
238 if (device_info
&& (needs_bounce
|| dma_needs_bounce(dev
, dma_addr
, size
))) {
239 struct safe_buffer
*buf
;
241 buf
= alloc_safe_buffer(device_info
, ptr
, size
, dir
);
243 dev_err(dev
, "%s: unable to map unsafe buffer %p!\n",
249 "%s: unsafe buffer %p (phy=%p) mapped to %p (phy=%p)\n",
250 __func__
, buf
->ptr
, (void *) virt_to_dma(dev
, buf
->ptr
),
251 buf
->safe
, (void *) buf
->safe_dma_addr
);
253 if ((dir
== DMA_TO_DEVICE
) ||
254 (dir
== DMA_BIDIRECTIONAL
)) {
255 dev_dbg(dev
, "%s: copy unsafe %p to safe %p, size %d\n",
256 __func__
, ptr
, buf
->safe
, size
);
257 memcpy(buf
->safe
, ptr
, size
);
261 dma_addr
= buf
->safe_dma_addr
;
264 * We don't need to sync the DMA buffer since
265 * it was allocated via the coherent allocators.
267 dma_cache_maint(ptr
, size
, dir
);
274 unmap_single(struct device
*dev
, dma_addr_t dma_addr
, size_t size
,
275 enum dma_data_direction dir
)
277 struct dmabounce_device_info
*device_info
= dev
->archdata
.dmabounce
;
278 struct safe_buffer
*buf
= NULL
;
281 * Trying to unmap an invalid mapping
283 if (dma_mapping_error(dma_addr
)) {
284 dev_err(dev
, "Trying to unmap invalid mapping\n");
289 buf
= find_safe_buffer(device_info
, dma_addr
);
292 BUG_ON(buf
->size
!= size
);
295 "%s: unsafe buffer %p (phy=%p) mapped to %p (phy=%p)\n",
296 __func__
, buf
->ptr
, (void *) virt_to_dma(dev
, buf
->ptr
),
297 buf
->safe
, (void *) buf
->safe_dma_addr
);
299 DO_STATS ( device_info
->bounce_count
++ );
301 if (dir
== DMA_FROM_DEVICE
|| dir
== DMA_BIDIRECTIONAL
) {
302 void *ptr
= buf
->ptr
;
305 "%s: copy back safe %p to unsafe %p size %d\n",
306 __func__
, buf
->safe
, ptr
, size
);
307 memcpy(ptr
, buf
->safe
, size
);
310 * DMA buffers must have the same cache properties
311 * as if they were really used for DMA - which means
312 * data must be written back to RAM. Note that
313 * we don't use dmac_flush_range() here for the
314 * bidirectional case because we know the cache
315 * lines will be coherent with the data written.
317 dmac_clean_range(ptr
, ptr
+ size
);
318 outer_clean_range(__pa(ptr
), __pa(ptr
) + size
);
320 free_safe_buffer(device_info
, buf
);
325 sync_single(struct device
*dev
, dma_addr_t dma_addr
, size_t size
,
326 enum dma_data_direction dir
)
328 struct dmabounce_device_info
*device_info
= dev
->archdata
.dmabounce
;
329 struct safe_buffer
*buf
= NULL
;
332 buf
= find_safe_buffer(device_info
, dma_addr
);
336 * Both of these checks from original code need to be
337 * commented out b/c some drivers rely on the following:
339 * 1) Drivers may map a large chunk of memory into DMA space
340 * but only sync a small portion of it. Good example is
341 * allocating a large buffer, mapping it, and then
342 * breaking it up into small descriptors. No point
343 * in syncing the whole buffer if you only have to
344 * touch one descriptor.
346 * 2) Buffers that are mapped as DMA_BIDIRECTIONAL are
347 * usually only synced in one dir at a time.
349 * See drivers/net/eepro100.c for examples of both cases.
353 * BUG_ON(buf->size != size);
354 * BUG_ON(buf->direction != dir);
358 "%s: unsafe buffer %p (phy=%p) mapped to %p (phy=%p)\n",
359 __func__
, buf
->ptr
, (void *) virt_to_dma(dev
, buf
->ptr
),
360 buf
->safe
, (void *) buf
->safe_dma_addr
);
362 DO_STATS ( device_info
->bounce_count
++ );
365 case DMA_FROM_DEVICE
:
367 "%s: copy back safe %p to unsafe %p size %d\n",
368 __func__
, buf
->safe
, buf
->ptr
, size
);
369 memcpy(buf
->ptr
, buf
->safe
, size
);
373 "%s: copy out unsafe %p to safe %p, size %d\n",
374 __func__
,buf
->ptr
, buf
->safe
, size
);
375 memcpy(buf
->safe
, buf
->ptr
, size
);
377 case DMA_BIDIRECTIONAL
:
378 BUG(); /* is this allowed? what does it mean? */
383 * No need to sync the safe buffer - it was allocated
384 * via the coherent allocators.
387 dma_cache_maint(dma_to_virt(dev
, dma_addr
), size
, dir
);
391 /* ************************************************** */
394 * see if a buffer address is in an 'unsafe' range. if it is
395 * allocate a 'safe' buffer and copy the unsafe buffer into it.
396 * substitute the safe buffer for the unsafe one.
397 * (basically move the buffer from an unsafe area to a safe one)
400 dma_map_single(struct device
*dev
, void *ptr
, size_t size
,
401 enum dma_data_direction dir
)
405 dev_dbg(dev
, "%s(ptr=%p,size=%d,dir=%x)\n",
406 __func__
, ptr
, size
, dir
);
408 BUG_ON(dir
== DMA_NONE
);
410 dma_addr
= map_single(dev
, ptr
, size
, dir
);
416 * see if a mapped address was really a "safe" buffer and if so, copy
417 * the data from the safe buffer back to the unsafe buffer and free up
418 * the safe buffer. (basically return things back to the way they
423 dma_unmap_single(struct device
*dev
, dma_addr_t dma_addr
, size_t size
,
424 enum dma_data_direction dir
)
426 dev_dbg(dev
, "%s(ptr=%p,size=%d,dir=%x)\n",
427 __func__
, (void *) dma_addr
, size
, dir
);
429 BUG_ON(dir
== DMA_NONE
);
431 unmap_single(dev
, dma_addr
, size
, dir
);
435 dma_map_sg(struct device
*dev
, struct scatterlist
*sg
, int nents
,
436 enum dma_data_direction dir
)
440 dev_dbg(dev
, "%s(sg=%p,nents=%d,dir=%x)\n",
441 __func__
, sg
, nents
, dir
);
443 BUG_ON(dir
== DMA_NONE
);
445 for (i
= 0; i
< nents
; i
++, sg
++) {
446 struct page
*page
= sg_page(sg
);
447 unsigned int offset
= sg
->offset
;
448 unsigned int length
= sg
->length
;
449 void *ptr
= page_address(page
) + offset
;
452 map_single(dev
, ptr
, length
, dir
);
459 dma_unmap_sg(struct device
*dev
, struct scatterlist
*sg
, int nents
,
460 enum dma_data_direction dir
)
464 dev_dbg(dev
, "%s(sg=%p,nents=%d,dir=%x)\n",
465 __func__
, sg
, nents
, dir
);
467 BUG_ON(dir
== DMA_NONE
);
469 for (i
= 0; i
< nents
; i
++, sg
++) {
470 dma_addr_t dma_addr
= sg
->dma_address
;
471 unsigned int length
= sg
->length
;
473 unmap_single(dev
, dma_addr
, length
, dir
);
478 dma_sync_single_for_cpu(struct device
*dev
, dma_addr_t dma_addr
, size_t size
,
479 enum dma_data_direction dir
)
481 dev_dbg(dev
, "%s(ptr=%p,size=%d,dir=%x)\n",
482 __func__
, (void *) dma_addr
, size
, dir
);
484 sync_single(dev
, dma_addr
, size
, dir
);
488 dma_sync_single_for_device(struct device
*dev
, dma_addr_t dma_addr
, size_t size
,
489 enum dma_data_direction dir
)
491 dev_dbg(dev
, "%s(ptr=%p,size=%d,dir=%x)\n",
492 __func__
, (void *) dma_addr
, size
, dir
);
494 sync_single(dev
, dma_addr
, size
, dir
);
498 dma_sync_sg_for_cpu(struct device
*dev
, struct scatterlist
*sg
, int nents
,
499 enum dma_data_direction dir
)
503 dev_dbg(dev
, "%s(sg=%p,nents=%d,dir=%x)\n",
504 __func__
, sg
, nents
, dir
);
506 BUG_ON(dir
== DMA_NONE
);
508 for (i
= 0; i
< nents
; i
++, sg
++) {
509 dma_addr_t dma_addr
= sg
->dma_address
;
510 unsigned int length
= sg
->length
;
512 sync_single(dev
, dma_addr
, length
, dir
);
517 dma_sync_sg_for_device(struct device
*dev
, struct scatterlist
*sg
, int nents
,
518 enum dma_data_direction dir
)
522 dev_dbg(dev
, "%s(sg=%p,nents=%d,dir=%x)\n",
523 __func__
, sg
, nents
, dir
);
525 BUG_ON(dir
== DMA_NONE
);
527 for (i
= 0; i
< nents
; i
++, sg
++) {
528 dma_addr_t dma_addr
= sg
->dma_address
;
529 unsigned int length
= sg
->length
;
531 sync_single(dev
, dma_addr
, length
, dir
);
536 dmabounce_init_pool(struct dmabounce_pool
*pool
, struct device
*dev
, const char *name
,
540 DO_STATS(pool
->allocs
= 0);
541 pool
->pool
= dma_pool_create(name
, dev
, size
,
542 0 /* byte alignment */,
543 0 /* no page-crossing issues */);
545 return pool
->pool
? 0 : -ENOMEM
;
549 dmabounce_register_dev(struct device
*dev
, unsigned long small_buffer_size
,
550 unsigned long large_buffer_size
)
552 struct dmabounce_device_info
*device_info
;
555 device_info
= kmalloc(sizeof(struct dmabounce_device_info
), GFP_ATOMIC
);
558 "Could not allocated dmabounce_device_info\n");
562 ret
= dmabounce_init_pool(&device_info
->small
, dev
,
563 "small_dmabounce_pool", small_buffer_size
);
566 "dmabounce: could not allocate DMA pool for %ld byte objects\n",
571 if (large_buffer_size
) {
572 ret
= dmabounce_init_pool(&device_info
->large
, dev
,
573 "large_dmabounce_pool",
577 "dmabounce: could not allocate DMA pool for %ld byte objects\n",
583 device_info
->dev
= dev
;
584 INIT_LIST_HEAD(&device_info
->safe_buffers
);
585 rwlock_init(&device_info
->lock
);
588 device_info
->total_allocs
= 0;
589 device_info
->map_op_count
= 0;
590 device_info
->bounce_count
= 0;
591 device_info
->attr_res
= device_create_file(dev
, &dev_attr_dmabounce_stats
);
594 dev
->archdata
.dmabounce
= device_info
;
596 dev_info(dev
, "dmabounce: registered device\n");
601 dma_pool_destroy(device_info
->small
.pool
);
608 dmabounce_unregister_dev(struct device
*dev
)
610 struct dmabounce_device_info
*device_info
= dev
->archdata
.dmabounce
;
612 dev
->archdata
.dmabounce
= NULL
;
616 "Never registered with dmabounce but attempting"
621 if (!list_empty(&device_info
->safe_buffers
)) {
623 "Removing from dmabounce with pending buffers!\n");
627 if (device_info
->small
.pool
)
628 dma_pool_destroy(device_info
->small
.pool
);
629 if (device_info
->large
.pool
)
630 dma_pool_destroy(device_info
->large
.pool
);
633 if (device_info
->attr_res
== 0)
634 device_remove_file(dev
, &dev_attr_dmabounce_stats
);
639 dev_info(dev
, "dmabounce: device unregistered\n");
643 EXPORT_SYMBOL(dma_map_single
);
644 EXPORT_SYMBOL(dma_unmap_single
);
645 EXPORT_SYMBOL(dma_map_sg
);
646 EXPORT_SYMBOL(dma_unmap_sg
);
647 EXPORT_SYMBOL(dma_sync_single_for_cpu
);
648 EXPORT_SYMBOL(dma_sync_single_for_device
);
649 EXPORT_SYMBOL(dma_sync_sg_for_cpu
);
650 EXPORT_SYMBOL(dma_sync_sg_for_device
);
651 EXPORT_SYMBOL(dmabounce_register_dev
);
652 EXPORT_SYMBOL(dmabounce_unregister_dev
);
654 MODULE_AUTHOR("Christopher Hoover <ch@hpl.hp.com>, Deepak Saxena <dsaxena@plexity.net>");
655 MODULE_DESCRIPTION("Special dma_{map/unmap/dma_sync}_* routines for systems with limited DMA windows");
656 MODULE_LICENSE("GPL");