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
Showing the changes to include/linux (2 of 8 files). Show all
Unified · Split
| @@ -35,13 +35,12 @@ extern void debug_dma_map_single(struct device *dev, const void *addr, · 34 unmodified lines | ||
| 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); |
| @@ -95,8 +94,7 @@ static inline void debug_dma_map_single(struct device *dev, const void *addr, · 47 unmodified lines | ||
| 95 | 94 | |
| 96 | 95 | static inline void debug_dma_map_page(struct device *dev, struct page *page, |
| 97 | 96 | size_t offset, size_t size, |
| 98 | − int direction, dma_addr_t dma_addr, | |
| 99 | − bool map_single) | |
| 97 | + int direction, dma_addr_t dma_addr) | |
| 100 | 98 | { |
| 101 | 99 | } |
| 102 | 100 | |
| @@ -106,8 +104,7 @@ static inline void debug_dma_mapping_error(struct device *dev, · 3 unmodified lines | ||
| 106 | 104 | } |
| 107 | 105 | |
| 108 | 106 | static inline void debug_dma_unmap_page(struct device *dev, dma_addr_t addr, |
| 109 | − size_t size, int direction, | |
| 110 | − bool map_single) | |
| 107 | + size_t size, int direction) | |
| 111 | 108 | { |
| 112 | 109 | } |
| 113 | 110 | |
| @@ -194,33 +194,6 @@ static inline int dma_mmap_from_global_coherent(struct vm_area_struct *vma, · 193 unmodified lines | ||
| 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); |
| @@ -284,32 +257,41 @@ static inline void dma_direct_sync_sg_for_cpu(struct device *dev, · 57 unmodified lines | ||
| 284 | 257 | } |
| 285 | 258 | #endif |
| 286 | 259 | |
| 287 | −static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, | |
| 288 | − size_t size, | |
| 289 | − enum dma_data_direction dir, | |
| 290 | − unsigned long attrs) | |
| 260 | +#ifdef CONFIG_HAS_DMA | |
| 261 | +#include <asm/dma-mapping.h> | |
| 262 | + | |
| 263 | +static inline const struct dma_map_ops *get_dma_ops(struct device *dev) | |
| 264 | +{ | |
| 265 | + if (dev && dev->dma_ops) | |
| 266 | + return dev->dma_ops; | |
| 267 | + return get_arch_dma_ops(dev ? dev->bus : NULL); | |
| 268 | +} | |
| 269 | + | |
| 270 | +static inline void set_dma_ops(struct device *dev, | |
| 271 | + const struct dma_map_ops *dma_ops) | |
| 272 | +{ | |
| 273 | + dev->dma_ops = dma_ops; | |
| 274 | +} | |
| 275 | + | |
| 276 | +static inline dma_addr_t dma_map_page_attrs(struct device *dev, | |
| 277 | + struct page *page, size_t offset, size_t size, | |
| 278 | + enum dma_data_direction dir, unsigned long attrs) | |
| 291 | 279 | { |
| 292 | 280 | const struct dma_map_ops *ops = get_dma_ops(dev); |
| 293 | 281 | dma_addr_t addr; |
| 294 | 282 | |
| 295 | 283 | BUG_ON(!valid_dma_direction(dir)); |
| 296 | − debug_dma_map_single(dev, ptr, size); | |
| 297 | 284 | if (dma_is_direct(ops)) |
| 298 | − addr = dma_direct_map_page(dev, virt_to_page(ptr), | |
| 299 | − offset_in_page(ptr), size, dir, attrs); | |
| 285 | + addr = dma_direct_map_page(dev, page, offset, size, dir, attrs); | |
| 300 | 286 | else |
| 301 | − addr = ops->map_page(dev, virt_to_page(ptr), | |
| 302 | − offset_in_page(ptr), size, dir, attrs); | |
| 303 | − debug_dma_map_page(dev, virt_to_page(ptr), | |
| 304 | − offset_in_page(ptr), size, | |
| 305 | − dir, addr, true); | |
| 287 | + addr = ops->map_page(dev, page, offset, size, dir, attrs); | |
| 288 | + debug_dma_map_page(dev, page, offset, size, dir, addr); | |
| 289 | + | |
| 306 | 290 | return addr; |
| 307 | 291 | } |
| 308 | 292 | |
| 309 | −static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, | |
| 310 | − size_t size, | |
| 311 | − enum dma_data_direction dir, | |
| 312 | − unsigned long attrs) | |
| 293 | +static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr, | |
| 294 | + size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 313 | 295 | { |
| 314 | 296 | const struct dma_map_ops *ops = get_dma_ops(dev); |
| 315 | 297 | |
| @@ -318,13 +300,7 @@ static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, · 2 unmodified lines | ||
| 318 | 300 | dma_direct_unmap_page(dev, addr, size, dir, attrs); |
| 319 | 301 | else if (ops->unmap_page) |
| 320 | 302 | ops->unmap_page(dev, addr, size, dir, attrs); |
| 321 | − debug_dma_unmap_page(dev, addr, size, dir, true); | |
| 322 | −} | |
| 323 | − | |
| 324 | −static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr, | |
| 325 | − size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 326 | −{ | |
| 327 | − return dma_unmap_single_attrs(dev, addr, size, dir, attrs); | |
| 303 | + debug_dma_unmap_page(dev, addr, size, dir); | |
| 328 | 304 | } |
| 329 | 305 | |
| 330 | 306 | /* |
| @@ -363,25 +339,6 @@ static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg · 32 unmodified lines | ||
| 363 | 339 | ops->unmap_sg(dev, sg, nents, dir, attrs); |
| 364 | 340 | } |
| 365 | 341 | |
| 366 | −static inline dma_addr_t dma_map_page_attrs(struct device *dev, | |
| 367 | − struct page *page, | |
| 368 | − size_t offset, size_t size, | |
| 369 | − enum dma_data_direction dir, | |
| 370 | − unsigned long attrs) | |
| 371 | −{ | |
| 372 | − const struct dma_map_ops *ops = get_dma_ops(dev); | |
| 373 | − dma_addr_t addr; | |
| 374 | − | |
| 375 | − BUG_ON(!valid_dma_direction(dir)); | |
| 376 | − if (dma_is_direct(ops)) | |
| 377 | − addr = dma_direct_map_page(dev, page, offset, size, dir, attrs); | |
| 378 | − else | |
| 379 | − addr = ops->map_page(dev, page, offset, size, dir, attrs); | |
| 380 | − debug_dma_map_page(dev, page, offset, size, dir, addr, false); | |
| 381 | − | |
| 382 | − return addr; | |
| 383 | −} | |
| 384 | − | |
| 385 | 342 | static inline dma_addr_t dma_map_resource(struct device *dev, |
| 386 | 343 | phys_addr_t phys_addr, |
| 387 | 344 | size_t size, |
| @@ -431,13 +388,6 @@ static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, · 43 unmodified lines | ||
| 431 | 388 | debug_dma_sync_single_for_cpu(dev, addr, size, dir); |
| 432 | 389 | } |
| 433 | 390 | |
| 434 | −static inline void dma_sync_single_range_for_cpu(struct device *dev, | |
| 435 | − dma_addr_t addr, unsigned long offset, size_t size, | |
| 436 | − enum dma_data_direction dir) | |
| 437 | −{ | |
| 438 | − return dma_sync_single_for_cpu(dev, addr + offset, size, dir); | |
| 439 | −} | |
| 440 | − | |
| 441 | 391 | static inline void dma_sync_single_for_device(struct device *dev, |
| 442 | 392 | dma_addr_t addr, size_t size, |
| 443 | 393 | enum dma_data_direction dir) |
| @@ -452,13 +402,6 @@ static inline void dma_sync_single_for_device(struct device *dev, · 8 unmodified lines | ||
| 452 | 402 | debug_dma_sync_single_for_device(dev, addr, size, dir); |
| 453 | 403 | } |
| 454 | 404 | |
| 455 | −static inline void dma_sync_single_range_for_device(struct device *dev, | |
| 456 | − dma_addr_t addr, unsigned long offset, size_t size, | |
| 457 | − enum dma_data_direction dir) | |
| 458 | −{ | |
| 459 | − return dma_sync_single_for_device(dev, addr + offset, size, dir); | |
| 460 | −} | |
| 461 | − | |
| 462 | 405 | static inline void |
| 463 | 406 | dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, |
| 464 | 407 | int nelems, enum dma_data_direction dir) |
| @@ -488,15 +431,174 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, · 23 unmodified lines | ||
| 488 | 431 | |
| 489 | 432 | } |
| 490 | 433 | |
| 434 | +static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) | |
| 435 | +{ | |
| 436 | + debug_dma_mapping_error(dev, dma_addr); | |
| 437 | + | |
| 438 | + if (dma_addr == DMA_MAPPING_ERROR) | |
| 439 | + return -ENOMEM; | |
| 440 | + return 0; | |
| 441 | +} | |
| 442 | + | |
| 443 | +void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, | |
| 444 | + gfp_t flag, unsigned long attrs); | |
| 445 | +void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr, | |
| 446 | + dma_addr_t dma_handle, unsigned long attrs); | |
| 447 | +void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, | |
| 448 | + gfp_t gfp, unsigned long attrs); | |
| 449 | +void dmam_free_coherent(struct device *dev, size_t size, void *vaddr, | |
| 450 | + dma_addr_t dma_handle); | |
| 451 | +void dma_cache_sync(struct device *dev, void *vaddr, size_t size, | |
| 452 | + enum dma_data_direction dir); | |
| 453 | +int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, | |
| 454 | + void *cpu_addr, dma_addr_t dma_addr, size_t size, | |
| 455 | + unsigned long attrs); | |
| 456 | +int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, | |
| 457 | + void *cpu_addr, dma_addr_t dma_addr, size_t size, | |
| 458 | + unsigned long attrs); | |
| 459 | +int dma_supported(struct device *dev, u64 mask); | |
| 460 | +int dma_set_mask(struct device *dev, u64 mask); | |
| 461 | +int dma_set_coherent_mask(struct device *dev, u64 mask); | |
| 462 | +u64 dma_get_required_mask(struct device *dev); | |
| 463 | +#else /* CONFIG_HAS_DMA */ | |
| 464 | +static inline dma_addr_t dma_map_page_attrs(struct device *dev, | |
| 465 | + struct page *page, size_t offset, size_t size, | |
| 466 | + enum dma_data_direction dir, unsigned long attrs) | |
| 467 | +{ | |
| 468 | + return DMA_MAPPING_ERROR; | |
| 469 | +} | |
| 470 | +static inline void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr, | |
| 471 | + size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 472 | +{ | |
| 473 | +} | |
| 474 | +static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, | |
| 475 | + int nents, enum dma_data_direction dir, unsigned long attrs) | |
| 476 | +{ | |
| 477 | + return 0; | |
| 478 | +} | |
| 479 | +static inline void dma_unmap_sg_attrs(struct device *dev, | |
| 480 | + struct scatterlist *sg, int nents, enum dma_data_direction dir, | |
| 481 | + unsigned long attrs) | |
| 482 | +{ | |
| 483 | +} | |
| 484 | +static inline dma_addr_t dma_map_resource(struct device *dev, | |
| 485 | + phys_addr_t phys_addr, size_t size, enum dma_data_direction dir, | |
| 486 | + unsigned long attrs) | |
| 487 | +{ | |
| 488 | + return DMA_MAPPING_ERROR; | |
| 489 | +} | |
| 490 | +static inline void dma_unmap_resource(struct device *dev, dma_addr_t addr, | |
| 491 | + size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 492 | +{ | |
| 493 | +} | |
| 494 | +static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, | |
| 495 | + size_t size, enum dma_data_direction dir) | |
| 496 | +{ | |
| 497 | +} | |
| 498 | +static inline void dma_sync_single_for_device(struct device *dev, | |
| 499 | + dma_addr_t addr, size_t size, enum dma_data_direction dir) | |
| 500 | +{ | |
| 501 | +} | |
| 502 | +static inline void dma_sync_sg_for_cpu(struct device *dev, | |
| 503 | + struct scatterlist *sg, int nelems, enum dma_data_direction dir) | |
| 504 | +{ | |
| 505 | +} | |
| 506 | +static inline void dma_sync_sg_for_device(struct device *dev, | |
| 507 | + struct scatterlist *sg, int nelems, enum dma_data_direction dir) | |
| 508 | +{ | |
| 509 | +} | |
| 510 | +static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) | |
| 511 | +{ | |
| 512 | + return -ENOMEM; | |
| 513 | +} | |
| 514 | +static inline void *dma_alloc_attrs(struct device *dev, size_t size, | |
| 515 | + dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs) | |
| 516 | +{ | |
| 517 | + return NULL; | |
| 518 | +} | |
| 519 | +static void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr, | |
| 520 | + dma_addr_t dma_handle, unsigned long attrs) | |
| 521 | +{ | |
| 522 | +} | |
| 523 | +static inline void *dmam_alloc_attrs(struct device *dev, size_t size, | |
| 524 | + dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs) | |
| 525 | +{ | |
| 526 | + return NULL; | |
| 527 | +} | |
| 528 | +static inline void dmam_free_coherent(struct device *dev, size_t size, | |
| 529 | + void *vaddr, dma_addr_t dma_handle) | |
| 530 | +{ | |
| 531 | +} | |
| 532 | +static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size, | |
| 533 | + enum dma_data_direction dir) | |
| 534 | +{ | |
| 535 | +} | |
| 536 | +static inline int dma_get_sgtable_attrs(struct device *dev, | |
| 537 | + struct sg_table *sgt, void *cpu_addr, dma_addr_t dma_addr, | |
| 538 | + size_t size, unsigned long attrs) | |
| 539 | +{ | |
| 540 | + return -ENXIO; | |
| 541 | +} | |
| 542 | +static inline int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, | |
| 543 | + void *cpu_addr, dma_addr_t dma_addr, size_t size, | |
| 544 | + unsigned long attrs) | |
| 545 | +{ | |
| 546 | + return -ENXIO; | |
| 547 | +} | |
| 548 | +static inline int dma_supported(struct device *dev, u64 mask) | |
| 549 | +{ | |
| 550 | + return 0; | |
| 551 | +} | |
| 552 | +static inline int dma_set_mask(struct device *dev, u64 mask) | |
| 553 | +{ | |
| 554 | + return -EIO; | |
| 555 | +} | |
| 556 | +static inline int dma_set_coherent_mask(struct device *dev, u64 mask) | |
| 557 | +{ | |
| 558 | + return -EIO; | |
| 559 | +} | |
| 560 | +static inline u64 dma_get_required_mask(struct device *dev) | |
| 561 | +{ | |
| 562 | + return 0; | |
| 563 | +} | |
| 564 | +#endif /* CONFIG_HAS_DMA */ | |
| 565 | + | |
| 566 | +static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, | |
| 567 | + size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 568 | +{ | |
| 569 | + debug_dma_map_single(dev, ptr, size); | |
| 570 | + return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr), | |
| 571 | + size, dir, attrs); | |
| 572 | +} | |
| 573 | + | |
| 574 | +static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, | |
| 575 | + size_t size, enum dma_data_direction dir, unsigned long attrs) | |
| 576 | +{ | |
| 577 | + return dma_unmap_page_attrs(dev, addr, size, dir, attrs); | |
| 578 | +} | |
| 579 | + | |
| 580 | +static inline void dma_sync_single_range_for_cpu(struct device *dev, | |
| 581 | + dma_addr_t addr, unsigned long offset, size_t size, | |
| 582 | + enum dma_data_direction dir) | |
| 583 | +{ | |
| 584 | + return dma_sync_single_for_cpu(dev, addr + offset, size, dir); | |
| 585 | +} | |
| 586 | + | |
| 587 | +static inline void dma_sync_single_range_for_device(struct device *dev, | |
| 588 | + dma_addr_t addr, unsigned long offset, size_t size, | |
| 589 | + enum dma_data_direction dir) | |
| 590 | +{ | |
| 591 | + return dma_sync_single_for_device(dev, addr + offset, size, dir); | |
| 592 | +} | |
| 593 | + | |
| 491 | 594 | #define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0) |
| 492 | 595 | #define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0) |
| 493 | 596 | #define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0) |
| 494 | 597 | #define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0) |
| 495 | 598 | #define dma_map_page(d, p, o, s, r) dma_map_page_attrs(d, p, o, s, r, 0) |
| 496 | 599 | #define dma_unmap_page(d, a, s, r) dma_unmap_page_attrs(d, a, s, r, 0) |
| 497 | − | |
| 498 | −void dma_cache_sync(struct device *dev, void *vaddr, size_t size, | |
| 499 | − enum dma_data_direction dir); | |
| 600 | +#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0) | |
| 601 | +#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0) | |
| 500 | 602 | |
| 501 | 603 | extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma, |
| 502 | 604 | void *cpu_addr, dma_addr_t dma_addr, size_t size, |
| @@ -516,25 +618,10 @@ bool dma_in_atomic_pool(void *start, size_t size); · 13 unmodified lines | ||
| 516 | 618 | void *dma_alloc_from_pool(size_t size, struct page **ret_page, gfp_t flags); |
| 517 | 619 | bool dma_free_from_pool(void *start, size_t size); |
| 518 | 620 | |
| 519 | −int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, | |
| 520 | − void *cpu_addr, dma_addr_t dma_addr, size_t size, | |
| 521 | − unsigned long attrs); | |
| 522 | −#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0) | |
| 523 | − | |
| 524 | 621 | int |
| 525 | 622 | dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr, |
| 526 | 623 | dma_addr_t dma_addr, size_t size, unsigned long attrs); |
| 527 | 624 | |
| 528 | −int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, | |
| 529 | − void *cpu_addr, dma_addr_t dma_addr, size_t size, | |
| 530 | − unsigned long attrs); | |
| 531 | −#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0) | |
| 532 | − | |
| 533 | −void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, | |
| 534 | − gfp_t flag, unsigned long attrs); | |
| 535 | −void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr, | |
| 536 | − dma_addr_t dma_handle, unsigned long attrs); | |
| 537 | − | |
| 538 | 625 | static inline void *dma_alloc_coherent(struct device *dev, size_t size, |
| 539 | 626 | dma_addr_t *dma_handle, gfp_t gfp) |
| 540 | 627 | { |
| @@ -549,18 +636,6 @@ static inline void dma_free_coherent(struct device *dev, size_t size, · 8 unmodified lines | ||
| 549 | 636 | return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0); |
| 550 | 637 | } |
| 551 | 638 | |
| 552 | −static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) | |
| 553 | −{ | |
| 554 | − debug_dma_mapping_error(dev, dma_addr); | |
| 555 | − | |
| 556 | − if (dma_addr == DMA_MAPPING_ERROR) | |
| 557 | − return -ENOMEM; | |
| 558 | − return 0; | |
| 559 | −} | |
| 560 | − | |
| 561 | −int dma_supported(struct device *dev, u64 mask); | |
| 562 | −int dma_set_mask(struct device *dev, u64 mask); | |
| 563 | −int dma_set_coherent_mask(struct device *dev, u64 mask); | |
| 564 | 639 | |
| 565 | 640 | static inline u64 dma_get_mask(struct device *dev) |
| 566 | 641 | { |
| @@ -593,8 +668,6 @@ static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask) · 26 unmodified lines | ||
| 593 | 668 | return dma_set_mask_and_coherent(dev, mask); |
| 594 | 669 | } |
| 595 | 670 | |
| 596 | −extern u64 dma_get_required_mask(struct device *dev); | |
| 597 | − | |
| 598 | 671 | #ifndef arch_setup_dma_ops |
| 599 | 672 | static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base, |
| 600 | 673 | u64 size, const struct iommu_ops *iommu, |
| @@ -691,43 +764,12 @@ dma_mark_declared_memory_occupied(struct device *dev, · 90 unmodified lines | ||
| 691 | 764 | } |
| 692 | 765 | #endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */ |
| 693 | 766 | |
| 694 | −/* | |
| 695 | − * Managed DMA API | |
| 696 | − */ | |
| 697 | −#ifdef CONFIG_HAS_DMA | |
| 698 | −extern void *dmam_alloc_coherent(struct device *dev, size_t size, | |
| 699 | − dma_addr_t *dma_handle, gfp_t gfp); | |
| 700 | −extern void dmam_free_coherent(struct device *dev, size_t size, void *vaddr, | |
| 701 | − dma_addr_t dma_handle); | |
| 702 | −#else /* !CONFIG_HAS_DMA */ | |
| 703 | 767 | static inline void *dmam_alloc_coherent(struct device *dev, size_t size, |
| 704 | − dma_addr_t *dma_handle, gfp_t gfp) | |
| 705 | −{ return NULL; } | |
| 706 | −static inline void dmam_free_coherent(struct device *dev, size_t size, | |
| 707 | − void *vaddr, dma_addr_t dma_handle) { } | |
| 708 | −#endif /* !CONFIG_HAS_DMA */ | |
| 709 | − | |
| 710 | −extern void *dmam_alloc_attrs(struct device *dev, size_t size, | |
| 711 | − dma_addr_t *dma_handle, gfp_t gfp, | |
| 712 | − unsigned long attrs); | |
| 713 | −#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT | |
| 714 | −extern int dmam_declare_coherent_memory(struct device *dev, | |
| 715 | − phys_addr_t phys_addr, | |
| 716 | − dma_addr_t device_addr, size_t size, | |
| 717 | − int flags); | |
| 718 | −extern void dmam_release_declared_memory(struct device *dev); | |
| 719 | −#else /* CONFIG_HAVE_GENERIC_DMA_COHERENT */ | |
| 720 | −static inline int dmam_declare_coherent_memory(struct device *dev, | |
| 721 | − phys_addr_t phys_addr, dma_addr_t device_addr, | |
| 722 | − size_t size, gfp_t gfp) | |
| 723 | −{ | |
| 724 | − return 0; | |
| 725 | −} | |
| 726 | − | |
| 727 | −static inline void dmam_release_declared_memory(struct device *dev) | |
| 768 | + dma_addr_t *dma_handle, gfp_t gfp) | |
| 728 | 769 | { |
| 770 | + return dmam_alloc_attrs(dev, size, dma_handle, gfp, | |
| 771 | + (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0); | |
| 729 | 772 | } |
| 730 | −#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */ | |
| 731 | 773 | |
| 732 | 774 | static inline void *dma_alloc_wc(struct device *dev, size_t size, |
| 733 | 775 | dma_addr_t *dma_addr, gfp_t gfp) |