| /drivers/include/asm/dma-mapping.h |
|---|
| 0,0 → 1,116 |
| #ifndef _ASM_X86_DMA_MAPPING_H |
| #define _ASM_X86_DMA_MAPPING_H |
| /* |
| * IOMMU interface. See Documentation/DMA-API-HOWTO.txt and |
| * Documentation/DMA-API.txt for documentation. |
| */ |
| #include <linux/kmemcheck.h> |
| #include <linux/scatterlist.h> |
| #include <linux/dma-debug.h> |
| #include <linux/dma-attrs.h> |
| #include <asm/io.h> |
| #include <asm/swiotlb.h> |
| #include <linux/dma-contiguous.h> |
| #ifdef CONFIG_ISA |
| # define ISA_DMA_BIT_MASK DMA_BIT_MASK(24) |
| #else |
| # define ISA_DMA_BIT_MASK DMA_BIT_MASK(32) |
| #endif |
| #define DMA_ERROR_CODE 0 |
| extern int iommu_merge; |
| extern struct device x86_dma_fallback_dev; |
| extern int panic_on_overflow; |
| extern struct dma_map_ops *dma_ops; |
| static inline struct dma_map_ops *get_dma_ops(struct device *dev) |
| { |
| #ifndef CONFIG_X86_DEV_DMA_OPS |
| return dma_ops; |
| #else |
| if (unlikely(!dev) || !dev->archdata.dma_ops) |
| return dma_ops; |
| else |
| return dev->archdata.dma_ops; |
| #endif |
| } |
| bool arch_dma_alloc_attrs(struct device **dev, gfp_t *gfp); |
| #define arch_dma_alloc_attrs arch_dma_alloc_attrs |
| #define HAVE_ARCH_DMA_SUPPORTED 1 |
| extern int dma_supported(struct device *hwdev, u64 mask); |
| #include <asm-generic/dma-mapping-common.h> |
| extern void *dma_generic_alloc_coherent(struct device *dev, size_t size, |
| dma_addr_t *dma_addr, gfp_t flag, |
| struct dma_attrs *attrs); |
| extern void dma_generic_free_coherent(struct device *dev, size_t size, |
| void *vaddr, dma_addr_t dma_addr, |
| struct dma_attrs *attrs); |
| #ifdef CONFIG_X86_DMA_REMAP /* Platform code defines bridge-specific code */ |
| extern bool dma_capable(struct device *dev, dma_addr_t addr, size_t size); |
| extern dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr); |
| extern phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr); |
| #else |
| static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size) |
| { |
| if (!dev->dma_mask) |
| return 0; |
| return addr + size - 1 <= *dev->dma_mask; |
| } |
| static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr) |
| { |
| return paddr; |
| } |
| static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t daddr) |
| { |
| return daddr; |
| } |
| #endif /* CONFIG_X86_DMA_REMAP */ |
| static inline void |
| dma_cache_sync(struct device *dev, void *vaddr, size_t size, |
| enum dma_data_direction dir) |
| { |
| flush_write_buffers(); |
| } |
| static inline unsigned long dma_alloc_coherent_mask(struct device *dev, |
| gfp_t gfp) |
| { |
| unsigned long dma_mask = 0; |
| dma_mask = dev->coherent_dma_mask; |
| if (!dma_mask) |
| dma_mask = (gfp & GFP_DMA) ? DMA_BIT_MASK(24) : DMA_BIT_MASK(32); |
| return dma_mask; |
| } |
| static inline gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp) |
| { |
| unsigned long dma_mask = dma_alloc_coherent_mask(dev, gfp); |
| if (dma_mask <= DMA_BIT_MASK(24)) |
| gfp |= GFP_DMA; |
| #ifdef CONFIG_X86_64 |
| if (dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA)) |
| gfp |= GFP_DMA32; |
| #endif |
| return gfp; |
| } |
| #endif |
| /drivers/include/asm-generic/atomic64.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Generic implementation of 64-bit atomics using spinlocks, |
| * useful on processors that don't have 64-bit atomic instructions. |
| * |
| * Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com> |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version |
| * 2 of the License, or (at your option) any later version. |
| */ |
| #ifndef _ASM_GENERIC_ATOMIC64_H |
| #define _ASM_GENERIC_ATOMIC64_H |
| typedef struct { |
| long long counter; |
| } atomic64_t; |
| #define ATOMIC64_INIT(i) { (i) } |
| extern long long atomic64_read(const atomic64_t *v); |
| extern void atomic64_set(atomic64_t *v, long long i); |
| #define ATOMIC64_OP(op) \ |
| extern void atomic64_##op(long long a, atomic64_t *v); |
| #define ATOMIC64_OP_RETURN(op) \ |
| extern long long atomic64_##op##_return(long long a, atomic64_t *v); |
| #define ATOMIC64_OPS(op) ATOMIC64_OP(op) ATOMIC64_OP_RETURN(op) |
| ATOMIC64_OPS(add) |
| ATOMIC64_OPS(sub) |
| ATOMIC64_OP(and) |
| ATOMIC64_OP(or) |
| ATOMIC64_OP(xor) |
| #undef ATOMIC64_OPS |
| #undef ATOMIC64_OP_RETURN |
| #undef ATOMIC64_OP |
| extern long long atomic64_dec_if_positive(atomic64_t *v); |
| extern long long atomic64_cmpxchg(atomic64_t *v, long long o, long long n); |
| extern long long atomic64_xchg(atomic64_t *v, long long new); |
| extern int atomic64_add_unless(atomic64_t *v, long long a, long long u); |
| #define atomic64_add_negative(a, v) (atomic64_add_return((a), (v)) < 0) |
| #define atomic64_inc(v) atomic64_add(1LL, (v)) |
| #define atomic64_inc_return(v) atomic64_add_return(1LL, (v)) |
| #define atomic64_inc_and_test(v) (atomic64_inc_return(v) == 0) |
| #define atomic64_sub_and_test(a, v) (atomic64_sub_return((a), (v)) == 0) |
| #define atomic64_dec(v) atomic64_sub(1LL, (v)) |
| #define atomic64_dec_return(v) atomic64_sub_return(1LL, (v)) |
| #define atomic64_dec_and_test(v) (atomic64_dec_return((v)) == 0) |
| #define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1LL, 0LL) |
| #endif /* _ASM_GENERIC_ATOMIC64_H */ |
| /drivers/include/asm-generic/dma-mapping-broken.h |
|---|
| 0,0 → 1,95 |
| #ifndef _ASM_GENERIC_DMA_MAPPING_H |
| #define _ASM_GENERIC_DMA_MAPPING_H |
| /* define the dma api to allow compilation but not linking of |
| * dma dependent code. Code that depends on the dma-mapping |
| * API needs to set 'depends on HAS_DMA' in its Kconfig |
| */ |
| struct scatterlist; |
| extern void * |
| dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, |
| gfp_t flag); |
| extern void |
| dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, |
| dma_addr_t dma_handle); |
| static inline void *dma_alloc_attrs(struct device *dev, size_t size, |
| dma_addr_t *dma_handle, gfp_t flag, |
| struct dma_attrs *attrs) |
| { |
| /* attrs is not supported and ignored */ |
| return dma_alloc_coherent(dev, size, dma_handle, flag); |
| } |
| static inline void dma_free_attrs(struct device *dev, size_t size, |
| void *cpu_addr, dma_addr_t dma_handle, |
| struct dma_attrs *attrs) |
| { |
| /* attrs is not supported and ignored */ |
| dma_free_coherent(dev, size, cpu_addr, dma_handle); |
| } |
| #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f) |
| #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h) |
| extern dma_addr_t |
| dma_map_single(struct device *dev, void *ptr, size_t size, |
| enum dma_data_direction direction); |
| extern void |
| dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, |
| enum dma_data_direction direction); |
| extern int |
| dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, |
| enum dma_data_direction direction); |
| extern void |
| dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, |
| enum dma_data_direction direction); |
| extern dma_addr_t |
| dma_map_page(struct device *dev, struct page *page, unsigned long offset, |
| size_t size, enum dma_data_direction direction); |
| extern void |
| dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, |
| enum dma_data_direction direction); |
| extern void |
| dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, |
| enum dma_data_direction direction); |
| extern void |
| dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, |
| unsigned long offset, size_t size, |
| enum dma_data_direction direction); |
| extern void |
| dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, |
| enum dma_data_direction direction); |
| #define dma_sync_single_for_device dma_sync_single_for_cpu |
| #define dma_sync_single_range_for_device dma_sync_single_range_for_cpu |
| #define dma_sync_sg_for_device dma_sync_sg_for_cpu |
| extern int |
| dma_mapping_error(struct device *dev, dma_addr_t dma_addr); |
| extern int |
| dma_supported(struct device *dev, u64 mask); |
| extern int |
| dma_set_mask(struct device *dev, u64 mask); |
| extern int |
| dma_get_cache_alignment(void); |
| extern void |
| dma_cache_sync(struct device *dev, void *vaddr, size_t size, |
| enum dma_data_direction direction); |
| #endif /* _ASM_GENERIC_DMA_MAPPING_H */ |
| /drivers/include/linux/dma-attrs.h |
|---|
| 0,0 → 1,80 |
| #ifndef _DMA_ATTR_H |
| #define _DMA_ATTR_H |
| #include <linux/bitmap.h> |
| #include <linux/bitops.h> |
| #include <linux/bug.h> |
| /** |
| * an enum dma_attr represents an attribute associated with a DMA |
| * mapping. The semantics of each attribute should be defined in |
| * Documentation/DMA-attributes.txt. |
| */ |
| enum dma_attr { |
| DMA_ATTR_WRITE_BARRIER, |
| DMA_ATTR_WEAK_ORDERING, |
| DMA_ATTR_WRITE_COMBINE, |
| DMA_ATTR_NON_CONSISTENT, |
| DMA_ATTR_NO_KERNEL_MAPPING, |
| DMA_ATTR_SKIP_CPU_SYNC, |
| DMA_ATTR_FORCE_CONTIGUOUS, |
| DMA_ATTR_MAX, |
| }; |
| #define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX) |
| /** |
| * struct dma_attrs - an opaque container for DMA attributes |
| * @flags - bitmask representing a collection of enum dma_attr |
| */ |
| struct dma_attrs { |
| unsigned long flags[__DMA_ATTRS_LONGS]; |
| }; |
| #define DEFINE_DMA_ATTRS(x) \ |
| struct dma_attrs x = { \ |
| .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 }, \ |
| } |
| static inline void init_dma_attrs(struct dma_attrs *attrs) |
| { |
| bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS); |
| } |
| #ifdef CONFIG_HAVE_DMA_ATTRS |
| /** |
| * dma_set_attr - set a specific attribute |
| * @attr: attribute to set |
| * @attrs: struct dma_attrs (may be NULL) |
| */ |
| static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) |
| { |
| if (attrs == NULL) |
| return; |
| BUG_ON(attr >= DMA_ATTR_MAX); |
| __set_bit(attr, attrs->flags); |
| } |
| /** |
| * dma_get_attr - check for a specific attribute |
| * @attr: attribute to set |
| * @attrs: struct dma_attrs (may be NULL) |
| */ |
| static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs) |
| { |
| if (attrs == NULL) |
| return 0; |
| BUG_ON(attr >= DMA_ATTR_MAX); |
| return test_bit(attr, attrs->flags); |
| } |
| #else /* !CONFIG_HAVE_DMA_ATTRS */ |
| static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) |
| { |
| } |
| static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs) |
| { |
| return 0; |
| } |
| #endif /* CONFIG_HAVE_DMA_ATTRS */ |
| #endif /* _DMA_ATTR_H */ |
| /drivers/include/linux/swap.h |
|---|
| 0,0 → 1,22 |
| #ifndef _LINUX_SWAP_H |
| #define _LINUX_SWAP_H |
| #include <linux/spinlock.h> |
| struct notifier_block; |
| struct bio; |
| #define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */ |
| #define SWAP_FLAG_PRIO_MASK 0x7fff |
| #define SWAP_FLAG_PRIO_SHIFT 0 |
| #define SWAP_FLAG_DISCARD 0x10000 /* enable discard for swap */ |
| #define SWAP_FLAG_DISCARD_ONCE 0x20000 /* discard swap area at swapon-time */ |
| #define SWAP_FLAG_DISCARD_PAGES 0x40000 /* discard page-clusters after use */ |
| #define SWAP_FLAGS_VALID (SWAP_FLAG_PRIO_MASK | SWAP_FLAG_PREFER | \ |
| SWAP_FLAG_DISCARD | SWAP_FLAG_DISCARD_ONCE | \ |
| SWAP_FLAG_DISCARD_PAGES) |
| #endif /* _LINUX_SWAP_H */ |