Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'dma-mapping-4.21-1' of git://git.infradead.org/users/hch/dma-mapping
Pull dma-mapping fixes from Christoph Hellwig:
"Fix various regressions introduced in this cycles:
- fix dma-debug tracking for the map_page / map_single
consolidatation
- properly stub out DMA mapping symbols for !HAS_DMA builds to avoid
link failures
- fix AMD Gart direct mappings
- setup the dma address for no kernel mappings using the remap
allocator"
* tag 'dma-mapping-4.21-1' of git://git.infradead.org/users/hch/dma-mapping:
dma-direct: fix DMA_ATTR_NO_KERNEL_MAPPING for remapped allocations
x86/amd_gart: fix unmapping of non-GART mappings
dma-mapping: remove a few unused exports
dma-mapping: properly stub out the DMA API for !CONFIG_HAS_DMA
dma-mapping: remove dmam_{declare,release}_coherent_memory
dma-mapping: implement dmam_alloc_coherent using dmam_alloc_attrs
dma-mapping: implement dma_map_single_attrs using dma_map_page_attrs
+215
-275
-1
Documentation/driver-model/devres.txt
-1
Documentation/driver-model/devres.txt
+9
-1
arch/x86/kernel/amd_gart_64.c
+9
-1
arch/x86/kernel/amd_gart_64.c
···
256
256
int npages;
257
257
int i;
258
258
259
-
if (dma_addr == DMA_MAPPING_ERROR ||
259
+
if (WARN_ON_ONCE(dma_addr == DMA_MAPPING_ERROR))
260
+
return;
261
+
262
+
/*
263
+
* This driver will not always use a GART mapping, but might have
264
+
* created a direct mapping instead. If that is the case there is
265
+
* nothing to unmap here.
266
+
*/
267
+
if (dma_addr < iommu_bus_base ||
260
268
dma_addr >= iommu_bus_base + iommu_size)
261
269
return;
262
270
+4
-7
include/linux/dma-debug.h
+4
-7
include/linux/dma-debug.h
···
35
35
36
36
extern void debug_dma_map_page(struct device *dev, struct page *page,
37
37
size_t offset, size_t size,
38
-
int direction, dma_addr_t dma_addr,
39
-
bool map_single);
38
+
int direction, dma_addr_t dma_addr);
40
39
41
40
extern void debug_dma_mapping_error(struct device *dev, dma_addr_t dma_addr);
42
41
43
42
extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
44
-
size_t size, int direction, bool map_single);
43
+
size_t size, int direction);
45
44
46
45
extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
47
46
int nents, int mapped_ents, int direction);
···
94
95
95
96
static inline void debug_dma_map_page(struct device *dev, struct page *page,
96
97
size_t offset, size_t size,
97
-
int direction, dma_addr_t dma_addr,
98
-
bool map_single)
98
+
int direction, dma_addr_t dma_addr)
99
99
{
100
100
}
101
101
···
104
106
}
105
107
106
108
static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
107
-
size_t size, int direction,
108
-
bool map_single)
109
+
size_t size, int direction)
109
110
{
110
111
}
111
112
+191
-149
include/linux/dma-mapping.h
+191
-149
include/linux/dma-mapping.h
···
194
194
}
195
195
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
196
196
197
-
#ifdef CONFIG_HAS_DMA
198
-
#include <asm/dma-mapping.h>
199
-
static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
200
-
{
201
-
if (dev && dev->dma_ops)
202
-
return dev->dma_ops;
203
-
return get_arch_dma_ops(dev ? dev->bus : NULL);
204
-
}
205
-
206
-
static inline void set_dma_ops(struct device *dev,
207
-
const struct dma_map_ops *dma_ops)
208
-
{
209
-
dev->dma_ops = dma_ops;
210
-
}
211
-
#else
212
-
/*
213
-
* Define the dma api to allow compilation of dma dependent code.
214
-
* Code that depends on the dma-mapping API needs to set 'depends on HAS_DMA'
215
-
* in its Kconfig, unless it already depends on <something> || COMPILE_TEST,
216
-
* where <something> guarantuees the availability of the dma-mapping API.
217
-
*/
218
-
static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
219
-
{
220
-
return NULL;
221
-
}
222
-
#endif
223
-
224
197
static inline bool dma_is_direct(const struct dma_map_ops *ops)
225
198
{
226
199
return likely(!ops);
···
257
284
}
258
285
#endif
259
286
260
-
static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
261
-
size_t size,
262
-
enum dma_data_direction dir,
263
-
unsigned long attrs)
287
+
#ifdef CONFIG_HAS_DMA
288
+
#include <asm/dma-mapping.h>
289
+
290
+
static inline const struct dma_map_ops *get_dma_ops(struct device *dev)
291
+
{
292
+
if (dev && dev->dma_ops)
293
+
return dev->dma_ops;
294
+
return get_arch_dma_ops(dev ? dev->bus : NULL);
295
+
}
296
+
297
+
static inline void set_dma_ops(struct device *dev,
298
+
const struct dma_map_ops *dma_ops)
299
+
{
300
+
dev->dma_ops = dma_ops;
301
+
}
302
+
303
+
static inline dma_addr_t dma_map_page_attrs(struct device *dev,
304
+
struct page *page, size_t offset, size_t size,
305
+
enum dma_data_direction dir, unsigned long attrs)
264
306
{
265
307
const struct dma_map_ops *ops = get_dma_ops(dev);
266
308
dma_addr_t addr;
267
309
268
310
BUG_ON(!valid_dma_direction(dir));
269
-
debug_dma_map_single(dev, ptr, size);
270
311
if (dma_is_direct(ops))
271
-
addr = dma_direct_map_page(dev, virt_to_page(ptr),
272
-
offset_in_page(ptr), size, dir, attrs);
312
+
addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
273
313
else
274
-
addr = ops->map_page(dev, virt_to_page(ptr),
275
-
offset_in_page(ptr), size, dir, attrs);
276
-
debug_dma_map_page(dev, virt_to_page(ptr),
277
-
offset_in_page(ptr), size,
278
-
dir, addr, true);
314
+
addr = ops->map_page(dev, page, offset, size, dir, attrs);
315
+
debug_dma_map_page(dev, page, offset, size, dir, addr);
316
+
279
317
return addr;
280
318
}
281
319
282
-
static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
283
-
size_t size,
284
-
enum dma_data_direction dir,
285
-
unsigned long attrs)
320
+
static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
321
+
size_t size, enum dma_data_direction dir, unsigned long attrs)
286
322
{
287
323
const struct dma_map_ops *ops = get_dma_ops(dev);
288
324
···
300
318
dma_direct_unmap_page(dev, addr, size, dir, attrs);
301
319
else if (ops->unmap_page)
302
320
ops->unmap_page(dev, addr, size, dir, attrs);
303
-
debug_dma_unmap_page(dev, addr, size, dir, true);
304
-
}
305
-
306
-
static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
307
-
size_t size, enum dma_data_direction dir, unsigned long attrs)
308
-
{
309
-
return dma_unmap_single_attrs(dev, addr, size, dir, attrs);
321
+
debug_dma_unmap_page(dev, addr, size, dir);
310
322
}
311
323
312
324
/*
···
337
361
dma_direct_unmap_sg(dev, sg, nents, dir, attrs);
338
362
else if (ops->unmap_sg)
339
363
ops->unmap_sg(dev, sg, nents, dir, attrs);
340
-
}
341
-
342
-
static inline dma_addr_t dma_map_page_attrs(struct device *dev,
343
-
struct page *page,
344
-
size_t offset, size_t size,
345
-
enum dma_data_direction dir,
346
-
unsigned long attrs)
347
-
{
348
-
const struct dma_map_ops *ops = get_dma_ops(dev);
349
-
dma_addr_t addr;
350
-
351
-
BUG_ON(!valid_dma_direction(dir));
352
-
if (dma_is_direct(ops))
353
-
addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
354
-
else
355
-
addr = ops->map_page(dev, page, offset, size, dir, attrs);
356
-
debug_dma_map_page(dev, page, offset, size, dir, addr, false);
357
-
358
-
return addr;
359
364
}
360
365
361
366
static inline dma_addr_t dma_map_resource(struct device *dev,
···
388
431
debug_dma_sync_single_for_cpu(dev, addr, size, dir);
389
432
}
390
433
391
-
static inline void dma_sync_single_range_for_cpu(struct device *dev,
392
-
dma_addr_t addr, unsigned long offset, size_t size,
393
-
enum dma_data_direction dir)
394
-
{
395
-
return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
396
-
}
397
-
398
434
static inline void dma_sync_single_for_device(struct device *dev,
399
435
dma_addr_t addr, size_t size,
400
436
enum dma_data_direction dir)
···
400
450
else if (ops->sync_single_for_device)
401
451
ops->sync_single_for_device(dev, addr, size, dir);
402
452
debug_dma_sync_single_for_device(dev, addr, size, dir);
403
-
}
404
-
405
-
static inline void dma_sync_single_range_for_device(struct device *dev,
406
-
dma_addr_t addr, unsigned long offset, size_t size,
407
-
enum dma_data_direction dir)
408
-
{
409
-
return dma_sync_single_for_device(dev, addr + offset, size, dir);
410
453
}
411
454
412
455
static inline void
···
431
488
432
489
}
433
490
491
+
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
492
+
{
493
+
debug_dma_mapping_error(dev, dma_addr);
494
+
495
+
if (dma_addr == DMA_MAPPING_ERROR)
496
+
return -ENOMEM;
497
+
return 0;
498
+
}
499
+
500
+
void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
501
+
gfp_t flag, unsigned long attrs);
502
+
void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
503
+
dma_addr_t dma_handle, unsigned long attrs);
504
+
void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
505
+
gfp_t gfp, unsigned long attrs);
506
+
void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
507
+
dma_addr_t dma_handle);
508
+
void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
509
+
enum dma_data_direction dir);
510
+
int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
511
+
void *cpu_addr, dma_addr_t dma_addr, size_t size,
512
+
unsigned long attrs);
513
+
int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
514
+
void *cpu_addr, dma_addr_t dma_addr, size_t size,
515
+
unsigned long attrs);
516
+
int dma_supported(struct device *dev, u64 mask);
517
+
int dma_set_mask(struct device *dev, u64 mask);
518
+
int dma_set_coherent_mask(struct device *dev, u64 mask);
519
+
u64 dma_get_required_mask(struct device *dev);
520
+
#else /* CONFIG_HAS_DMA */
521
+
static inline dma_addr_t dma_map_page_attrs(struct device *dev,
522
+
struct page *page, size_t offset, size_t size,
523
+
enum dma_data_direction dir, unsigned long attrs)
524
+
{
525
+
return DMA_MAPPING_ERROR;
526
+
}
527
+
static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr,
528
+
size_t size, enum dma_data_direction dir, unsigned long attrs)
529
+
{
530
+
}
531
+
static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
532
+
int nents, enum dma_data_direction dir, unsigned long attrs)
533
+
{
534
+
return 0;
535
+
}
536
+
static inline void dma_unmap_sg_attrs(struct device *dev,
537
+
struct scatterlist *sg, int nents, enum dma_data_direction dir,
538
+
unsigned long attrs)
539
+
{
540
+
}
541
+
static inline dma_addr_t dma_map_resource(struct device *dev,
542
+
phys_addr_t phys_addr, size_t size, enum dma_data_direction dir,
543
+
unsigned long attrs)
544
+
{
545
+
return DMA_MAPPING_ERROR;
546
+
}
547
+
static inline void dma_unmap_resource(struct device *dev, dma_addr_t addr,
548
+
size_t size, enum dma_data_direction dir, unsigned long attrs)
549
+
{
550
+
}
551
+
static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
552
+
size_t size, enum dma_data_direction dir)
553
+
{
554
+
}
555
+
static inline void dma_sync_single_for_device(struct device *dev,
556
+
dma_addr_t addr, size_t size, enum dma_data_direction dir)
557
+
{
558
+
}
559
+
static inline void dma_sync_sg_for_cpu(struct device *dev,
560
+
struct scatterlist *sg, int nelems, enum dma_data_direction dir)
561
+
{
562
+
}
563
+
static inline void dma_sync_sg_for_device(struct device *dev,
564
+
struct scatterlist *sg, int nelems, enum dma_data_direction dir)
565
+
{
566
+
}
567
+
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
568
+
{
569
+
return -ENOMEM;
570
+
}
571
+
static inline void *dma_alloc_attrs(struct device *dev, size_t size,
572
+
dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
573
+
{
574
+
return NULL;
575
+
}
576
+
static void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
577
+
dma_addr_t dma_handle, unsigned long attrs)
578
+
{
579
+
}
580
+
static inline void *dmam_alloc_attrs(struct device *dev, size_t size,
581
+
dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
582
+
{
583
+
return NULL;
584
+
}
585
+
static inline void dmam_free_coherent(struct device *dev, size_t size,
586
+
void *vaddr, dma_addr_t dma_handle)
587
+
{
588
+
}
589
+
static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
590
+
enum dma_data_direction dir)
591
+
{
592
+
}
593
+
static inline int dma_get_sgtable_attrs(struct device *dev,
594
+
struct sg_table *sgt, void *cpu_addr, dma_addr_t dma_addr,
595
+
size_t size, unsigned long attrs)
596
+
{
597
+
return -ENXIO;
598
+
}
599
+
static inline int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
600
+
void *cpu_addr, dma_addr_t dma_addr, size_t size,
601
+
unsigned long attrs)
602
+
{
603
+
return -ENXIO;
604
+
}
605
+
static inline int dma_supported(struct device *dev, u64 mask)
606
+
{
607
+
return 0;
608
+
}
609
+
static inline int dma_set_mask(struct device *dev, u64 mask)
610
+
{
611
+
return -EIO;
612
+
}
613
+
static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
614
+
{
615
+
return -EIO;
616
+
}
617
+
static inline u64 dma_get_required_mask(struct device *dev)
618
+
{
619
+
return 0;
620
+
}
621
+
#endif /* CONFIG_HAS_DMA */
622
+
623
+
static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
624
+
size_t size, enum dma_data_direction dir, unsigned long attrs)
625
+
{
626
+
debug_dma_map_single(dev, ptr, size);
627
+
return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr),
628
+
size, dir, attrs);
629
+
}
630
+
631
+
static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
632
+
size_t size, enum dma_data_direction dir, unsigned long attrs)
633
+
{
634
+
return dma_unmap_page_attrs(dev, addr, size, dir, attrs);
635
+
}
636
+
637
+
static inline void dma_sync_single_range_for_cpu(struct device *dev,
638
+
dma_addr_t addr, unsigned long offset, size_t size,
639
+
enum dma_data_direction dir)
640
+
{
641
+
return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
642
+
}
643
+
644
+
static inline void dma_sync_single_range_for_device(struct device *dev,
645
+
dma_addr_t addr, unsigned long offset, size_t size,
646
+
enum dma_data_direction dir)
647
+
{
648
+
return dma_sync_single_for_device(dev, addr + offset, size, dir);
649
+
}
650
+
434
651
#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0)
435
652
#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0)
436
653
#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)
437
654
#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)
438
655
#define dma_map_page(d, p, o, s, r) dma_map_page_attrs(d, p, o, s, r, 0)
439
656
#define dma_unmap_page(d, a, s, r) dma_unmap_page_attrs(d, a, s, r, 0)
440
-
441
-
void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
442
-
enum dma_data_direction dir);
657
+
#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
658
+
#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
443
659
444
660
extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
445
661
void *cpu_addr, dma_addr_t dma_addr, size_t size,
···
618
516
void *dma_alloc_from_pool(size_t size, struct page **ret_page, gfp_t flags);
619
517
bool dma_free_from_pool(void *start, size_t size);
620
518
621
-
int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
622
-
void *cpu_addr, dma_addr_t dma_addr, size_t size,
623
-
unsigned long attrs);
624
-
#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
625
-
626
519
int
627
520
dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,
628
521
dma_addr_t dma_addr, size_t size, unsigned long attrs);
629
-
630
-
int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
631
-
void *cpu_addr, dma_addr_t dma_addr, size_t size,
632
-
unsigned long attrs);
633
-
#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
634
-
635
-
void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
636
-
gfp_t flag, unsigned long attrs);
637
-
void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
638
-
dma_addr_t dma_handle, unsigned long attrs);
639
522
640
523
static inline void *dma_alloc_coherent(struct device *dev, size_t size,
641
524
dma_addr_t *dma_handle, gfp_t gfp)
···
636
549
return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);
637
550
}
638
551
639
-
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
640
-
{
641
-
debug_dma_mapping_error(dev, dma_addr);
642
-
643
-
if (dma_addr == DMA_MAPPING_ERROR)
644
-
return -ENOMEM;
645
-
return 0;
646
-
}
647
-
648
-
int dma_supported(struct device *dev, u64 mask);
649
-
int dma_set_mask(struct device *dev, u64 mask);
650
-
int dma_set_coherent_mask(struct device *dev, u64 mask);
651
552
652
553
static inline u64 dma_get_mask(struct device *dev)
653
554
{
···
667
592
dev->dma_mask = &dev->coherent_dma_mask;
668
593
return dma_set_mask_and_coherent(dev, mask);
669
594
}
670
-
671
-
extern u64 dma_get_required_mask(struct device *dev);
672
595
673
596
#ifndef arch_setup_dma_ops
674
597
static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base,
···
764
691
}
765
692
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
766
693
767
-
/*
768
-
* Managed DMA API
769
-
*/
770
-
#ifdef CONFIG_HAS_DMA
771
-
extern void *dmam_alloc_coherent(struct device *dev, size_t size,
772
-
dma_addr_t *dma_handle, gfp_t gfp);
773
-
extern void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
774
-
dma_addr_t dma_handle);
775
-
#else /* !CONFIG_HAS_DMA */
776
694
static inline void *dmam_alloc_coherent(struct device *dev, size_t size,
777
-
dma_addr_t *dma_handle, gfp_t gfp)
778
-
{ return NULL; }
779
-
static inline void dmam_free_coherent(struct device *dev, size_t size,
780
-
void *vaddr, dma_addr_t dma_handle) { }
781
-
#endif /* !CONFIG_HAS_DMA */
782
-
783
-
extern void *dmam_alloc_attrs(struct device *dev, size_t size,
784
-
dma_addr_t *dma_handle, gfp_t gfp,
785
-
unsigned long attrs);
786
-
#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
787
-
extern int dmam_declare_coherent_memory(struct device *dev,
788
-
phys_addr_t phys_addr,
789
-
dma_addr_t device_addr, size_t size,
790
-
int flags);
791
-
extern void dmam_release_declared_memory(struct device *dev);
792
-
#else /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
793
-
static inline int dmam_declare_coherent_memory(struct device *dev,
794
-
phys_addr_t phys_addr, dma_addr_t device_addr,
795
-
size_t size, gfp_t gfp)
695
+
dma_addr_t *dma_handle, gfp_t gfp)
796
696
{
797
-
return 0;
697
+
return dmam_alloc_attrs(dev, size, dma_handle, gfp,
698
+
(gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0);
798
699
}
799
-
800
-
static inline void dmam_release_declared_memory(struct device *dev)
801
-
{
802
-
}
803
-
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
804
700
805
701
static inline void *dma_alloc_wc(struct device *dev, size_t size,
806
702
dma_addr_t *dma_addr, gfp_t gfp)
-2
kernel/dma/coherent.c
-2
kernel/dma/coherent.c
···
223
223
*/
224
224
return mem->flags & DMA_MEMORY_EXCLUSIVE;
225
225
}
226
-
EXPORT_SYMBOL(dma_alloc_from_dev_coherent);
227
226
228
227
void *dma_alloc_from_global_coherent(ssize_t size, dma_addr_t *dma_handle)
229
228
{
···
267
268
268
269
return __dma_release_from_coherent(mem, order, vaddr);
269
270
}
270
-
EXPORT_SYMBOL(dma_release_from_dev_coherent);
271
271
272
272
int dma_release_from_global_coherent(int order, void *vaddr)
273
273
{
+4
-15
kernel/dma/debug.c
+4
-15
kernel/dma/debug.c
···
49
49
50
50
enum {
51
51
dma_debug_single,
52
-
dma_debug_page,
53
52
dma_debug_sg,
54
53
dma_debug_coherent,
55
54
dma_debug_resource,
···
1299
1300
EXPORT_SYMBOL(debug_dma_map_single);
1300
1301
1301
1302
void debug_dma_map_page(struct device *dev, struct page *page, size_t offset,
1302
-
size_t size, int direction, dma_addr_t dma_addr,
1303
-
bool map_single)
1303
+
size_t size, int direction, dma_addr_t dma_addr)
1304
1304
{
1305
1305
struct dma_debug_entry *entry;
1306
1306
···
1314
1316
return;
1315
1317
1316
1318
entry->dev = dev;
1317
-
entry->type = dma_debug_page;
1319
+
entry->type = dma_debug_single;
1318
1320
entry->pfn = page_to_pfn(page);
1319
1321
entry->offset = offset,
1320
1322
entry->dev_addr = dma_addr;
1321
1323
entry->size = size;
1322
1324
entry->direction = direction;
1323
1325
entry->map_err_type = MAP_ERR_NOT_CHECKED;
1324
-
1325
-
if (map_single)
1326
-
entry->type = dma_debug_single;
1327
1326
1328
1327
check_for_stack(dev, page, offset);
1329
1328
···
1373
1378
EXPORT_SYMBOL(debug_dma_mapping_error);
1374
1379
1375
1380
void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
1376
-
size_t size, int direction, bool map_single)
1381
+
size_t size, int direction)
1377
1382
{
1378
1383
struct dma_debug_entry ref = {
1379
-
.type = dma_debug_page,
1384
+
.type = dma_debug_single,
1380
1385
.dev = dev,
1381
1386
.dev_addr = addr,
1382
1387
.size = size,
···
1385
1390
1386
1391
if (unlikely(dma_debug_disabled()))
1387
1392
return;
1388
-
1389
-
if (map_single)
1390
-
ref.type = dma_debug_single;
1391
-
1392
1393
check_unmap(&ref);
1393
1394
}
1394
1395
EXPORT_SYMBOL(debug_dma_unmap_page);
···
1512
1521
1513
1522
add_dma_entry(entry);
1514
1523
}
1515
-
EXPORT_SYMBOL(debug_dma_alloc_coherent);
1516
1524
1517
1525
void debug_dma_free_coherent(struct device *dev, size_t size,
1518
1526
void *virt, dma_addr_t addr)
···
1539
1549
1540
1550
check_unmap(&ref);
1541
1551
}
1542
-
EXPORT_SYMBOL(debug_dma_free_coherent);
1543
1552
1544
1553
void debug_dma_map_resource(struct device *dev, phys_addr_t addr, size_t size,
1545
1554
int direction, dma_addr_t dma_addr)
-94
kernel/dma/mapping.c
-94
kernel/dma/mapping.c
···
46
46
}
47
47
48
48
/**
49
-
* dmam_alloc_coherent - Managed dma_alloc_coherent()
50
-
* @dev: Device to allocate coherent memory for
51
-
* @size: Size of allocation
52
-
* @dma_handle: Out argument for allocated DMA handle
53
-
* @gfp: Allocation flags
54
-
*
55
-
* Managed dma_alloc_coherent(). Memory allocated using this function
56
-
* will be automatically released on driver detach.
57
-
*
58
-
* RETURNS:
59
-
* Pointer to allocated memory on success, NULL on failure.
60
-
*/
61
-
void *dmam_alloc_coherent(struct device *dev, size_t size,
62
-
dma_addr_t *dma_handle, gfp_t gfp)
63
-
{
64
-
struct dma_devres *dr;
65
-
void *vaddr;
66
-
67
-
dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
68
-
if (!dr)
69
-
return NULL;
70
-
71
-
vaddr = dma_alloc_coherent(dev, size, dma_handle, gfp);
72
-
if (!vaddr) {
73
-
devres_free(dr);
74
-
return NULL;
75
-
}
76
-
77
-
dr->vaddr = vaddr;
78
-
dr->dma_handle = *dma_handle;
79
-
dr->size = size;
80
-
81
-
devres_add(dev, dr);
82
-
83
-
return vaddr;
84
-
}
85
-
EXPORT_SYMBOL(dmam_alloc_coherent);
86
-
87
-
/**
88
49
* dmam_free_coherent - Managed dma_free_coherent()
89
50
* @dev: Device to free coherent memory for
90
51
* @size: Size of allocation
···
104
143
return vaddr;
105
144
}
106
145
EXPORT_SYMBOL(dmam_alloc_attrs);
107
-
108
-
#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
109
-
110
-
static void dmam_coherent_decl_release(struct device *dev, void *res)
111
-
{
112
-
dma_release_declared_memory(dev);
113
-
}
114
-
115
-
/**
116
-
* dmam_declare_coherent_memory - Managed dma_declare_coherent_memory()
117
-
* @dev: Device to declare coherent memory for
118
-
* @phys_addr: Physical address of coherent memory to be declared
119
-
* @device_addr: Device address of coherent memory to be declared
120
-
* @size: Size of coherent memory to be declared
121
-
* @flags: Flags
122
-
*
123
-
* Managed dma_declare_coherent_memory().
124
-
*
125
-
* RETURNS:
126
-
* 0 on success, -errno on failure.
127
-
*/
128
-
int dmam_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
129
-
dma_addr_t device_addr, size_t size, int flags)
130
-
{
131
-
void *res;
132
-
int rc;
133
-
134
-
res = devres_alloc(dmam_coherent_decl_release, 0, GFP_KERNEL);
135
-
if (!res)
136
-
return -ENOMEM;
137
-
138
-
rc = dma_declare_coherent_memory(dev, phys_addr, device_addr, size,
139
-
flags);
140
-
if (!rc)
141
-
devres_add(dev, res);
142
-
else
143
-
devres_free(res);
144
-
145
-
return rc;
146
-
}
147
-
EXPORT_SYMBOL(dmam_declare_coherent_memory);
148
-
149
-
/**
150
-
* dmam_release_declared_memory - Managed dma_release_declared_memory().
151
-
* @dev: Device to release declared coherent memory for
152
-
*
153
-
* Managed dmam_release_declared_memory().
154
-
*/
155
-
void dmam_release_declared_memory(struct device *dev)
156
-
{
157
-
WARN_ON(devres_destroy(dev, dmam_coherent_decl_release, NULL, NULL));
158
-
}
159
-
EXPORT_SYMBOL(dmam_release_declared_memory);
160
-
161
-
#endif
162
146
163
147
/*
164
148
* Create scatter-list for the already allocated DMA buffer.
+7
-6
kernel/dma/remap.c
+7
-6
kernel/dma/remap.c
···
204
204
ret = dma_alloc_from_pool(size, &page, flags);
205
205
if (!ret)
206
206
return NULL;
207
-
*dma_handle = phys_to_dma(dev, page_to_phys(page));
208
-
return ret;
207
+
goto done;
209
208
}
210
209
211
210
page = __dma_direct_alloc_pages(dev, size, dma_handle, flags, attrs);
···
214
215
/* remove any dirty cache lines on the kernel alias */
215
216
arch_dma_prep_coherent(page, size);
216
217
217
-
if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
218
-
return page; /* opaque cookie */
218
+
if (attrs & DMA_ATTR_NO_KERNEL_MAPPING) {
219
+
ret = page; /* opaque cookie */
220
+
goto done;
221
+
}
219
222
220
223
/* create a coherent mapping */
221
224
ret = dma_common_contiguous_remap(page, size, VM_USERMAP,
···
228
227
return ret;
229
228
}
230
229
231
-
*dma_handle = phys_to_dma(dev, page_to_phys(page));
232
230
memset(ret, 0, size);
233
-
231
+
done:
232
+
*dma_handle = phys_to_dma(dev, page_to_phys(page));
234
233
return ret;
235
234
}
236
235