/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 */ |