Lines Matching refs:be
21 A dma_addr_t can hold any valid DMA address for the platform. It can be
23 a dma_addr_t directly because there may be translation between its physical
34 the processor can immediately be read by the processor or device
44 It also returns a <dma_handle> which may be cast to an unsigned integer the
48 Note: consistent memory can be expensive on some platforms, and the
49 minimum allocation length may be as big as a page, so you should
70 size and dma_handle must all be the same as those passed into
71 dma_alloc_coherent(). cpu_addr must be the virtual address returned by
75 may only be called with IRQs enabled.
88 for alignment, like queue heads needing to be aligned on N-byte boundaries.
96 for use with a given device. It must be called in a context which
102 in bytes, and must be a power of two). If your device has no boundary
129 dma_pool_destroy() frees the resources of the pool. It must be
195 Maps a piece of processor virtual memory so it can be accessed by the
198 The direction for both APIs may be converted freely by casting.
207 Notes: Not all memory regions in a machine can be mapped by this API.
208 Further, contiguous kernel virtual space may not be contiguous as
211 contiguous piece of memory. For this reason, memory to be mapped by
212 this API should be obtained from sources which guarantee it to be
215 Further, the DMA address of the memory must be within the
223 guarantees to be within the first 16MB of available DMA addresses,
228 maps an I/O DMA address to a physical memory address). However, to be
237 may not be known at compile time, the API will not enforce this
241 are guaranteed also to be cache line boundaries).
243 DMA_TO_DEVICE synchronisation must be done after the last modification
246 primitive should be treated as read-only by the device. If the device
247 may write to it at any point, it should be DMA_BIDIRECTIONAL (see
250 DMA_FROM_DEVICE synchronisation must be done before the driver
251 accesses data that may be changed by the device. This memory should
252 be treated as read-only by the driver. If the driver needs to write
253 to it at any point, it should be DMA_BIDIRECTIONAL (see below).
260 are flushed from the processor) and once before the data may be
269 must be identical to those passed in (and returned) by the mapping
292 could not be created and the driver should take appropriate action (e.g.
299 Returns: the number of DMA address segments mapped (this may be shorter
304 Please note that the sg cannot be mapped again if it has been mapped once.
326 into one (e.g. with an IOMMU, or if several pages just happen to be
330 Then you should loop count times (note: this can be less than nents times)
339 must be the same as those and passed in to the scatter/gather mapping
342 Note: <nents> must be the number you passed in, *not* the number of
359 and device. With the sync_sg API, all the parameters must be the same
368 - After writing values that will be written to the device using DMA
403 each attribute should be documented in Documentation/DMA-attributes.txt.
415 /* DMA_ATTR_FOO should be defined in linux/dma-attrs.h and
444 Warning: These pieces of the DMA API should not be used in the
449 processor and an I/O device, you should not be using this part of the
466 only use this API if you positively know your driver will be
475 be identical to those passed in (and returned by
487 into the width returned by this call. It will also always be a power
504 Declare region of memory to be handed out by dma_alloc_coherent() when
508 assigned (this will be ioremapped so the CPU can access the region).
510 device_addr is the DMA address the device needs to be programmed
511 with to actually address this memory (this will be handed out as the
514 size is the size of the area (must be multiples of PAGE_SIZE).
516 flags can be ORed together and are:
519 dma_alloc_coherent() be directly writable.
522 dma_alloc_coherent() be addressable using read()/write()/memcpy_toio() etc.
524 One or both of these flags must be present.
526 DMA_MEMORY_INCLUDES_CHILDREN - make the declared memory be allocated by
534 The return value will be either DMA_MEMORY_MAP or DMA_MEMORY_IO and
540 dma_alloc_coherent() may no longer be accessed directly, but instead
541 must be accessed using the correct bus functions. If your driver
546 memory may be declared per device.
570 size is the size (and should be a page-sized multiple).
572 The return value will be either a pointer to the processor virtual
579 The DMA-API as described above has some constraints. DMA addresses must be
586 be compiled into the kernel which will tell the developer about those
633 be disabled via debugfs. See the debugfs interface documentation below for
637 this directory the following files can currently be found:
654 warnings will be printed to the kernel log
656 one at system boot and be set by writing into
660 This read-only file can be read to get the
677 If you have this code compiled into your kernel it will be enabled by default.
686 driver afterwards. This filter can be disabled or changed later using debugfs.
702 leads up to the unmap. This interface can be called from dma_mapping_error()