| /linux-4.4.14/arch/metag/include/asm/ |
| H A D | dma-mapping.h | 31 enum dma_data_direction direction) dma_map_single()
33 BUG_ON(!valid_dma_direction(direction)); dma_map_single()
35 dma_sync_for_device(ptr, size, direction); dma_map_single()
41 enum dma_data_direction direction) dma_unmap_single()
43 BUG_ON(!valid_dma_direction(direction)); dma_unmap_single()
44 dma_sync_for_cpu(phys_to_virt(dma_addr), size, direction); dma_unmap_single() local
49 enum dma_data_direction direction) dma_map_sg()
54 BUG_ON(!valid_dma_direction(direction)); dma_map_sg()
61 dma_sync_for_device(sg_virt(sg), sg->length, direction); for_each_sg() local
69 size_t size, enum dma_data_direction direction) dma_map_page()
71 BUG_ON(!valid_dma_direction(direction)); dma_map_page()
73 direction); dma_map_page()
79 enum dma_data_direction direction) dma_unmap_page()
81 BUG_ON(!valid_dma_direction(direction)); dma_unmap_page()
82 dma_sync_for_cpu(phys_to_virt(dma_address), size, direction); dma_unmap_page() local
88 enum dma_data_direction direction) dma_unmap_sg()
93 BUG_ON(!valid_dma_direction(direction)); dma_unmap_sg()
100 dma_sync_for_cpu(sg_virt(sg), sg->length, direction); for_each_sg() local
106 enum dma_data_direction direction) dma_sync_single_for_cpu()
108 dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction); dma_sync_single_for_cpu() local
113 size_t size, enum dma_data_direction direction) dma_sync_single_for_device()
115 dma_sync_for_device(phys_to_virt(dma_handle), size, direction); dma_sync_single_for_device() local
121 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
124 direction); dma_sync_single_range_for_cpu()
130 enum dma_data_direction direction) dma_sync_single_range_for_device()
133 direction); dma_sync_single_range_for_device()
138 enum dma_data_direction direction) dma_sync_sg_for_cpu()
144 dma_sync_for_cpu(sg_virt(sg), sg->length, direction); dma_sync_sg_for_cpu() local
149 int nelems, enum dma_data_direction direction) dma_sync_sg_for_device()
155 dma_sync_for_device(sg_virt(sg), sg->length, direction); dma_sync_sg_for_device() local
183 enum dma_data_direction direction) dma_cache_sync()
30 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
40 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
48 dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_map_sg() argument
68 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
78 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
87 dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
105 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
112 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
119 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) dma_sync_single_range_for_cpu() argument
128 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
137 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
148 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
182 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/nios2/mm/ |
| H A D | dma-mapping.c | 60 enum dma_data_direction direction) dma_map_sg()
64 BUG_ON(!valid_dma_direction(direction)); dma_map_sg()
71 __dma_sync_for_device(addr, sg->length, direction); for_each_sg()
82 enum dma_data_direction direction) dma_map_page()
86 BUG_ON(!valid_dma_direction(direction)); dma_map_page()
89 __dma_sync_for_device(addr, size, direction); dma_map_page()
96 enum dma_data_direction direction) dma_unmap_page()
98 BUG_ON(!valid_dma_direction(direction)); dma_unmap_page()
100 __dma_sync_for_cpu(phys_to_virt(dma_address), size, direction); dma_unmap_page() local
105 enum dma_data_direction direction) dma_unmap_sg()
110 BUG_ON(!valid_dma_direction(direction)); dma_unmap_sg()
112 if (direction == DMA_TO_DEVICE) dma_unmap_sg()
118 __dma_sync_for_cpu(addr, sg->length, direction); for_each_sg()
124 size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu()
126 BUG_ON(!valid_dma_direction(direction)); dma_sync_single_for_cpu()
128 __dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction); dma_sync_single_for_cpu() local
133 size_t size, enum dma_data_direction direction) dma_sync_single_for_device()
135 BUG_ON(!valid_dma_direction(direction)); dma_sync_single_for_device()
137 __dma_sync_for_device(phys_to_virt(dma_handle), size, direction); dma_sync_single_for_device() local
143 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
145 BUG_ON(!valid_dma_direction(direction)); dma_sync_single_range_for_cpu()
147 __dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction); dma_sync_single_range_for_cpu() local
153 enum dma_data_direction direction) dma_sync_single_range_for_device()
155 BUG_ON(!valid_dma_direction(direction)); dma_sync_single_range_for_device()
157 __dma_sync_for_device(phys_to_virt(dma_handle), size, direction); dma_sync_single_range_for_device() local
162 enum dma_data_direction direction) dma_sync_sg_for_cpu()
166 BUG_ON(!valid_dma_direction(direction)); dma_sync_sg_for_cpu()
170 __dma_sync_for_cpu(sg_virt(sg), sg->length, direction); dma_sync_sg_for_cpu()
175 int nelems, enum dma_data_direction direction) dma_sync_sg_for_device()
179 BUG_ON(!valid_dma_direction(direction)); dma_sync_sg_for_device()
183 __dma_sync_for_device(sg_virt(sg), sg->length, direction); dma_sync_sg_for_device()
59 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) dma_map_sg() argument
80 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
95 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
104 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
123 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
132 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
141 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) dma_sync_single_range_for_cpu() argument
151 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
161 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
174 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
|
| /linux-4.4.14/include/asm-generic/ |
| H A D | pci-dma-compat.h | 32 pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction) pci_map_single() argument
34 return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction); pci_map_single()
39 size_t size, int direction) pci_unmap_single()
41 dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction); pci_unmap_single()
46 unsigned long offset, size_t size, int direction) pci_map_page()
48 return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction); pci_map_page()
53 size_t size, int direction) pci_unmap_page()
55 dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction); pci_unmap_page()
60 int nents, int direction) pci_map_sg()
62 return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction); pci_map_sg()
67 int nents, int direction) pci_unmap_sg()
69 dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction); pci_unmap_sg()
74 size_t size, int direction) pci_dma_sync_single_for_cpu()
76 dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); pci_dma_sync_single_for_cpu()
81 size_t size, int direction) pci_dma_sync_single_for_device()
83 dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction); pci_dma_sync_single_for_device()
88 int nelems, int direction) pci_dma_sync_sg_for_cpu()
90 dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); pci_dma_sync_sg_for_cpu()
95 int nelems, int direction) pci_dma_sync_sg_for_device()
97 dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction); pci_dma_sync_sg_for_device()
38 pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, size_t size, int direction) pci_unmap_single() argument
45 pci_map_page(struct pci_dev *hwdev, struct page *page, unsigned long offset, size_t size, int direction) pci_map_page() argument
52 pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address, size_t size, int direction) pci_unmap_page() argument
59 pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction) pci_map_sg() argument
66 pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction) pci_unmap_sg() argument
73 pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction) pci_dma_sync_single_for_cpu() argument
80 pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle, size_t size, int direction) pci_dma_sync_single_for_device() argument
87 pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction) pci_dma_sync_sg_for_cpu() argument
94 pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg, int nelems, int direction) pci_dma_sync_sg_for_device() argument
|
| H A D | dma-mapping-broken.h | 40 enum dma_data_direction direction);
44 enum dma_data_direction direction);
48 enum dma_data_direction direction);
52 enum dma_data_direction direction);
56 size_t size, enum dma_data_direction direction);
60 enum dma_data_direction direction);
64 enum dma_data_direction direction);
69 enum dma_data_direction direction);
73 enum dma_data_direction direction);
93 enum dma_data_direction direction);
|
| /linux-4.4.14/arch/cris/include/asm/ |
| H A D | dma-mapping.h | 42 enum dma_data_direction direction) dma_map_single()
44 BUG_ON(direction == DMA_NONE); dma_map_single()
50 enum dma_data_direction direction) dma_unmap_single()
52 BUG_ON(direction == DMA_NONE); dma_unmap_single()
57 enum dma_data_direction direction) dma_map_sg()
65 size_t size, enum dma_data_direction direction) dma_map_page()
67 BUG_ON(direction == DMA_NONE); dma_map_page()
73 enum dma_data_direction direction) dma_unmap_page()
75 BUG_ON(direction == DMA_NONE); dma_unmap_page()
81 enum dma_data_direction direction) dma_unmap_sg()
83 BUG_ON(direction == DMA_NONE); dma_unmap_sg()
88 enum dma_data_direction direction) dma_sync_single_for_cpu()
94 enum dma_data_direction direction) dma_sync_single_for_device()
101 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
108 enum dma_data_direction direction) dma_sync_single_range_for_device()
114 enum dma_data_direction direction) dma_sync_sg_for_cpu()
120 enum dma_data_direction direction) dma_sync_sg_for_device()
157 enum dma_data_direction direction) dma_cache_sync()
41 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
49 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
56 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) dma_map_sg() argument
64 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
72 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
80 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
87 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
93 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
99 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) dma_sync_single_range_for_cpu() argument
106 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
113 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
119 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
156 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/frv/include/asm/ |
| H A D | dma-mapping.h | 25 enum dma_data_direction direction);
29 enum dma_data_direction direction) dma_unmap_single()
31 BUG_ON(direction == DMA_NONE); dma_unmap_single()
35 enum dma_data_direction direction);
39 enum dma_data_direction direction) dma_unmap_sg()
41 BUG_ON(direction == DMA_NONE); dma_unmap_sg()
46 size_t size, enum dma_data_direction direction);
50 enum dma_data_direction direction) dma_unmap_page()
52 BUG_ON(direction == DMA_NONE); dma_unmap_page()
58 enum dma_data_direction direction) dma_sync_single_for_cpu()
64 enum dma_data_direction direction) dma_sync_single_for_device()
72 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
79 enum dma_data_direction direction) dma_sync_single_range_for_device()
86 enum dma_data_direction direction) dma_sync_sg_for_cpu()
92 enum dma_data_direction direction) dma_sync_sg_for_device()
130 enum dma_data_direction direction) dma_cache_sync()
28 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
38 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
49 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
57 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
63 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
70 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) dma_sync_single_range_for_cpu() argument
77 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
85 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
91 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
129 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| H A D | pci.h | 30 extern void consistent_sync(void *vaddr, size_t size, int direction);
32 size_t size, int direction);
|
| /linux-4.4.14/arch/parisc/include/asm/ |
| H A D | dma-mapping.h | 14 dma_addr_t (*map_single)(struct device *dev, void *addr, size_t size, enum dma_data_direction direction);
15 void (*unmap_single)(struct device *dev, dma_addr_t iova, size_t size, enum dma_data_direction direction);
16 int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction);
17 void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nhwents, enum dma_data_direction direction);
18 void (*dma_sync_single_for_cpu)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
19 void (*dma_sync_single_for_device)(struct device *dev, dma_addr_t iova, unsigned long offset, size_t size, enum dma_data_direction direction);
20 void (*dma_sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
21 void (*dma_sync_sg_for_device)(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction);
82 enum dma_data_direction direction) dma_map_single()
84 return hppa_dma_ops->map_single(dev, ptr, size, direction); dma_map_single()
89 enum dma_data_direction direction) dma_unmap_single()
91 hppa_dma_ops->unmap_single(dev, dma_addr, size, direction); dma_unmap_single()
96 enum dma_data_direction direction) dma_map_sg()
98 return hppa_dma_ops->map_sg(dev, sg, nents, direction); dma_map_sg()
103 enum dma_data_direction direction) dma_unmap_sg()
105 hppa_dma_ops->unmap_sg(dev, sg, nhwentries, direction); dma_unmap_sg()
110 size_t size, enum dma_data_direction direction) dma_map_page()
112 return dma_map_single(dev, (page_address(page) + (offset)), size, direction); dma_map_page()
117 enum dma_data_direction direction) dma_unmap_page()
119 dma_unmap_single(dev, dma_address, size, direction); dma_unmap_page()
125 enum dma_data_direction direction) dma_sync_single_for_cpu()
128 hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, 0, size, direction); dma_sync_single_for_cpu()
133 enum dma_data_direction direction) dma_sync_single_for_device()
136 hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, 0, size, direction); dma_sync_single_for_device()
142 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
145 hppa_dma_ops->dma_sync_single_for_cpu(dev, dma_handle, offset, size, direction); dma_sync_single_range_for_cpu()
151 enum dma_data_direction direction) dma_sync_single_range_for_device()
154 hppa_dma_ops->dma_sync_single_for_device(dev, dma_handle, offset, size, direction); dma_sync_single_range_for_device()
159 enum dma_data_direction direction) dma_sync_sg_for_cpu()
162 hppa_dma_ops->dma_sync_sg_for_cpu(dev, sg, nelems, direction); dma_sync_sg_for_cpu()
167 enum dma_data_direction direction) dma_sync_sg_for_device()
170 hppa_dma_ops->dma_sync_sg_for_device(dev, sg, nelems, direction); dma_sync_sg_for_device()
192 enum dma_data_direction direction) dma_cache_sync()
81 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
88 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
95 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) dma_map_sg() argument
102 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
109 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
116 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
124 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
132 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
140 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) dma_sync_single_range_for_cpu() argument
149 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
158 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
166 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
191 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/tile/kernel/ |
| H A D | pci-dma.c | 102 size_t size, enum dma_data_direction direction) __dma_prep_page()
128 BUG_ON(direction == DMA_FROM_DEVICE || __dma_prep_page()
129 direction == DMA_BIDIRECTIONAL); __dma_prep_page()
150 size_t size, enum dma_data_direction direction) __dma_complete_page()
172 enum dma_data_direction direction) __dma_prep_pa_range()
179 __dma_prep_page(page, offset, bytes, direction); __dma_prep_pa_range()
188 enum dma_data_direction direction) __dma_complete_pa_range()
195 __dma_complete_page(page, offset, bytes, direction); __dma_complete_pa_range()
204 int nents, enum dma_data_direction direction, tile_dma_map_sg()
210 BUG_ON(!valid_dma_direction(direction)); tile_dma_map_sg()
216 __dma_prep_pa_range(sg->dma_address, sg->length, direction); for_each_sg()
226 int nents, enum dma_data_direction direction, tile_dma_unmap_sg()
232 BUG_ON(!valid_dma_direction(direction)); for_each_sg()
236 direction); for_each_sg()
242 enum dma_data_direction direction, tile_dma_map_page()
245 BUG_ON(!valid_dma_direction(direction)); tile_dma_map_page()
248 __dma_prep_page(page, offset, size, direction); tile_dma_map_page()
254 size_t size, enum dma_data_direction direction, tile_dma_unmap_page()
257 BUG_ON(!valid_dma_direction(direction)); tile_dma_unmap_page()
260 dma_address & (PAGE_SIZE - 1), size, direction); tile_dma_unmap_page()
266 enum dma_data_direction direction) tile_dma_sync_single_for_cpu()
268 BUG_ON(!valid_dma_direction(direction)); tile_dma_sync_single_for_cpu()
270 __dma_complete_pa_range(dma_handle, size, direction); tile_dma_sync_single_for_cpu()
275 enum dma_data_direction direction) tile_dma_sync_single_for_device()
277 __dma_prep_pa_range(dma_handle, size, direction); tile_dma_sync_single_for_device()
282 enum dma_data_direction direction) tile_dma_sync_sg_for_cpu()
287 BUG_ON(!valid_dma_direction(direction)); tile_dma_sync_sg_for_cpu()
292 sg_dma_len(sg), direction); for_each_sg()
298 enum dma_data_direction direction) tile_dma_sync_sg_for_device()
303 BUG_ON(!valid_dma_direction(direction)); tile_dma_sync_sg_for_device()
308 sg_dma_len(sg), direction); for_each_sg()
377 int nents, enum dma_data_direction direction, tile_pci_dma_map_sg()
383 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_map_sg()
389 __dma_prep_pa_range(sg->dma_address, sg->length, direction); for_each_sg()
402 enum dma_data_direction direction, tile_pci_dma_unmap_sg()
408 BUG_ON(!valid_dma_direction(direction)); for_each_sg()
412 direction); for_each_sg()
418 enum dma_data_direction direction, tile_pci_dma_map_page()
421 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_map_page()
424 __dma_prep_page(page, offset, size, direction); tile_pci_dma_map_page()
431 enum dma_data_direction direction, tile_pci_dma_unmap_page()
434 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_unmap_page()
439 dma_address & (PAGE_SIZE - 1), size, direction); tile_pci_dma_unmap_page()
445 enum dma_data_direction direction) tile_pci_dma_sync_single_for_cpu()
447 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_sync_single_for_cpu()
451 __dma_complete_pa_range(dma_handle, size, direction); tile_pci_dma_sync_single_for_cpu()
458 direction) tile_pci_dma_sync_single_for_device()
462 __dma_prep_pa_range(dma_handle, size, direction); tile_pci_dma_sync_single_for_device()
468 enum dma_data_direction direction) tile_pci_dma_sync_sg_for_cpu()
473 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_sync_sg_for_cpu()
478 sg_dma_len(sg), direction); for_each_sg()
485 enum dma_data_direction direction) tile_pci_dma_sync_sg_for_device()
490 BUG_ON(!valid_dma_direction(direction)); tile_pci_dma_sync_sg_for_device()
495 sg_dma_len(sg), direction); for_each_sg()
101 __dma_prep_page(struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) __dma_prep_page() argument
149 __dma_complete_page(struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) __dma_complete_page() argument
171 __dma_prep_pa_range(dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) __dma_prep_pa_range() argument
187 __dma_complete_pa_range(dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) __dma_complete_pa_range() argument
203 tile_dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) tile_dma_map_sg() argument
225 tile_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) tile_dma_unmap_sg() argument
240 tile_dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) tile_dma_map_page() argument
253 tile_dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) tile_dma_unmap_page() argument
263 tile_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) tile_dma_sync_single_for_cpu() argument
273 tile_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) tile_dma_sync_single_for_device() argument
280 tile_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) tile_dma_sync_sg_for_cpu() argument
296 tile_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) tile_dma_sync_sg_for_device() argument
376 tile_pci_dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) tile_pci_dma_map_sg() argument
400 tile_pci_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) tile_pci_dma_unmap_sg() argument
416 tile_pci_dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) tile_pci_dma_map_page() argument
429 tile_pci_dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) tile_pci_dma_unmap_page() argument
442 tile_pci_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) tile_pci_dma_sync_single_for_cpu() argument
454 tile_pci_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) tile_pci_dma_sync_single_for_device() argument
465 tile_pci_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) tile_pci_dma_sync_sg_for_cpu() argument
482 tile_pci_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) tile_pci_dma_sync_sg_for_device() argument
|
| /linux-4.4.14/arch/mn10300/include/asm/ |
| H A D | dma-mapping.h | 36 enum dma_data_direction direction) dma_map_single()
38 BUG_ON(direction == DMA_NONE); dma_map_single()
45 enum dma_data_direction direction) dma_unmap_single()
47 BUG_ON(direction == DMA_NONE); dma_unmap_single()
52 enum dma_data_direction direction) dma_map_sg()
57 BUG_ON(!valid_dma_direction(direction)); dma_map_sg()
72 enum dma_data_direction direction) dma_unmap_sg()
74 BUG_ON(!valid_dma_direction(direction)); dma_unmap_sg()
80 enum dma_data_direction direction) dma_map_page()
82 BUG_ON(direction == DMA_NONE); dma_map_page()
88 enum dma_data_direction direction) dma_unmap_page()
90 BUG_ON(direction == DMA_NONE); dma_unmap_page()
95 size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu()
101 size_t size, enum dma_data_direction direction) dma_sync_single_for_device()
109 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
116 enum dma_data_direction direction) dma_sync_single_range_for_device()
124 int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu()
130 int nelems, enum dma_data_direction direction) dma_sync_sg_for_device()
166 enum dma_data_direction direction) dma_cache_sync()
35 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
44 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
51 dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_map_sg() argument
71 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
78 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
87 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
94 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
100 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
107 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) dma_sync_single_range_for_cpu() argument
114 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
123 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
129 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
165 dma_cache_sync(void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/nios2/include/asm/ |
| H A D | dma-mapping.h | 18 enum dma_data_direction direction) __dma_sync_for_device()
20 switch (direction) { __dma_sync_for_device()
40 enum dma_data_direction direction) __dma_sync_for_cpu()
42 switch (direction) { __dma_sync_for_cpu()
66 enum dma_data_direction direction) dma_map_single()
68 BUG_ON(!valid_dma_direction(direction)); dma_map_single()
69 __dma_sync_for_device(ptr, size, direction); dma_map_single()
74 size_t size, enum dma_data_direction direction) dma_unmap_single()
79 enum dma_data_direction direction);
81 unsigned long offset, size_t size, enum dma_data_direction direction);
83 size_t size, enum dma_data_direction direction);
85 int nhwentries, enum dma_data_direction direction);
87 size_t size, enum dma_data_direction direction);
89 dma_addr_t dma_handle, size_t size, enum dma_data_direction direction);
92 enum dma_data_direction direction);
95 enum dma_data_direction direction);
97 int nelems, enum dma_data_direction direction);
99 int nelems, enum dma_data_direction direction);
126 enum dma_data_direction direction) dma_cache_sync()
17 __dma_sync_for_device(void *vaddr, size_t size, enum dma_data_direction direction) __dma_sync_for_device() argument
39 __dma_sync_for_cpu(void *vaddr, size_t size, enum dma_data_direction direction) __dma_sync_for_cpu() argument
64 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
73 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
125 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/include/linux/ |
| H A D | dma-debug.h | 39 int direction, dma_addr_t dma_addr,
45 size_t size, int direction, bool map_single);
48 int nents, int mapped_ents, int direction);
61 int direction);
65 size_t size, int direction);
71 int direction);
76 size_t size, int direction);
80 int nelems, int direction);
84 int nelems, int direction);
107 int direction, dma_addr_t dma_addr, debug_dma_map_page()
118 size_t size, int direction, debug_dma_unmap_page()
124 int nents, int mapped_ents, int direction) debug_dma_map_sg()
146 size_t size, int direction) debug_dma_sync_single_for_cpu()
152 size_t size, int direction) debug_dma_sync_single_for_device()
160 int direction) debug_dma_sync_single_range_for_cpu()
168 int direction) debug_dma_sync_single_range_for_device()
174 int nelems, int direction) debug_dma_sync_sg_for_cpu()
180 int nelems, int direction) debug_dma_sync_sg_for_device()
105 debug_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, int direction, dma_addr_t dma_addr, bool map_single) debug_dma_map_page() argument
117 debug_dma_unmap_page(struct device *dev, dma_addr_t addr, size_t size, int direction, bool map_single) debug_dma_unmap_page() argument
123 debug_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, int mapped_ents, int direction) debug_dma_map_sg() argument
144 debug_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) debug_dma_sync_single_for_cpu() argument
150 debug_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) debug_dma_sync_single_for_device() argument
156 debug_dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) debug_dma_sync_single_range_for_cpu() argument
164 debug_dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) debug_dma_sync_single_range_for_device() argument
172 debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, int direction) debug_dma_sync_sg_for_cpu() argument
178 debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, int direction) debug_dma_sync_sg_for_device() argument
|
| H A D | basic_mmio_gpio.h | 58 /* Shadowed direction registers to clear/set direction safely. */
|
| H A D | uio.h | 90 void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
92 void iov_iter_kvec(struct iov_iter *i, int direction, const struct kvec *kvec,
94 void iov_iter_bvec(struct iov_iter *i, int direction, const struct bio_vec *bvec,
|
| H A D | tifm.h | 149 int direction);
151 int direction);
|
| H A D | timb_dma.h | 29 * @rx: true if this channel handles data in the direction to
|
| /linux-4.4.14/arch/microblaze/kernel/ |
| H A D | dma.c | 55 int nents, enum dma_data_direction direction, dma_direct_map_sg()
65 sg->length, direction); for_each_sg() local
80 enum dma_data_direction direction, dma_direct_map_page()
83 __dma_sync(page_to_phys(page) + offset, size, direction); dma_direct_map_page()
90 enum dma_data_direction direction, dma_direct_unmap_page()
98 __dma_sync(dma_address, size, direction); dma_direct_unmap_page()
104 enum dma_data_direction direction) dma_direct_sync_single_for_cpu()
111 if (direction == DMA_FROM_DEVICE) dma_direct_sync_single_for_cpu()
112 __dma_sync(dma_handle, size, direction); dma_direct_sync_single_for_cpu()
118 enum dma_data_direction direction) dma_direct_sync_single_for_device()
125 if (direction == DMA_TO_DEVICE) dma_direct_sync_single_for_device()
126 __dma_sync(dma_handle, size, direction); dma_direct_sync_single_for_device()
132 enum dma_data_direction direction) dma_direct_sync_sg_for_cpu()
138 if (direction == DMA_FROM_DEVICE) dma_direct_sync_sg_for_cpu()
140 __dma_sync(sg->dma_address, sg->length, direction); dma_direct_sync_sg_for_cpu()
146 enum dma_data_direction direction) dma_direct_sync_sg_for_device()
152 if (direction == DMA_TO_DEVICE) dma_direct_sync_sg_for_device()
154 __dma_sync(sg->dma_address, sg->length, direction); dma_direct_sync_sg_for_device()
54 dma_direct_map_sg(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_map_sg() argument
76 dma_direct_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_map_page() argument
87 dma_direct_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_unmap_page() argument
102 dma_direct_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_direct_sync_single_for_cpu() argument
116 dma_direct_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_direct_sync_single_for_device() argument
130 dma_direct_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) dma_direct_sync_sg_for_cpu() argument
144 dma_direct_sync_sg_for_device(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) dma_direct_sync_sg_for_device() argument
|
| H A D | reset.c | 49 /* Setup output direction */ of_platform_reset_gpio_probe()
|
| /linux-4.4.14/include/linux/iio/ |
| H A D | events.h | 20 * @direction: Direction of the event. One of enum iio_event_direction.
27 #define IIO_EVENT_CODE(chan_type, diff, modifier, direction, \
30 ((u64)direction << 48) | ((u64)modifier << 40) | \
41 * @direction: Direction of the event. One of enum iio_event_direction.
45 type, direction) \
46 IIO_EVENT_CODE(chan_type, 0, modifier, direction, type, number, 0, 0)
53 * @direction: Direction of the event. One of enum iio_event_direction.
56 #define IIO_UNMOD_EVENT_CODE(chan_type, number, type, direction) \
57 IIO_EVENT_CODE(chan_type, 0, 0, direction, type, number, 0, 0)
|
| /linux-4.4.14/net/sunrpc/auth_gss/ |
| H A D | gss_krb5_seqnum.c | 43 krb5_make_rc4_seq_num(struct krb5_ctx *kctx, int direction, s32 seqnum, krb5_make_rc4_seq_num() argument
60 plain[4] = direction; krb5_make_rc4_seq_num()
61 plain[5] = direction; krb5_make_rc4_seq_num()
62 plain[6] = direction; krb5_make_rc4_seq_num()
63 plain[7] = direction; krb5_make_rc4_seq_num()
77 int direction, krb5_make_seq_num()
84 return krb5_make_rc4_seq_num(kctx, direction, seqnum, krb5_make_seq_num()
92 plain[4] = direction; krb5_make_seq_num()
93 plain[5] = direction; krb5_make_seq_num()
94 plain[6] = direction; krb5_make_seq_num()
95 plain[7] = direction; krb5_make_seq_num()
102 unsigned char *buf, int *direction, s32 *seqnum) krb5_get_rc4_seq_num()
128 *direction = plain[4]; krb5_get_rc4_seq_num()
141 int *direction, u32 *seqnum) krb5_get_seq_num()
151 direction, seqnum); krb5_get_seq_num()
160 *direction = plain[4]; krb5_get_seq_num()
75 krb5_make_seq_num(struct krb5_ctx *kctx, struct crypto_blkcipher *key, int direction, u32 seqnum, unsigned char *cksum, unsigned char *buf) krb5_make_seq_num() argument
101 krb5_get_rc4_seq_num(struct krb5_ctx *kctx, unsigned char *cksum, unsigned char *buf, int *direction, s32 *seqnum) krb5_get_rc4_seq_num() argument
138 krb5_get_seq_num(struct krb5_ctx *kctx, unsigned char *cksum, unsigned char *buf, int *direction, u32 *seqnum) krb5_get_seq_num() argument
|
| H A D | gss_krb5_unseal.c | 83 int direction; gss_verify_mic_v1() local
135 &direction, &seqnum)) gss_verify_mic_v1()
138 if ((ctx->initiate && direction != 0xff) || gss_verify_mic_v1()
139 (!ctx->initiate && direction != 0)) gss_verify_mic_v1()
|
| /linux-4.4.14/include/uapi/linux/netfilter/ |
| H A D | xt_connbytes.h | 24 __u8 direction; /* ipt_connbytes_direction */ member in struct:xt_connbytes_info
|
| H A D | nf_conntrack_common.h | 7 /* Part of an established connection (either direction). */
11 (in either direction). */
18 /* >= this indicates reply direction */
|
| /linux-4.4.14/drivers/char/xillybus/ |
| H A D | xillybus_of.c | 45 int direction) xilly_dma_sync_single_for_cpu_of()
47 dma_sync_single_for_cpu(ep->dev, dma_handle, size, direction); xilly_dma_sync_single_for_cpu_of()
53 int direction) xilly_dma_sync_single_for_device_of()
55 dma_sync_single_for_device(ep->dev, dma_handle, size, direction); xilly_dma_sync_single_for_device_of()
61 int direction) xilly_dma_sync_single_nop()
70 data->size, data->direction); xilly_of_unmap()
78 int direction, xilly_map_single_of()
90 addr = dma_map_single(ep->dev, ptr, size, direction); xilly_map_single_of()
100 this->direction = direction; xilly_map_single_of()
107 dma_unmap_single(ep->dev, addr, size, direction); xilly_map_single_of()
42 xilly_dma_sync_single_for_cpu_of(struct xilly_endpoint *ep, dma_addr_t dma_handle, size_t size, int direction) xilly_dma_sync_single_for_cpu_of() argument
50 xilly_dma_sync_single_for_device_of(struct xilly_endpoint *ep, dma_addr_t dma_handle, size_t size, int direction) xilly_dma_sync_single_for_device_of() argument
58 xilly_dma_sync_single_nop(struct xilly_endpoint *ep, dma_addr_t dma_handle, size_t size, int direction) xilly_dma_sync_single_nop() argument
75 xilly_map_single_of(struct xilly_endpoint *ep, void *ptr, size_t size, int direction, dma_addr_t *ret_dma_handle ) xilly_map_single_of() argument
|
| H A D | xillybus_pcie.c | 41 static int xilly_pci_direction(int direction) xilly_pci_direction() argument
43 switch (direction) { xilly_pci_direction()
56 int direction) xilly_dma_sync_single_for_cpu_pci()
61 xilly_pci_direction(direction)); xilly_dma_sync_single_for_cpu_pci()
67 int direction) xilly_dma_sync_single_for_device_pci()
72 xilly_pci_direction(direction)); xilly_dma_sync_single_for_device_pci()
80 data->size, data->direction); xilly_pci_unmap()
94 int direction, xilly_map_single_pci()
107 pci_direction = xilly_pci_direction(direction); xilly_map_single_pci()
119 this->direction = pci_direction; xilly_map_single_pci()
53 xilly_dma_sync_single_for_cpu_pci(struct xilly_endpoint *ep, dma_addr_t dma_handle, size_t size, int direction) xilly_dma_sync_single_for_cpu_pci() argument
64 xilly_dma_sync_single_for_device_pci(struct xilly_endpoint *ep, dma_addr_t dma_handle, size_t size, int direction) xilly_dma_sync_single_for_device_pci() argument
91 xilly_map_single_pci(struct xilly_endpoint *ep, void *ptr, size_t size, int direction, dma_addr_t *ret_dma_handle ) xilly_map_single_pci() argument
|
| /linux-4.4.14/arch/frv/mb93090-mb00/ |
| H A D | pci-dma.c | 42 enum dma_data_direction direction) dma_map_single()
44 BUG_ON(direction == DMA_NONE); dma_map_single()
54 enum dma_data_direction direction) dma_map_sg()
61 BUG_ON(direction == DMA_NONE); dma_map_sg()
85 size_t size, enum dma_data_direction direction) dma_map_page()
87 BUG_ON(direction == DMA_NONE); dma_map_page()
41 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
53 dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_map_sg() argument
84 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
|
| H A D | pci-dma-nommu.c | 111 enum dma_data_direction direction) dma_map_single()
113 BUG_ON(direction == DMA_NONE); dma_map_single()
123 enum dma_data_direction direction) dma_map_sg()
133 BUG_ON(direction == DMA_NONE);
141 size_t size, enum dma_data_direction direction) dma_map_page()
143 BUG_ON(direction == DMA_NONE); dma_map_page()
110 dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction direction) dma_map_single() argument
122 dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_map_sg() argument
140 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
|
| /linux-4.4.14/arch/mips/mm/ |
| H A D | dma-default.c | 235 enum dma_data_direction direction) __dma_sync_virtual()
237 switch (direction) { __dma_sync_virtual()
262 unsigned long offset, size_t size, enum dma_data_direction direction) __dma_sync()
281 __dma_sync_virtual(addr + offset, len, direction); __dma_sync()
285 size, direction); __dma_sync()
293 size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_unmap_page()
297 dma_addr & ~PAGE_MASK, size, direction); mips_dma_unmap_page() local
299 plat_unmap_dma_mem(dev, dma_addr, size, direction); mips_dma_unmap_page()
303 int nents, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_map_sg()
311 direction); for_each_sg() local
323 unsigned long offset, size_t size, enum dma_data_direction direction, mips_dma_map_page()
327 __dma_sync(page, offset, size, direction); mips_dma_map_page()
333 int nhwentries, enum dma_data_direction direction, mips_dma_unmap_sg()
341 direction != DMA_TO_DEVICE) for_each_sg()
343 direction); for_each_sg() local
344 plat_unmap_dma_mem(dev, sg->dma_address, sg->length, direction); for_each_sg()
349 dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) mips_dma_sync_single_for_cpu()
353 dma_handle & ~PAGE_MASK, size, direction); mips_dma_sync_single_for_cpu() local
358 dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) mips_dma_sync_single_for_device()
362 dma_handle & ~PAGE_MASK, size, direction); mips_dma_sync_single_for_device() local
367 enum dma_data_direction direction) mips_dma_sync_sg_for_cpu()
375 direction); for_each_sg() local
383 enum dma_data_direction direction) mips_dma_sync_sg_for_device()
391 direction); for_each_sg() local
407 enum dma_data_direction direction) dma_cache_sync()
409 BUG_ON(direction == DMA_NONE); dma_cache_sync()
412 __dma_sync_virtual(vaddr, size, direction); dma_cache_sync()
234 __dma_sync_virtual(void *addr, size_t size, enum dma_data_direction direction) __dma_sync_virtual() argument
261 __dma_sync(struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) __dma_sync() argument
292 mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_unmap_page() argument
302 mips_dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_map_sg() argument
322 mips_dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_map_page() argument
332 mips_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nhwentries, enum dma_data_direction direction, struct dma_attrs *attrs) mips_dma_unmap_sg() argument
348 mips_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) mips_dma_sync_single_for_cpu() argument
357 mips_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) mips_dma_sync_single_for_device() argument
365 mips_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) mips_dma_sync_sg_for_cpu() argument
381 mips_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) mips_dma_sync_sg_for_device() argument
406 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/microblaze/include/asm/ |
| H A D | dma-mapping.h | 50 size_t size, enum dma_data_direction direction) __dma_sync()
52 switch (direction) { __dma_sync()
66 enum dma_data_direction direction) dma_cache_sync()
68 BUG_ON(direction == DMA_NONE); dma_cache_sync()
69 __dma_sync(virt_to_phys(vaddr), size, (int)direction); dma_cache_sync()
49 __dma_sync(unsigned long paddr, size_t size, enum dma_data_direction direction) __dma_sync() argument
65 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/drivers/staging/rdma/ipath/ |
| H A D | ipath_dma.c | 57 enum dma_data_direction direction) ipath_dma_map_single()
59 BUG_ON(!valid_dma_direction(direction)); ipath_dma_map_single()
65 enum dma_data_direction direction) ipath_dma_unmap_single()
67 BUG_ON(!valid_dma_direction(direction)); ipath_dma_unmap_single()
74 enum dma_data_direction direction) ipath_dma_map_page()
78 BUG_ON(!valid_dma_direction(direction)); ipath_dma_map_page()
96 enum dma_data_direction direction) ipath_dma_unmap_page()
98 BUG_ON(!valid_dma_direction(direction)); ipath_dma_unmap_page()
102 int nents, enum dma_data_direction direction) ipath_map_sg()
109 BUG_ON(!valid_dma_direction(direction)); ipath_map_sg()
128 enum dma_data_direction direction) ipath_unmap_sg()
130 BUG_ON(!valid_dma_direction(direction)); ipath_unmap_sg()
55 ipath_dma_map_single(struct ib_device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction) ipath_dma_map_single() argument
63 ipath_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) ipath_dma_unmap_single() argument
70 ipath_dma_map_page(struct ib_device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) ipath_dma_map_page() argument
94 ipath_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) ipath_dma_unmap_page() argument
101 ipath_map_sg(struct ib_device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) ipath_map_sg() argument
126 ipath_unmap_sg(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) ipath_unmap_sg() argument
|
| H A D | ipath_user_pages.c | 106 unsigned long offset, size_t size, int direction) ipath_map_page()
110 phys = pci_map_page(hwdev, page, offset, size, direction); ipath_map_page()
113 pci_unmap_page(hwdev, phys, size, direction); ipath_map_page()
114 phys = pci_map_page(hwdev, page, offset, size, direction); ipath_map_page()
130 int direction) ipath_map_single()
134 phys = pci_map_single(hwdev, ptr, size, direction); ipath_map_single()
137 pci_unmap_single(hwdev, phys, size, direction); ipath_map_single()
138 phys = pci_map_single(hwdev, ptr, size, direction); ipath_map_single()
105 ipath_map_page(struct pci_dev *hwdev, struct page *page, unsigned long offset, size_t size, int direction) ipath_map_page() argument
129 ipath_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction) ipath_map_single() argument
|
| /linux-4.4.14/drivers/infiniband/hw/qib/ |
| H A D | qib_dma.c | 54 size_t size, enum dma_data_direction direction) qib_dma_map_single()
56 BUG_ON(!valid_dma_direction(direction)); qib_dma_map_single()
61 enum dma_data_direction direction) qib_dma_unmap_single()
63 BUG_ON(!valid_dma_direction(direction)); qib_dma_unmap_single()
68 enum dma_data_direction direction) qib_dma_map_page()
72 BUG_ON(!valid_dma_direction(direction)); qib_dma_map_page()
89 enum dma_data_direction direction) qib_dma_unmap_page()
91 BUG_ON(!valid_dma_direction(direction)); qib_dma_unmap_page()
95 int nents, enum dma_data_direction direction) qib_map_sg()
102 BUG_ON(!valid_dma_direction(direction)); qib_map_sg()
121 enum dma_data_direction direction) qib_unmap_sg()
123 BUG_ON(!valid_dma_direction(direction)); qib_unmap_sg()
53 qib_dma_map_single(struct ib_device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction) qib_dma_map_single() argument
60 qib_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) qib_dma_unmap_single() argument
66 qib_dma_map_page(struct ib_device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) qib_dma_map_page() argument
88 qib_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) qib_dma_unmap_page() argument
94 qib_map_sg(struct ib_device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) qib_map_sg() argument
119 qib_unmap_sg(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) qib_unmap_sg() argument
|
| H A D | qib_user_pages.c | 102 unsigned long offset, size_t size, int direction) qib_map_page()
106 phys = pci_map_page(hwdev, page, offset, size, direction); qib_map_page()
109 pci_unmap_page(hwdev, phys, size, direction); qib_map_page()
110 phys = pci_map_page(hwdev, page, offset, size, direction); qib_map_page()
101 qib_map_page(struct pci_dev *hwdev, struct page *page, unsigned long offset, size_t size, int direction) qib_map_page() argument
|
| /linux-4.4.14/arch/powerpc/kernel/ |
| H A D | dma-iommu.c | 42 enum dma_data_direction direction, dma_iommu_map_page()
46 size, device_to_mask(dev), direction, attrs); dma_iommu_map_page()
51 size_t size, enum dma_data_direction direction, dma_iommu_unmap_page()
54 iommu_unmap_page(get_iommu_table_base(dev), dma_handle, size, direction, dma_iommu_unmap_page() local
60 int nelems, enum dma_data_direction direction, dma_iommu_map_sg()
64 device_to_mask(dev), direction, attrs); dma_iommu_map_sg()
68 int nelems, enum dma_data_direction direction, dma_iommu_unmap_sg()
72 direction, attrs); dma_iommu_unmap_sg() local
40 dma_iommu_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_iommu_map_page() argument
50 dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_iommu_unmap_page() argument
59 dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_iommu_map_sg() argument
67 dma_iommu_unmap_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_iommu_unmap_sg() argument
|
| H A D | dma.c | 197 int nents, enum dma_data_direction direction, dma_direct_map_sg()
206 __dma_sync_page(sg_page(sg), sg->offset, sg->length, direction); for_each_sg() local
213 int nents, enum dma_data_direction direction, dma_direct_unmap_sg()
245 enum dma_data_direction direction, dma_direct_unmap_page()
253 enum dma_data_direction direction) dma_direct_sync_sg()
259 __dma_sync_page(sg_page(sg), sg->offset, sg->length, direction); dma_direct_sync_sg()
264 enum dma_data_direction direction) dma_direct_sync_single()
266 __dma_sync(bus_to_virt(dma_handle), size, direction); dma_direct_sync_single() local
196 dma_direct_map_sg(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_map_sg() argument
212 dma_direct_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_unmap_sg() argument
242 dma_direct_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_direct_unmap_page() argument
251 dma_direct_sync_sg(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) dma_direct_sync_sg() argument
262 dma_direct_sync_single(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_direct_sync_single() argument
|
| H A D | iommu.c | 308 enum dma_data_direction direction, iommu_alloc()
327 IOMMU_PAGE_MASK(tbl), direction, attrs); iommu_alloc()
433 unsigned long mask, enum dma_data_direction direction, ppc_iommu_map_sg()
443 BUG_ON(direction == DMA_NONE); ppc_iommu_map_sg()
500 direction, attrs); for_each_sg()
576 int nelems, enum dma_data_direction direction, ppc_iommu_unmap_sg()
581 BUG_ON(direction == DMA_NONE); ppc_iommu_unmap_sg()
755 unsigned long mask, enum dma_data_direction direction, iommu_map_page()
763 BUG_ON(direction == DMA_NONE); iommu_map_page()
775 dma_handle = iommu_alloc(dev, tbl, vaddr, npages, direction, iommu_map_page()
792 size_t size, enum dma_data_direction direction, iommu_unmap_page()
797 BUG_ON(direction == DMA_NONE); iommu_unmap_page()
986 unsigned long *hpa, enum dma_data_direction *direction) iommu_tce_xchg()
990 ret = tbl->it_ops->exchange(tbl, entry, hpa, direction); iommu_tce_xchg()
992 if (!ret && ((*direction == DMA_FROM_DEVICE) || iommu_tce_xchg()
993 (*direction == DMA_BIDIRECTIONAL))) iommu_tce_xchg()
306 iommu_alloc(struct device *dev, struct iommu_table *tbl, void *page, unsigned int npages, enum dma_data_direction direction, unsigned long mask, unsigned int align_order, struct dma_attrs *attrs) iommu_alloc() argument
431 ppc_iommu_map_sg(struct device *dev, struct iommu_table *tbl, struct scatterlist *sglist, int nelems, unsigned long mask, enum dma_data_direction direction, struct dma_attrs *attrs) ppc_iommu_map_sg() argument
575 ppc_iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) ppc_iommu_unmap_sg() argument
753 iommu_map_page(struct device *dev, struct iommu_table *tbl, struct page *page, unsigned long offset, size_t size, unsigned long mask, enum dma_data_direction direction, struct dma_attrs *attrs) iommu_map_page() argument
791 iommu_unmap_page(struct iommu_table *tbl, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) iommu_unmap_page() argument
985 iommu_tce_xchg(struct iommu_table *tbl, unsigned long entry, unsigned long *hpa, enum dma_data_direction *direction) iommu_tce_xchg() argument
|
| /linux-4.4.14/arch/avr32/include/asm/ |
| H A D | dma-mapping.h | 12 int direction);
108 * @dir: DMA transfer direction
118 enum dma_data_direction direction) dma_map_single()
120 dma_cache_sync(dev, cpu_addr, size, direction); dma_map_single()
129 * @dir: DMA transfer direction
140 enum dma_data_direction direction) dma_unmap_single()
151 * @dir: DMA transfer direction
162 enum dma_data_direction direction) dma_map_page()
165 size, direction); dma_map_page()
173 * @dir: DMA transfer direction
184 enum dma_data_direction direction) dma_unmap_page()
186 dma_unmap_single(dev, dma_address, size, direction); dma_unmap_page()
194 * @dir: DMA transfer direction
213 enum dma_data_direction direction) dma_map_sg()
223 dma_cache_sync(dev, virt, sg->length, direction); for_each_sg()
234 * @dir: DMA transfer direction
242 enum dma_data_direction direction) dma_unmap_sg()
252 * @dir: DMA transfer direction
266 size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu()
277 size_t size, enum dma_data_direction direction) dma_sync_single_for_device()
279 dma_cache_sync(dev, bus_to_virt(dma_handle), size, direction); dma_sync_single_for_device()
285 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
288 dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction); dma_sync_single_range_for_cpu()
294 enum dma_data_direction direction) dma_sync_single_range_for_device()
297 dma_sync_single_for_device(dev, dma_handle, offset+size, direction); dma_sync_single_range_for_device()
305 * @dir: DMA transfer direction
315 int nents, enum dma_data_direction direction) dma_sync_sg_for_cpu()
326 int nents, enum dma_data_direction direction) dma_sync_sg_for_device()
332 dma_cache_sync(dev, sg_virt(sg), sg->length, direction); dma_sync_sg_for_device()
117 dma_map_single(struct device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction) dma_map_single() argument
139 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) dma_unmap_single() argument
160 dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) dma_map_page() argument
183 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size, enum dma_data_direction direction) dma_unmap_page() argument
212 dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_map_sg() argument
241 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, enum dma_data_direction direction) dma_unmap_sg() argument
265 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_cpu() argument
276 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) dma_sync_single_for_device() argument
283 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) dma_sync_single_range_for_cpu() argument
292 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
314 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) dma_sync_sg_for_cpu() argument
325 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) dma_sync_sg_for_device() argument
|
| /linux-4.4.14/include/linux/platform_data/ |
| H A D | dma-ep93xx.h | 31 * @direction: TX/RX channel
40 enum dma_transfer_direction direction; member in struct:ep93xx_dma_data
76 * ep93xx_dma_chan_direction - returns direction the channel can be used
80 * channel supports given DMA direction. Only M2P channels have such
81 * limitation, for M2M channels the direction is configurable.
|
| H A D | dma-ste-dma40.h | 173 * @direction: direction of transfer
181 enum dma_transfer_direction direction, stedma40_slave_mem()
189 return dmaengine_prep_slave_sg(chan, &sg, 1, direction, flags); stedma40_slave_mem()
202 enum dma_transfer_direction direction, stedma40_slave_mem()
178 stedma40_slave_mem(struct dma_chan *chan, dma_addr_t addr, unsigned int size, enum dma_transfer_direction direction, unsigned long flags) stedma40_slave_mem() argument
199 stedma40_slave_mem(struct dma_chan *chan, dma_addr_t addr, unsigned int size, enum dma_transfer_direction direction, unsigned long flags) stedma40_slave_mem() argument
|
| H A D | bfin_rotary.h | 17 #define ROT_DIR_CNT CNTMODE_DIRCNT /* direction counter mode */
62 #define CNTMODE_DIRCNT (4 << CNTMODE_SHIFT) /* direction counter mode */
63 #define CNTMODE_DIRTMR (5 << CNTMODE_SHIFT) /* direction timer mode */
|
| H A D | ad7793.h | 55 * enum ad7793_current_source_direction - AD7793 excitation current direction
97 * @current_source_direction: Excitation current direction selection
|
| /linux-4.4.14/drivers/staging/rdma/hfi1/ |
| H A D | dma.c | 72 size_t size, enum dma_data_direction direction) hfi1_dma_map_single()
74 if (WARN_ON(!valid_dma_direction(direction))) hfi1_dma_map_single()
81 enum dma_data_direction direction) hfi1_dma_unmap_single()
88 enum dma_data_direction direction) hfi1_dma_map_page()
92 if (WARN_ON(!valid_dma_direction(direction))) hfi1_dma_map_page()
106 enum dma_data_direction direction) hfi1_dma_unmap_page()
112 int nents, enum dma_data_direction direction) hfi1_map_sg()
119 if (WARN_ON(!valid_dma_direction(direction))) hfi1_map_sg()
138 enum dma_data_direction direction) hfi1_unmap_sg()
71 hfi1_dma_map_single(struct ib_device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction) hfi1_dma_map_single() argument
80 hfi1_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) hfi1_dma_unmap_single() argument
86 hfi1_dma_map_page(struct ib_device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) hfi1_dma_map_page() argument
105 hfi1_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) hfi1_dma_unmap_page() argument
111 hfi1_map_sg(struct ib_device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction) hfi1_map_sg() argument
136 hfi1_unmap_sg(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) hfi1_unmap_sg() argument
|
| H A D | user_pages.c | 110 unsigned long offset, size_t size, int direction) hfi1_map_page()
114 phys = pci_map_page(hwdev, page, offset, size, direction); hfi1_map_page()
109 hfi1_map_page(struct pci_dev *hwdev, struct page *page, unsigned long offset, size_t size, int direction) hfi1_map_page() argument
|
| /linux-4.4.14/arch/cris/include/uapi/asm/ |
| H A D | etraxgpio.h | 6 * /dev/gpioa minor 0, 8 bit GPIO, each bit can change direction
7 * /dev/gpiob minor 1, 8 bit GPIO, each bit can change direction
47 /* GPIO direction ioctl's */
48 #define IO_READDIR 0x8 /* Read direction 0=input 1=output (obsolete) */
49 #define IO_SETINPUT 0x9 /* Set direction for bits set, 0=unchanged 1=input,
51 #define IO_SETOUTPUT 0xA /* Set direction for bits set, 0=unchanged 1=output,
|
| /linux-4.4.14/net/netfilter/ |
| H A D | xt_connbytes.c | 43 switch (sinfo->direction) { connbytes_mt()
57 switch (sinfo->direction) { connbytes_mt()
71 switch (sinfo->direction) { connbytes_mt()
108 if (sinfo->direction != XT_CONNBYTES_DIR_ORIGINAL && connbytes_mt_check()
109 sinfo->direction != XT_CONNBYTES_DIR_REPLY && connbytes_mt_check()
110 sinfo->direction != XT_CONNBYTES_DIR_BOTH) connbytes_mt_check()
|
| /linux-4.4.14/drivers/net/ethernet/intel/ixgbe/ |
| H A D | ixgbe_dcb.c | 76 * @direction: Configuring either Tx or Rx.
84 int max_frame, u8 direction) ixgbe_dcb_calculate_tc_credits()
105 p = &dcb_config->tc_config[i].path[direction]; ixgbe_dcb_calculate_tc_credits()
106 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id]; ixgbe_dcb_calculate_tc_credits()
127 p = &dcb_config->tc_config[i].path[direction]; ixgbe_dcb_calculate_tc_credits()
128 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id]; ixgbe_dcb_calculate_tc_credits()
155 if (direction == DCB_TX_CONFIG) { ixgbe_dcb_calculate_tc_credits()
188 void ixgbe_dcb_unpack_refill(struct ixgbe_dcb_config *cfg, int direction, ixgbe_dcb_unpack_refill() argument
195 refill[tc] = tc_config[tc].path[direction].data_credits_refill; ixgbe_dcb_unpack_refill()
207 void ixgbe_dcb_unpack_bwgid(struct ixgbe_dcb_config *cfg, int direction, ixgbe_dcb_unpack_bwgid() argument
214 bwgid[tc] = tc_config[tc].path[direction].bwg_id; ixgbe_dcb_unpack_bwgid()
217 void ixgbe_dcb_unpack_prio(struct ixgbe_dcb_config *cfg, int direction, ixgbe_dcb_unpack_prio() argument
224 ptype[tc] = tc_config[tc].path[direction].prio_type; ixgbe_dcb_unpack_prio()
227 u8 ixgbe_dcb_get_tc_from_up(struct ixgbe_dcb_config *cfg, int direction, u8 up) ixgbe_dcb_get_tc_from_up() argument
243 if (prio_mask & tc_config[tc].path[direction].up_to_tc_bitmap) ixgbe_dcb_get_tc_from_up()
250 void ixgbe_dcb_unpack_map(struct ixgbe_dcb_config *cfg, int direction, u8 *map) ixgbe_dcb_unpack_map() argument
255 map[up] = ixgbe_dcb_get_tc_from_up(cfg, direction, up); ixgbe_dcb_unpack_map()
82 ixgbe_dcb_calculate_tc_credits(struct ixgbe_hw *hw, struct ixgbe_dcb_config *dcb_config, int max_frame, u8 direction) ixgbe_dcb_calculate_tc_credits() argument
|
| /linux-4.4.14/include/linux/netfilter/ |
| H A D | nf_conntrack_tcp.h | 13 u_int8_t flags; /* per direction options */
17 struct ip_ct_tcp_state seen[2]; /* connection parameters per direction */
|
| /linux-4.4.14/sound/firewire/ |
| H A D | cmp.h | 34 enum cmp_direction direction; member in struct:cmp_connection
39 enum cmp_direction direction,
|
| H A D | packets-buffer.h | 22 enum dma_data_direction direction);
|
| H A D | packets-buffer.c | 19 * @direction: %DMA_TO_DEVICE or %DMA_FROM_DEVICE
23 enum dma_data_direction direction) iso_packets_buffer_init()
45 pages, direction); iso_packets_buffer_init()
21 iso_packets_buffer_init(struct iso_packets_buffer *b, struct fw_unit *unit, unsigned int count, unsigned int packet_size, enum dma_data_direction direction) iso_packets_buffer_init() argument
|
| H A D | cmp.c | 52 (c->direction == CMP_INPUT) ? 'i' : 'o', cmp_error()
59 if (c->direction == CMP_INPUT) mpr_address()
67 if (c->direction == CMP_INPUT) pcr_address()
117 * @direction: input or output
122 enum cmp_direction direction, cmp_connection_init()
129 c->direction = direction; cmp_connection_init()
292 if (c->direction == CMP_OUTPUT) cmp_connection_establish()
346 if (c->direction == CMP_OUTPUT) cmp_connection_update()
120 cmp_connection_init(struct cmp_connection *c, struct fw_unit *unit, enum cmp_direction direction, unsigned int pcr_index) cmp_connection_init() argument
|
| /linux-4.4.14/lib/ |
| H A D | dma-debug.c | 64 * @direction: enum dma_data_direction
78 int direction; member in struct:dma_debug_entry
323 entry->direction == ref->direction ? ++match_lvl : 0; __hash_bucket_find()
424 dir2name[entry->direction], debug_dma_dump_mappings()
529 if (entry->direction == DMA_TO_DEVICE) active_cacheline_insert()
547 if (entry->direction == DMA_TO_DEVICE) active_cacheline_remove()
974 dir2name[entry->direction], type2name[entry->type]); dma_debug_device_change()
1140 if (ref->direction != entry->direction) { check_unmap()
1142 "DMA memory with different direction " check_unmap()
1146 dir2name[entry->direction], check_unmap()
1147 dir2name[ref->direction]); check_unmap()
1219 if (entry->direction == DMA_BIDIRECTIONAL) check_sync()
1222 if (ref->direction != entry->direction) { check_sync()
1224 "DMA memory with different direction " check_sync()
1228 dir2name[entry->direction], check_sync()
1229 dir2name[ref->direction]); check_sync()
1232 if (to_cpu && !(entry->direction == DMA_FROM_DEVICE) && check_sync()
1233 !(ref->direction == DMA_TO_DEVICE)) check_sync()
1239 dir2name[entry->direction], check_sync()
1240 dir2name[ref->direction]); check_sync()
1242 if (!to_cpu && !(entry->direction == DMA_TO_DEVICE) && check_sync()
1243 !(ref->direction == DMA_FROM_DEVICE)) check_sync()
1249 dir2name[entry->direction], check_sync()
1250 dir2name[ref->direction]); check_sync()
1265 size_t size, int direction, dma_addr_t dma_addr, debug_dma_map_page()
1286 entry->direction = direction; debug_dma_map_page()
1342 size_t size, int direction, bool map_single) debug_dma_unmap_page()
1349 .direction = direction, debug_dma_unmap_page()
1363 int nents, int mapped_ents, int direction) debug_dma_map_sg()
1383 entry->direction = direction; for_each_sg()
1434 .direction = dir, for_each_sg()
1470 entry->direction = DMA_BIDIRECTIONAL; debug_dma_alloc_coherent()
1486 .direction = DMA_BIDIRECTIONAL, debug_dma_free_coherent()
1497 size_t size, int direction) debug_dma_sync_single_for_cpu()
1508 ref.direction = direction; debug_dma_sync_single_for_cpu()
1517 int direction) debug_dma_sync_single_for_device()
1528 ref.direction = direction; debug_dma_sync_single_for_device()
1538 int direction) debug_dma_sync_single_range_for_cpu()
1549 ref.direction = direction; debug_dma_sync_single_range_for_cpu()
1559 size_t size, int direction) debug_dma_sync_single_range_for_device()
1570 ref.direction = direction; debug_dma_sync_single_range_for_device()
1578 int nelems, int direction) debug_dma_sync_sg_for_cpu()
1595 .direction = direction, for_each_sg()
1611 int nelems, int direction) debug_dma_sync_sg_for_device()
1628 .direction = direction, for_each_sg()
1264 debug_dma_map_page(struct device *dev, struct page *page, size_t offset, size_t size, int direction, dma_addr_t dma_addr, bool map_single) debug_dma_map_page() argument
1341 debug_dma_unmap_page(struct device *dev, dma_addr_t addr, size_t size, int direction, bool map_single) debug_dma_unmap_page() argument
1362 debug_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, int mapped_ents, int direction) debug_dma_map_sg() argument
1496 debug_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) debug_dma_sync_single_for_cpu() argument
1515 debug_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, int direction) debug_dma_sync_single_for_device() argument
1535 debug_dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) debug_dma_sync_single_range_for_cpu() argument
1556 debug_dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, int direction) debug_dma_sync_single_range_for_device() argument
1577 debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems, int direction) debug_dma_sync_sg_for_cpu() argument
1610 debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, int direction) debug_dma_sync_sg_for_device() argument
|
| H A D | iov_iter.c | 346 void iov_iter_init(struct iov_iter *i, int direction, iov_iter_init() argument
352 direction |= ITER_KVEC; iov_iter_init()
353 i->type = direction; iov_iter_init()
356 i->type = direction; iov_iter_init()
529 void iov_iter_kvec(struct iov_iter *i, int direction, iov_iter_kvec() argument
533 BUG_ON(!(direction & ITER_KVEC)); iov_iter_kvec()
534 i->type = direction; iov_iter_kvec()
542 void iov_iter_bvec(struct iov_iter *i, int direction, iov_iter_bvec() argument
546 BUG_ON(!(direction & ITER_BVEC)); iov_iter_bvec()
547 i->type = direction; iov_iter_bvec()
|
| /linux-4.4.14/include/sound/ |
| H A D | hda_regmap.h | 39 * @dir: direction (#HDA_INPUT, #HDA_OUTPUT)
53 * @dir: direction (#HDA_INPUT, #HDA_OUTPUT)
122 * @direction: #HDA_INPUT or #HDA_OUTPUT
123 * @index: the index value (only for input direction)
145 * @direction: #HDA_INPUT or #HDA_OUTPUT
146 * @idx: the index value (only for input direction)
167 * @direction: #HDA_INPUT or #HDA_OUTPUT
168 * @index: the index value (only for input direction)
189 * @direction: #HDA_INPUT or #HDA_OUTPUT
190 * @idx: the index value (only for input direction)
|
| H A D | compress_driver.h | 71 * @direction: stream direction, playback/recording
81 enum snd_compr_direction direction; member in struct:snd_compr_stream
142 * @direction: Playback or capture direction
152 unsigned int direction; member in struct:snd_compr
|
| H A D | i2c.h | 42 void (*direction)(struct snd_i2c_bus *bus, int clock, int data); /* set line direction (0 = write, 1 = read) */ member in struct:snd_i2c_bit_ops
|
| /linux-4.4.14/arch/powerpc/include/asm/ |
| H A D | iommu.h | 49 * When called with direction==DMA_NONE, it is equal to clear().
55 enum dma_data_direction direction,
59 * Exchanges existing TCE with new TCE plus direction bits;
60 * returns old TCE and DMA direction mask.
66 enum dma_data_direction *direction);
210 unsigned long *hpa, enum dma_data_direction *direction);
250 enum dma_data_direction direction,
255 enum dma_data_direction direction,
266 enum dma_data_direction direction,
269 size_t size, enum dma_data_direction direction,
|
| H A D | backlight.h | 23 extern void pmac_backlight_key(int direction); pmac_backlight_key_up()
|
| H A D | dma-mapping.h | 49 extern void __dma_sync(void *vaddr, size_t size, int direction);
51 size_t size, int direction);
161 enum dma_data_direction direction) dma_cache_sync()
163 BUG_ON(direction == DMA_NONE); dma_cache_sync()
164 __dma_sync(vaddr, size, (int)direction); dma_cache_sync()
160 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/drivers/input/ |
| H A D | ff-memless.c | 225 * Only left/right direction should be used (under/over 0x8000) for
226 * forward/reverse motor direction (to keep calculation fast & simple).
228 static u16 ml_calculate_direction(u16 direction, u16 force, ml_calculate_direction() argument
234 return direction; ml_calculate_direction()
235 return (((u32)(direction >> 1) * force + ml_calculate_direction()
266 i = new->direction * 360 / 0xffff; ml_combine_effects()
288 effect->direction = ml_calculate_direction( ml_combine_effects()
289 effect->direction, ml_combine_effects()
291 new->direction, strong); ml_combine_effects()
293 effect->direction = ml_calculate_direction( ml_combine_effects()
294 effect->direction, ml_combine_effects()
296 new->direction, weak); ml_combine_effects()
298 effect->direction = 0; ml_combine_effects()
314 effect->direction = ml_calculate_direction( ml_combine_effects()
315 effect->direction, ml_combine_effects()
317 new->direction, i); ml_combine_effects()
319 effect->direction = 0; ml_combine_effects()
|
| H A D | input-compat.h | 55 __u16 direction; member in struct:ff_effect_compat
|
| /linux-4.4.14/drivers/usb/core/ |
| H A D | endpoint.c | 132 char *direction; direction_show() local
135 direction = "both"; direction_show()
137 direction = "in"; direction_show()
139 direction = "out"; direction_show()
140 return sprintf(buf, "%s\n", direction); direction_show()
142 static DEVICE_ATTR_RO(direction);
|
| /linux-4.4.14/drivers/parisc/ |
| H A D | ccio-rm-dma.c | 103 int direction) ccio_map_single()
109 size_t size, int direction) ccio_unmap_single()
115 static int ccio_map_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, int direction) ccio_map_sg() argument
121 sg_dma_address(sglist) = ccio_map_single(dev, sglist->address, sglist->length, direction); ccio_map_sg()
131 static void ccio_unmap_sg(struct pci_dev *dev, struct scatterlist *sglist, int nents, int direction) ccio_unmap_sg() argument
135 ccio_unmap_single(dev, sg_dma_address(sglist), sg_dma_len(sglist), direction); ccio_unmap_sg()
102 ccio_map_single(struct pci_dev *dev, void *ptr, size_t size, int direction) ccio_map_single() argument
108 ccio_unmap_single(struct pci_dev *dev, dma_addr_t dma_addr, size_t size, int direction) ccio_unmap_single() argument
|
| /linux-4.4.14/arch/arm/kernel/ |
| H A D | dma-isa.c | 63 enum dma_data_direction direction; isa_enable_dma() local
68 direction = DMA_FROM_DEVICE; isa_enable_dma()
72 direction = DMA_TO_DEVICE; isa_enable_dma()
76 direction = DMA_BIDIRECTIONAL; isa_enable_dma()
80 direction = DMA_NONE; isa_enable_dma()
94 direction); isa_enable_dma()
|
| /linux-4.4.14/drivers/crypto/amcc/ |
| H A D | crypto4xx_sa.c | 42 if (ctx->direction == DIR_INBOUND) get_dynamic_sa_offset_state_ptr_field()
68 if (ctx->direction == DIR_INBOUND) get_dynamic_sa_iv_size()
79 if (ctx->direction == DIR_INBOUND) get_dynamic_sa_offset_key_field()
|
| H A D | crypto4xx_alg.c | 77 ctx->direction = DIR_OUTBOUND; crypto4xx_encrypt()
91 ctx->direction = DIR_INBOUND; crypto4xx_decrypt()
158 ctx->direction = DIR_INBOUND; crypto4xx_setkey_aes()
225 ctx->direction = DIR_INBOUND; crypto4xx_hash_alg_init()
249 ctx->direction = DIR_INBOUND; crypto4xx_hash_init()
261 ctx->direction = DIR_INBOUND; crypto4xx_hash_update()
279 ctx->direction = DIR_INBOUND; crypto4xx_hash_digest()
|
| /linux-4.4.14/drivers/gpio/ |
| H A D | gpio-iop.c | 38 static void gpio_line_config(int line, int direction) gpio_line_config() argument
45 if (direction == GPIO_IN) { gpio_line_config()
47 } else if (direction == GPIO_OUT) { gpio_line_config()
|
| H A D | gpio-xilinx.c | 28 #define XGPIO_TRI_OFFSET (0x4) /* I/O direction register */
46 * @gpio_dir: GPIO direction shadow register
89 * 0 if direction of GPIO signals is set as input otherwise it
125 /* Write to GPIO signal and set its direction to output */ xgpio_set()
138 * xgpio_dir_in - Set the direction of the specified GPIO signal as input.
143 * 0 - if direction of GPIO signals is set as input
157 /* Set the GPIO bit in shadow register and set direction as input */ xgpio_dir_in()
168 * xgpio_dir_out - Set the direction of the specified GPIO signal as output.
173 * This function sets the direction of specified GPIO signal as output.
198 /* Clear the GPIO bit in shadow register and set direction as output */ xgpio_dir_out()
270 /* Update GPIO direction shadow register with default value */ xgpio_probe()
291 /* Update GPIO direction shadow register with default value */ xgpio_probe()
|
| H A D | gpio-lp3943.c | 45 u16 input_mask; /* 1 = GPIO is input direction, 0 = output */
145 * LP3943 doesn't have the GPIO direction register. It provides lp3943_gpio_get()
147 * So, direction info is required to handle the 'get' operation. lp3943_gpio_get()
148 * This variable is updated whenever the direction is changed and lp3943_gpio_get()
|
| H A D | gpio-mpc5200.c | 110 /* set the direction */ mpc52xx_wkup_gpio_dir_in()
136 /* Then set direction */ mpc52xx_wkup_gpio_dir_out()
274 /* set the direction */ mpc52xx_simple_gpio_dir_in()
301 /* Then set direction */ mpc52xx_simple_gpio_dir_out()
|
| /linux-4.4.14/drivers/staging/comedi/drivers/ |
| H A D | plx9052.h | 48 #define PLX9052_CNTRL_UIO0_DIR (1 << 1) /* UIO0 direction */
51 #define PLX9052_CNTRL_UIO1_DIR (1 << 4) /* UIO1 direction */
54 #define PLX9052_CNTRL_UIO2_DIR (1 << 7) /* UIO2 direction */
57 #define PLX9052_CNTRL_UIO3_DIR (1 << 10) /* UIO3 direction */
|
| /linux-4.4.14/drivers/md/ |
| H A D | md-cluster.h | 21 int (*area_resyncing)(struct mddev *mddev, int direction, sector_t lo, sector_t hi);
|
| H A D | raid10.h | 111 * if the IO is in READ direction, then this is where we read
117 * if the IO is in WRITE direction, then multiple bios are used,
|
| /linux-4.4.14/drivers/media/v4l2-core/ |
| H A D | videobuf-dma-sg.c | 155 int direction, unsigned long data, unsigned long size) videobuf_dma_init_user_locked()
160 dma->direction = direction; videobuf_dma_init_user_locked()
161 switch (dma->direction) { videobuf_dma_init_user_locked()
197 static int videobuf_dma_init_user(struct videobuf_dmabuf *dma, int direction, videobuf_dma_init_user() argument
203 ret = videobuf_dma_init_user_locked(dma, direction, data, size); videobuf_dma_init_user()
209 static int videobuf_dma_init_kernel(struct videobuf_dmabuf *dma, int direction, videobuf_dma_init_kernel() argument
216 dma->direction = direction; videobuf_dma_init_kernel()
269 static int videobuf_dma_init_overlay(struct videobuf_dmabuf *dma, int direction, videobuf_dma_init_overlay() argument
274 dma->direction = direction; videobuf_dma_init_overlay()
314 dma->nr_pages, dma->direction); videobuf_dma_map()
335 dma_unmap_sg(dev, dma->sglist, dma->sglen, dma->direction); videobuf_dma_unmap()
376 dma->direction = DMA_NONE; videobuf_dma_free()
582 mem->dma.sglen, mem->dma.direction); __videobuf_sync()
154 videobuf_dma_init_user_locked(struct videobuf_dmabuf *dma, int direction, unsigned long data, unsigned long size) videobuf_dma_init_user_locked() argument
|
| /linux-4.4.14/drivers/gpu/drm/gma500/ |
| H A D | accel_2d.c | 138 * @xdir: X direction of move
139 * @ydir: Y direction of move
183 uint32_t direction; psb_accel_2d_copy() local
187 direction = psb_accel_2d_copy()
190 if (direction == PSB_2D_COPYORDER_BR2TL || psb_accel_2d_copy()
191 direction == PSB_2D_COPYORDER_TR2BL) { psb_accel_2d_copy()
195 if (direction == PSB_2D_COPYORDER_BR2TL || psb_accel_2d_copy()
196 direction == PSB_2D_COPYORDER_BL2TR) { psb_accel_2d_copy()
206 PSB_2D_USE_PAT | PSB_2D_ROP3_SRCCOPY | direction; psb_accel_2d_copy()
|
| /linux-4.4.14/arch/mips/include/asm/ |
| H A D | dma-mapping.h | 35 enum dma_data_direction direction);
|
| /linux-4.4.14/arch/s390/include/asm/ |
| H A D | dma-mapping.h | 22 enum dma_data_direction direction) dma_cache_sync()
21 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/m68k/include/asm/ |
| H A D | dma-mapping.h | 84 enum dma_data_direction direction) dma_sync_single_range_for_device()
87 dma_sync_single_for_device(dev, dma_handle, offset + size, direction); dma_sync_single_range_for_device()
102 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
105 dma_sync_single_for_cpu(dev, dma_handle, offset + size, direction); dma_sync_single_range_for_cpu()
82 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
100 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) dma_sync_single_range_for_cpu() argument
|
| /linux-4.4.14/arch/parisc/kernel/ |
| H A D | pci-dma.c | 453 static dma_addr_t pa11_dma_map_single(struct device *dev, void *addr, size_t size, enum dma_data_direction direction) pa11_dma_map_single() argument
455 BUG_ON(direction == DMA_NONE); pa11_dma_map_single()
461 static void pa11_dma_unmap_single(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) pa11_dma_unmap_single() argument
463 BUG_ON(direction == DMA_NONE); pa11_dma_unmap_single()
465 if (direction == DMA_TO_DEVICE) pa11_dma_unmap_single()
478 static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) pa11_dma_map_sg() argument
483 BUG_ON(direction == DMA_NONE); pa11_dma_map_sg()
495 static void pa11_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) pa11_dma_unmap_sg() argument
500 BUG_ON(direction == DMA_NONE); pa11_dma_unmap_sg()
502 if (direction == DMA_TO_DEVICE) pa11_dma_unmap_sg()
512 static void pa11_dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) pa11_dma_sync_single_for_cpu() argument
514 BUG_ON(direction == DMA_NONE); pa11_dma_sync_single_for_cpu()
519 static void pa11_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) pa11_dma_sync_single_for_device() argument
521 BUG_ON(direction == DMA_NONE); pa11_dma_sync_single_for_device()
526 static void pa11_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) pa11_dma_sync_sg_for_cpu() argument
537 static void pa11_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sglist, int nents, enum dma_data_direction direction) pa11_dma_sync_sg_for_device() argument
|
| /linux-4.4.14/arch/blackfin/kernel/ |
| H A D | dma-mapping.c | 117 enum dma_data_direction direction) dma_map_sg()
124 __dma_sync(sg_dma_address(sg), sg_dma_len(sg), direction); for_each_sg() local
132 int nelems, enum dma_data_direction direction) dma_sync_sg_for_device()
139 __dma_sync(sg_dma_address(sg), sg_dma_len(sg), direction); for_each_sg() local
116 dma_map_sg(struct device *dev, struct scatterlist *sg_list, int nents, enum dma_data_direction direction) dma_map_sg() argument
131 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg_list, int nelems, enum dma_data_direction direction) dma_sync_sg_for_device() argument
|
| /linux-4.4.14/sound/usb/ |
| H A D | endpoint.h | 9 int ep_num, int direction, int type);
|
| /linux-4.4.14/drivers/staging/rtl8188eu/hal/ |
| H A D | rf.c | 57 u8 direction; rtl88eu_phy_rf6052_set_cck_txpower() local
104 rtl88eu_dm_txpower_track_adjust(&hal_data->odmpriv, 1, &direction, rtl88eu_phy_rf6052_set_cck_txpower()
107 if (direction == 1) { rtl88eu_phy_rf6052_set_cck_txpower()
111 } else if (direction == 2) { rtl88eu_phy_rf6052_set_cck_txpower()
295 u8 direction; rtl88eu_phy_rf6052_set_ofdm_txpower() local
301 rtl88eu_dm_txpower_track_adjust(&hal_data->odmpriv, 0, &direction, rtl88eu_phy_rf6052_set_ofdm_txpower()
309 if (direction == 1) { rtl88eu_phy_rf6052_set_ofdm_txpower()
312 } else if (direction == 2) { rtl88eu_phy_rf6052_set_ofdm_txpower()
|
| /linux-4.4.14/arch/unicore32/include/asm/ |
| H A D | dma-mapping.h | 54 size_t size, enum dma_data_direction direction) dma_cache_sync()
59 switch (direction) { dma_cache_sync()
53 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/mips/cavium-octeon/ |
| H A D | dma-octeon.c | 127 unsigned long offset, size_t size, enum dma_data_direction direction, octeon_dma_map_page()
131 direction, attrs); octeon_dma_map_page()
138 int nents, enum dma_data_direction direction, struct dma_attrs *attrs) octeon_dma_map_sg()
140 int r = swiotlb_map_sg_attrs(dev, sg, nents, direction, attrs); octeon_dma_map_sg()
146 dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) octeon_dma_sync_single_for_device()
148 swiotlb_sync_single_for_device(dev, dma_handle, size, direction); octeon_dma_sync_single_for_device()
153 struct scatterlist *sg, int nelems, enum dma_data_direction direction) octeon_dma_sync_sg_for_device()
155 swiotlb_sync_sg_for_device(dev, sg, nelems, direction); octeon_dma_sync_sg_for_device()
126 octeon_dma_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) octeon_dma_map_page() argument
137 octeon_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) octeon_dma_map_sg() argument
145 octeon_dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) octeon_dma_sync_single_for_device() argument
152 octeon_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction direction) octeon_dma_sync_sg_for_device() argument
|
| /linux-4.4.14/arch/h8300/kernel/ |
| H A D | dma.c | 43 enum dma_data_direction direction, map_page()
50 int nents, enum dma_data_direction direction, map_sg()
41 map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) map_page() argument
49 map_sg(struct device *dev, struct scatterlist *sgl, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) map_sg() argument
|
| /linux-4.4.14/arch/arm/mach-omap1/ |
| H A D | gpio15xx.c | 42 .direction = OMAP_MPUIO_IO_CNTL,
83 .direction = OMAP1510_GPIO_DIR_CONTROL,
|
| /linux-4.4.14/include/linux/mfd/ |
| H A D | htc-egpio.h | 20 * @direction: bitfield, '0' = input, '1' = output,
26 unsigned long direction; member in struct:htc_egpio_chip
|
| /linux-4.4.14/drivers/input/misc/ |
| H A D | twl4030-vibra.c | 50 int direction; member in struct:vibra_info
107 dir = info->direction; vibra_play_work()
117 /* set vibra rotation direction */ vibra_play_work()
144 info->direction = effect->direction < EFFECT_DIR_180_DEG ? 0 : 1; vibra_play()
|
| H A D | twl6040-vibra.c | 56 int direction; member in struct:vibra_info
136 int speed, int direction) twl6040_vibra_code()
153 /* 2's complement for direction > 180 degrees */ twl6040_vibra_code()
154 vibdat *= direction; twl6040_vibra_code()
169 info->weak_speed, info->direction); twl6040_vibra_set_effect()
175 info->strong_speed, info->direction); twl6040_vibra_set_effect()
214 info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1; vibra_play()
135 twl6040_vibra_code(int vddvib, int vibdrv_res, int motor_res, int speed, int direction) twl6040_vibra_code() argument
|
| /linux-4.4.14/drivers/media/dvb-frontends/ |
| H A D | dibx000_common.h | 246 /* mask, direction and value are used specify which GPIO to change GPIO0
248 * mask is used for the direction and the value. Direction == 1 is OUT,
249 * 0 == IN. For direction "OUT" value is either 1 or 0, for direction IN
257 u32 direction; member in struct:dibGPIOFunction
|
| /linux-4.4.14/arch/sh/drivers/dma/ |
| H A D | dma-g2.c | 25 unsigned long direction; /* Transfer direction */ member in struct:g2_channel
117 /* Fixup direction */ g2_xfer_dma()
127 g2_dma->channel[chan_nr].direction = chan->mode; g2_xfer_dma()
144 g2_dma->channel[chan_nr].direction, g2_xfer_dma()
|
| /linux-4.4.14/drivers/dma/hsu/ |
| H A D | hsu.c | 49 if (hsuc->direction == DMA_MEM_TO_DEV) hsu_chan_enable()
51 else if (hsuc->direction == DMA_DEV_TO_MEM) hsu_chan_enable()
65 if (hsuc->direction == DMA_MEM_TO_DEV) { hsu_dma_chan_start()
68 } else if (hsuc->direction == DMA_DEV_TO_MEM) { hsu_dma_chan_start()
163 if (hsuc->direction == DMA_DEV_TO_MEM && (sr & HSU_CH_SR_DESCTO_ANY)) hsu_dma_irq()
216 unsigned int sg_len, enum dma_transfer_direction direction, hsu_dma_prep_slave_sg()
234 desc->direction = direction;
311 if (!is_slave_direction(config->direction)) hsu_dma_slave_config()
403 hsuc->direction = (i & 0x1) ? DMA_DEV_TO_MEM : DMA_MEM_TO_DEV; hsu_dma_probe()
214 hsu_dma_prep_slave_sg( struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) hsu_dma_prep_slave_sg() argument
|
| H A D | hsu.h | 68 enum dma_transfer_direction direction; member in struct:hsu_dma_desc
86 enum dma_transfer_direction direction; member in struct:hsu_dma_chan
|
| /linux-4.4.14/arch/sparc/kernel/ |
| H A D | iommu.c | 265 enum dma_data_direction direction, dma_4u_map_page()
279 if (unlikely(direction == DMA_NONE)) dma_4u_map_page()
304 if (direction != DMA_TO_DEVICE) dma_4u_map_page()
322 enum dma_data_direction direction) strbuf_flush()
365 if (direction == DMA_TO_DEVICE) strbuf_flush()
387 size_t sz, enum dma_data_direction direction, dma_4u_unmap_page()
395 if (unlikely(direction == DMA_NONE)) { dma_4u_unmap_page()
420 npages, direction); dma_4u_unmap_page()
433 int nelems, enum dma_data_direction direction, dma_4u_map_sg()
446 BUG_ON(direction == DMA_NONE); dma_4u_map_sg()
463 if (direction != DMA_TO_DEVICE) dma_4u_map_sg()
609 int nelems, enum dma_data_direction direction, dma_4u_unmap_sg()
617 BUG_ON(direction == DMA_NONE); dma_4u_unmap_sg()
645 npages, direction); dma_4u_unmap_sg()
662 enum dma_data_direction direction) dma_4u_sync_single_for_cpu()
693 strbuf_flush(strbuf, iommu, bus_addr, ctx, npages, direction); dma_4u_sync_single_for_cpu()
700 enum dma_data_direction direction) dma_4u_sync_sg_for_cpu()
739 strbuf_flush(strbuf, iommu, bus_addr, ctx, npages, direction);
263 dma_4u_map_page(struct device *dev, struct page *page, unsigned long offset, size_t sz, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4u_map_page() argument
320 strbuf_flush(struct strbuf *strbuf, struct iommu *iommu, u32 vaddr, unsigned long ctx, unsigned long npages, enum dma_data_direction direction) strbuf_flush() argument
386 dma_4u_unmap_page(struct device *dev, dma_addr_t bus_addr, size_t sz, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4u_unmap_page() argument
432 dma_4u_map_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4u_map_sg() argument
608 dma_4u_unmap_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4u_unmap_sg() argument
660 dma_4u_sync_single_for_cpu(struct device *dev, dma_addr_t bus_addr, size_t sz, enum dma_data_direction direction) dma_4u_sync_single_for_cpu() argument
698 dma_4u_sync_sg_for_cpu(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction) dma_4u_sync_sg_for_cpu() argument
|
| H A D | pci_sun4v.c | 237 enum dma_data_direction direction, dma_4v_map_page()
249 if (unlikely(direction == DMA_NONE)) dma_4v_map_page()
266 if (direction != DMA_TO_DEVICE) dma_4v_map_page()
296 size_t sz, enum dma_data_direction direction, dma_4v_unmap_page()
305 if (unlikely(direction == DMA_NONE)) { dma_4v_unmap_page()
324 int nelems, enum dma_data_direction direction, dma_4v_map_sg()
337 BUG_ON(direction == DMA_NONE); dma_4v_map_sg()
344 if (direction != DMA_TO_DEVICE) dma_4v_map_sg()
468 int nelems, enum dma_data_direction direction, dma_4v_unmap_sg()
477 BUG_ON(direction == DMA_NONE); dma_4v_unmap_sg()
235 dma_4v_map_page(struct device *dev, struct page *page, unsigned long offset, size_t sz, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4v_map_page() argument
295 dma_4v_unmap_page(struct device *dev, dma_addr_t bus_addr, size_t sz, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4v_unmap_page() argument
323 dma_4v_map_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4v_map_sg() argument
467 dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist, int nelems, enum dma_data_direction direction, struct dma_attrs *attrs) dma_4v_unmap_sg() argument
|
| H A D | unaligned_32.c | 23 enum direction { enum
32 static inline enum direction decode_direction(unsigned int insn) decode_direction()
241 enum direction dir = decode_direction(insn); kernel_unaligned_trap()
277 enum direction dir) ok_for_user()
325 enum direction dir; user_unaligned_trap()
|
| /linux-4.4.14/drivers/scsi/arm/ |
| H A D | arxescsi.c | 57 * Function: int arxescsi_dma_setup(host, SCpnt, direction, min_type)
61 * direction - DMA on to/off of card
67 fasdmadir_t direction, fasdmatype_t min_type) arxescsi_dma_setup()
104 * Function: int arxescsi_dma_pseudo(host, SCpnt, direction, transfer)
108 * direction - DMA on to/off of card
113 fasdmadir_t direction, int transfer) arxescsi_dma_pseudo()
123 if (direction == DMA_OUT) { arxescsi_dma_pseudo()
66 arxescsi_dma_setup(struct Scsi_Host *host, struct scsi_pointer *SCp, fasdmadir_t direction, fasdmatype_t min_type) arxescsi_dma_setup() argument
112 arxescsi_dma_pseudo(struct Scsi_Host *host, struct scsi_pointer *SCp, fasdmadir_t direction, int transfer) arxescsi_dma_pseudo() argument
|
| H A D | acornscsi.h | 215 * DMA direction
242 * Data phase direction
244 typedef enum { /* Data direction */
334 dmadir_t direction; /* dma direction */ member in struct:acornscsi_hostdata::__anon9163
|
| H A D | cumana_2.c | 148 /* Prototype: fasdmatype_t cumanascsi_2_dma_setup(host, SCpnt, direction, min_type)
152 * direction - DMA on to/off of card
158 fasdmadir_t direction, fasdmatype_t min_type) cumanascsi_2_dma_setup()
172 if (direction == DMA_OUT) cumanascsi_2_dma_setup()
201 * Prototype: void cumanascsi_2_dma_pseudo(host, SCpnt, direction, transfer)
205 * direction - DMA on to/off of card
210 fasdmadir_t direction, int transfer) cumanascsi_2_dma_pseudo()
219 if (direction == DMA_OUT) cumanascsi_2_dma_pseudo()
157 cumanascsi_2_dma_setup(struct Scsi_Host *host, struct scsi_pointer *SCp, fasdmadir_t direction, fasdmatype_t min_type) cumanascsi_2_dma_setup() argument
209 cumanascsi_2_dma_pseudo(struct Scsi_Host *host, struct scsi_pointer *SCp, fasdmadir_t direction, int transfer) cumanascsi_2_dma_pseudo() argument
|
| /linux-4.4.14/drivers/gpu/drm/tegra/ |
| H A D | mipi-phy.c | 44 * where n = 1 for forward-direction HS mode and n = 4 for reverse- mipi_dphy_timing_get_default()
45 * direction HS mode. There's only one setting and this function does mipi_dphy_timing_get_default()
47 * assumes that reverse-direction HS mode is supported and uses n = 4. mipi_dphy_timing_get_default()
|
| /linux-4.4.14/sound/soc/ux500/ |
| H A D | ux500_msp_i2s.c | 203 if (config->direction & MSP_DIR_TX) configure_protocol()
205 if (config->direction & MSP_DIR_RX) configure_protocol()
370 if ((config->direction & MSP_DIR_RX) && enable_msp()
376 if ((config->direction == MSP_DIR_TX) && enable_msp()
384 if (config->direction & MSP_DIR_RX) enable_msp()
386 if (config->direction & MSP_DIR_TX) enable_msp()
448 tx_sel = (config->direction & MSP_DIR_TX) > 0; ux500_msp_i2s_open()
449 rx_sel = (config->direction & MSP_DIR_RX) > 0; ux500_msp_i2s_open()
451 dev_err(msp->dev, "%s: Error: No direction selected!\n", ux500_msp_i2s_open()
575 int ux500_msp_i2s_trigger(struct ux500_msp *msp, int cmd, int direction) ux500_msp_i2s_trigger() argument
589 if (direction == SNDRV_PCM_STREAM_PLAYBACK) ux500_msp_i2s_trigger()
600 if (direction == SNDRV_PCM_STREAM_PLAYBACK) ux500_msp_i2s_trigger()
|
| /linux-4.4.14/sound/pci/hda/ |
| H A D | hda_local.h | 57 #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \
58 HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction, 0)
60 #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \
61 HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction, 0)
63 #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \
64 HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction)
66 #define HDA_CODEC_VOLUME_MIN_MUTE(xname, nid, xindex, direction) \
67 HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, 3, xindex, direction, \
70 #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
76 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
78 #define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \
79 HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction)
81 #define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \
82 HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction)
84 #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \
85 HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction)
88 #define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
94 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
101 #define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \
102 HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction)
104 #define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \
105 HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction)
137 int direction, int idx, int mask, int val);
182 #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \
187 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) }
557 u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
|
| /linux-4.4.14/drivers/soc/ti/ |
| H A D | knav_dma.c | 20 #include <linux/dma-direction.h>
116 enum dma_transfer_direction direction; member in struct:knav_dma_chan
132 #define chan_number(ch) ((ch->direction == DMA_MEM_TO_DEV) ? \
151 if ((chan->direction == DMA_MEM_TO_DEV) && chan->reg_chan) { chan_start()
318 ((chan->direction == DMA_MEM_TO_DEV) ? "tx chan" : "rx flow"), dma_debug_show_channels()
321 if (chan->direction == DMA_MEM_TO_DEV) { dma_debug_show_channels()
439 config->direction == DMA_MEM_TO_DEV ? "transmit" : knav_dma_open_channel()
440 config->direction == DMA_DEV_TO_MEM ? "receive" : knav_dma_open_channel()
443 if (config->direction != DMA_MEM_TO_DEV && knav_dma_open_channel()
444 config->direction != DMA_DEV_TO_MEM) { knav_dma_open_channel()
445 dev_err(kdev->dev, "bad direction\n"); knav_dma_open_channel()
464 if (config->direction == DMA_MEM_TO_DEV) { knav_dma_open_channel()
594 chan->direction = DMA_NONE; pktdma_init_chan()
599 chan->direction = dir; pktdma_init_chan()
602 chan->direction = dir; pktdma_init_chan()
605 dev_err(dev, "channel(%d) direction unknown\n", chan_num); pktdma_init_chan()
|
| /linux-4.4.14/drivers/media/pci/mantis/ |
| H A D | mantis_core.c | 193 /* direction = 0 , no CI passthrough ; 1 , CI passthrough */ mantis_set_direction()
194 void mantis_set_direction(struct mantis_pci *mantis, int direction) mantis_set_direction() argument
199 dprintk(verbose, MANTIS_DEBUG, 1, "TS direction setup"); mantis_set_direction()
200 if (direction == 0x01) { mantis_set_direction()
|
| /linux-4.4.14/arch/xtensa/include/asm/ |
| H A D | dma-mapping.h | 36 enum dma_data_direction direction);
|
| /linux-4.4.14/include/drm/ |
| H A D | drm_rect.h | 51 * Change the size of rectangle @r by @dw in the horizontal direction,
52 * and by @dh in the vertical direction, while keeping the center
71 * Move rectangle @r by @dx in the horizontal direction,
72 * and by @dy in the vertical direction.
|
| /linux-4.4.14/arch/mips/include/asm/mach-jazz/ |
| H A D | dma-coherence.h | 33 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
32 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/frv/mm/ |
| H A D | dma-alloc.c | 151 void consistent_sync(void *vaddr, size_t size, int direction) consistent_sync() argument
156 switch (direction) { consistent_sync()
177 size_t size, int direction) consistent_sync_page()
182 consistent_sync(start, size, direction); consistent_sync_page()
176 consistent_sync_page(struct page *page, unsigned long offset, size_t size, int direction) consistent_sync_page() argument
|
| /linux-4.4.14/sound/soc/ |
| H A D | soc-compress.c | 54 snd_soc_runtime_activate(rtd, cstream->direction); soc_compr_open()
78 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_open_fe()
189 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_free()
196 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); soc_compr_free()
211 if (cstream->direction == SND_COMPRESS_PLAYBACK) { soc_compr_free()
242 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_free_fe()
298 snd_soc_dai_digital_mute(codec_dai, 0, cstream->direction); soc_compr_trigger()
301 snd_soc_dai_digital_mute(codec_dai, 1, cstream->direction); soc_compr_trigger()
325 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_trigger_fe()
391 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_set_params()
419 if (cstream->direction == SND_COMPRESS_PLAYBACK) soc_compr_set_params_fe()
632 int ret = 0, direction = 0; snd_soc_new_compress() local
657 dev_err(rtd->card->dev, "Invalid direction for compress P %d, C %d\n", snd_soc_new_compress()
663 direction = SND_COMPRESS_PLAYBACK; snd_soc_new_compress()
665 direction = SND_COMPRESS_CAPTURE; snd_soc_new_compress()
709 ret = snd_compress_new(rtd->card->snd_card, num, direction, compr); snd_soc_new_compress()
|
| /linux-4.4.14/drivers/usb/gadget/udc/ |
| H A D | mv_udc_core.c | 45 ((ep)->udc->ep0_dir) : ((ep)->direction))
133 int i, direction; process_ep_req() local
139 direction = index % 2; process_ep_req()
160 if (direction) { process_ep_req()
171 index >> 1, direction ? "SEND" : "RECV", process_ep_req()
189 if (direction == EP_DIR_OUT) process_ep_req()
262 u32 bit_pos, direction; queue_dtd() local
268 direction = ep_dir(ep); queue_dtd()
269 dqh = &(udc->ep_dqh[ep->ep_num * 2 + direction]); queue_dtd()
270 bit_pos = 1 << (((direction == EP_DIR_OUT) ? 0 : 16) + ep->ep_num); queue_dtd()
451 u32 bit_pos, epctrlx, direction; mv_ep_enable() local
465 direction = ep_dir(ep); mv_ep_enable()
474 bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num); mv_ep_enable()
482 (unsigned)ep->ep_num, direction ? "SEND" : "RECV", mv_ep_enable()
527 if (direction == EP_DIR_IN) { mv_ep_enable()
570 u32 bit_pos, epctrlx, direction; mv_ep_disable() local
584 direction = ep_dir(ep); mv_ep_disable()
585 bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num); mv_ep_disable()
592 epctrlx &= ~((direction == EP_DIR_IN) mv_ep_disable()
636 u32 bit_pos, direction; mv_ep_fifo_flush() local
648 direction = ep_dir(ep); mv_ep_fifo_flush()
652 else if (direction == EP_DIR_OUT) mv_ep_fifo_flush()
866 static void ep_set_stall(struct mv_udc *udc, u8 ep_num, u8 direction, int stall) ep_set_stall() argument
873 if (direction == EP_DIR_IN) ep_set_stall()
878 if (direction == EP_DIR_IN) { ep_set_stall()
889 static int ep_is_stall(struct mv_udc *udc, u8 ep_num, u8 direction) ep_is_stall() argument
895 if (direction == EP_DIR_OUT) ep_is_stall()
1274 ep->direction = EP_DIR_IN; eps_init()
1278 ep->direction = EP_DIR_OUT; eps_init()
1451 udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty) udc_prime_status() argument
1458 udc->ep0_dir = direction; udc_prime_status()
1553 u8 ep_num, direction; ch9getstatus() local
1556 direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK) ch9getstatus()
1558 status = ep_is_stall(udc, ep_num, direction) ch9getstatus()
1572 u8 direction; ch9clearfeature() local
1589 direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK) ch9clearfeature()
1594 ep = &udc->eps[ep_num * 2 + direction]; ch9clearfeature()
1598 ep_set_stall(udc, ep_num, direction, 0); ch9clearfeature()
1616 u8 direction; ch9setfeature() local
1644 direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK) ch9setfeature()
1650 ep_set_stall(udc, ep_num, direction, 1); ch9setfeature()
1795 int i, ep_num = 0, direction = 0; irq_process_tr_complete() local
1833 direction = i % 2; irq_process_tr_complete()
1835 bit_pos = 1 << (ep_num + 16 * direction); irq_process_tr_complete()
|
| H A D | mv_u3d_core.c | 125 int direction, ep_num; mv_u3d_process_ep_req() local
130 direction = index % 2; mv_u3d_process_ep_req()
146 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_process_ep_req()
161 direction == MV_U3D_EP_DIR_OUT)) { mv_u3d_process_ep_req()
167 index >> 1, direction ? "SEND" : "RECV", mv_u3d_process_ep_req()
233 u32 tmp, direction; mv_u3d_queue_trb() local
239 direction = mv_u3d_ep_dir(ep); mv_u3d_queue_trb()
245 ep_context = &(u3d->ep_context[ep->ep_num * 2 + direction]); mv_u3d_queue_trb()
273 + ((direction == MV_U3D_EP_DIR_OUT) ? 0 : 1); mv_u3d_queue_trb()
284 unsigned int direction; mv_u3d_build_trb_one() local
329 direction = mv_u3d_ep_dir(req->ep); mv_u3d_build_trb_one()
330 if (direction == MV_U3D_EP_DIR_IN) mv_u3d_build_trb_one()
349 unsigned int direction; mv_u3d_build_trb_chain() local
375 direction = mv_u3d_ep_dir(req->ep); mv_u3d_build_trb_chain()
376 if (direction == MV_U3D_EP_DIR_IN) mv_u3d_build_trb_chain()
533 u32 epxcr, direction; mv_u3d_ep_enable() local
544 direction = mv_u3d_ep_dir(ep); mv_u3d_ep_enable()
599 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_ep_enable()
637 u32 epxcr, direction; mv_u3d_ep_disable() local
652 direction = mv_u3d_ep_dir(ep); mv_u3d_ep_disable()
660 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_ep_disable()
702 u32 direction; mv_u3d_ep_fifo_flush() local
712 direction = mv_u3d_ep_dir(ep); mv_u3d_ep_fifo_flush()
716 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_ep_fifo_flush()
734 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_ep_fifo_flush()
750 direction ? "in" : "out"); mv_u3d_ep_fifo_flush()
772 direction ? "in" : "out"); mv_u3d_ep_fifo_flush()
931 mv_u3d_ep_set_stall(struct mv_u3d *u3d, u8 ep_num, u8 direction, int stall) mv_u3d_ep_set_stall() argument
937 if (direction == MV_U3D_EP_DIR_OUT) { mv_u3d_ep_set_stall()
1344 ep->direction = MV_U3D_EP_DIR_IN; mv_u3d_eps_init()
1348 ep->direction = MV_U3D_EP_DIR_OUT; mv_u3d_eps_init()
1626 int i, ep_num = 0, direction = 0; mv_u3d_irq_process_tr_complete() local
1640 direction = i % 2; mv_u3d_irq_process_tr_complete()
1642 bit_pos = 1 << (ep_num + 16 * direction); mv_u3d_irq_process_tr_complete()
|
| /linux-4.4.14/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/ |
| H A D | rf.c | 71 u8 direction; rtl88e_phy_rf6052_set_cck_txpower() local
119 rtl88e_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl88e_phy_rf6052_set_cck_txpower()
120 if (direction == 1) { rtl88e_phy_rf6052_set_cck_txpower()
123 } else if (direction == 2) { rtl88e_phy_rf6052_set_cck_txpower()
394 u8 direction; rtl88e_phy_rf6052_set_ofdm_txpower() local
401 rtl88e_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl88e_phy_rf6052_set_ofdm_txpower()
409 if (direction == 1) { rtl88e_phy_rf6052_set_ofdm_txpower()
412 } else if (direction == 2) { rtl88e_phy_rf6052_set_ofdm_txpower()
|
| /linux-4.4.14/drivers/net/wireless/realtek/rtlwifi/rtl8723be/ |
| H A D | rf.c | 71 u8 direction; rtl8723be_phy_rf6052_set_cck_txpower() local
118 rtl8723be_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl8723be_phy_rf6052_set_cck_txpower()
119 if (direction == 1) { rtl8723be_phy_rf6052_set_cck_txpower()
122 } else if (direction == 2) { rtl8723be_phy_rf6052_set_cck_txpower()
397 u8 direction; rtl8723be_phy_rf6052_set_ofdm_txpower() local
404 rtl8723be_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl8723be_phy_rf6052_set_ofdm_txpower()
412 if (direction == 1) { rtl8723be_phy_rf6052_set_ofdm_txpower()
415 } else if (direction == 2) { rtl8723be_phy_rf6052_set_ofdm_txpower()
|
| /linux-4.4.14/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/ |
| H A D | rf.c | 70 u8 direction; rtl8821ae_phy_rf6052_set_cck_txpower() local
120 rtl8821ae_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl8821ae_phy_rf6052_set_cck_txpower()
121 if (direction == 1) { rtl8821ae_phy_rf6052_set_cck_txpower()
124 } else if (direction == 2) { rtl8821ae_phy_rf6052_set_cck_txpower()
377 u8 direction; rtl8821ae_phy_rf6052_set_ofdm_txpower() local
387 rtl8821ae_dm_txpower_track_adjust(hw, 1, &direction, &pwrtrac_value); rtl8821ae_phy_rf6052_set_ofdm_txpower()
394 if (direction == 1) { rtl8821ae_phy_rf6052_set_ofdm_txpower()
397 } else if (direction == 2) { rtl8821ae_phy_rf6052_set_ofdm_txpower()
|
| /linux-4.4.14/drivers/infiniband/core/ |
| H A D | smi.c | 48 u8 direction, __smi_handle_dr_smp_send()
57 if (!direction) { __smi_handle_dr_smp_send()
160 u8 direction, __smi_handle_dr_smp_recv()
169 if (!direction) { __smi_handle_dr_smp_recv()
271 u8 direction, __smi_check_forward_dr_smp()
275 if (!direction) { __smi_check_forward_dr_smp()
44 __smi_handle_dr_smp_send(bool is_switch, int port_num, u8 *hop_ptr, u8 hop_cnt, const u8 *initial_path, const u8 *return_path, u8 direction, bool dr_dlid_is_permissive, bool dr_slid_is_permissive) __smi_handle_dr_smp_send() argument
155 __smi_handle_dr_smp_recv(bool is_switch, int port_num, int phys_port_cnt, u8 *hop_ptr, u8 hop_cnt, const u8 *initial_path, u8 *return_path, u8 direction, bool dr_dlid_is_permissive, bool dr_slid_is_permissive) __smi_handle_dr_smp_recv() argument
270 __smi_check_forward_dr_smp(u8 hop_ptr, u8 hop_cnt, u8 direction, bool dr_dlid_is_permissive, bool dr_slid_is_permissive) __smi_check_forward_dr_smp() argument
|
| /linux-4.4.14/drivers/gpu/drm/nouveau/nvkm/subdev/therm/ |
| H A D | g84.c | 101 enum nvkm_therm_thrs_direction direction; g84_therm_threshold_hyst_emulation() local
126 /* find the direction */ g84_therm_threshold_hyst_emulation()
128 direction = NVKM_THERM_THRS_RISING; g84_therm_threshold_hyst_emulation()
130 direction = NVKM_THERM_THRS_FALLING; g84_therm_threshold_hyst_emulation()
134 /* advertise a change in direction */ g84_therm_threshold_hyst_emulation()
135 nvkm_therm_sensor_event(therm, thrs_name, direction); g84_therm_threshold_hyst_emulation()
|
| H A D | temp.c | 141 enum nvkm_therm_thrs_direction direction; nvkm_therm_threshold_hyst_polling() local
148 direction = NVKM_THERM_THRS_RISING; nvkm_therm_threshold_hyst_polling()
152 direction = NVKM_THERM_THRS_FALLING; nvkm_therm_threshold_hyst_polling()
158 nvkm_therm_sensor_event(therm, thrs_name, direction); nvkm_therm_threshold_hyst_polling()
|
| /linux-4.4.14/drivers/dma/ |
| H A D | dma-axi-dmac.c | 100 enum dma_transfer_direction direction; member in struct:axi_dmac_chan
340 unsigned int sg_len, enum dma_transfer_direction direction, axi_dmac_prep_slave_sg()
348 if (direction != chan->direction) axi_dmac_prep_slave_sg()
362 if (direction == DMA_DEV_TO_MEM) for_each_sg()
377 size_t period_len, enum dma_transfer_direction direction, axi_dmac_prep_dma_cyclic()
384 if (direction != chan->direction) axi_dmac_prep_dma_cyclic()
401 if (direction == DMA_DEV_TO_MEM) axi_dmac_prep_dma_cyclic()
426 if (xt->dir != chan->direction) axi_dmac_prep_interleaved()
548 chan->direction = DMA_MEM_TO_MEM; axi_dmac_parse_chan_dt()
550 chan->direction = DMA_MEM_TO_DEV; axi_dmac_parse_chan_dt()
552 chan->direction = DMA_DEV_TO_MEM; axi_dmac_parse_chan_dt()
554 chan->direction = DMA_DEV_TO_DEV; axi_dmac_parse_chan_dt()
620 dma_dev->directions = BIT(dmac->chan.direction);
338 axi_dmac_prep_slave_sg( struct dma_chan *c, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) axi_dmac_prep_slave_sg() argument
375 axi_dmac_prep_dma_cyclic( struct dma_chan *c, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) axi_dmac_prep_dma_cyclic() argument
|
| H A D | dma-jz4740.c | 108 enum dma_transfer_direction direction; member in struct:jz4740_dma_desc
219 switch (config->direction) { jz4740_dma_slave_config()
312 if (chan->desc->direction == DMA_MEM_TO_DEV) { jz4740_dma_start_transfer()
391 unsigned int sg_len, enum dma_transfer_direction direction, jz4740_dma_prep_slave_sg()
409 desc->direction = direction;
417 size_t period_len, enum dma_transfer_direction direction, jz4740_dma_prep_dma_cyclic()
440 desc->direction = direction; jz4740_dma_prep_dma_cyclic()
389 jz4740_dma_prep_slave_sg( struct dma_chan *c, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) jz4740_dma_prep_slave_sg() argument
415 jz4740_dma_prep_dma_cyclic( struct dma_chan *c, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) jz4740_dma_prep_dma_cyclic() argument
|
| H A D | bcm2835-dma.c | 353 size_t period_len, enum dma_transfer_direction direction, bcm2835_dma_prep_dma_cyclic()
365 if (!is_slave_direction(direction)) { bcm2835_dma_prep_dma_cyclic()
366 dev_err(chan->device->dev, "%s: bad direction?\n", __func__); bcm2835_dma_prep_dma_cyclic()
370 if (direction == DMA_DEV_TO_MEM) { bcm2835_dma_prep_dma_cyclic()
395 d->dir = direction; bcm2835_dma_prep_dma_cyclic()
474 if ((cfg->direction == DMA_DEV_TO_MEM && bcm2835_dma_slave_config()
476 (cfg->direction == DMA_MEM_TO_DEV && bcm2835_dma_slave_config()
478 !is_slave_direction(cfg->direction)) { bcm2835_dma_slave_config()
351 bcm2835_dma_prep_dma_cyclic( struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) bcm2835_dma_prep_dma_cyclic() argument
|
| H A D | at_xdmac.c | 248 enum dma_transfer_direction direction; member in struct:at_xdmac_desc
463 desc->direction = DMA_TRANS_NONE; at_xdmac_init_used_desc()
542 enum dma_transfer_direction direction) at_xdmac_compute_chan_conf()
547 if (direction == DMA_DEV_TO_MEM) { at_xdmac_compute_chan_conf()
570 } else if (direction == DMA_MEM_TO_DEV) { at_xdmac_compute_chan_conf()
603 * transfer since we don't know the direction at this stage.
635 unsigned int sg_len, enum dma_transfer_direction direction, at_xdmac_prep_slave_sg()
649 if (!is_slave_direction(direction)) { at_xdmac_prep_slave_sg()
650 dev_err(chan2dev(chan), "invalid DMA direction\n"); at_xdmac_prep_slave_sg()
656 direction == DMA_MEM_TO_DEV ? "to device" : "from device", at_xdmac_prep_slave_sg()
662 if (at_xdmac_compute_chan_conf(chan, direction)) at_xdmac_prep_slave_sg()
688 if (direction == DMA_DEV_TO_MEM) { for_each_sg()
726 first->direction = direction;
737 enum dma_transfer_direction direction, at_xdmac_prep_dma_cyclic()
748 direction == DMA_MEM_TO_DEV ? "mem2per" : "per2mem", flags); at_xdmac_prep_dma_cyclic()
750 if (!is_slave_direction(direction)) { at_xdmac_prep_dma_cyclic()
751 dev_err(chan2dev(chan), "invalid DMA direction\n"); at_xdmac_prep_dma_cyclic()
760 if (at_xdmac_compute_chan_conf(chan, direction)) at_xdmac_prep_dma_cyclic()
780 if (direction == DMA_DEV_TO_MEM) { at_xdmac_prep_dma_cyclic()
813 first->direction = direction; at_xdmac_prep_dma_cyclic()
862 * direction, it involves we can't dynamically set the source and dest at_xdmac_interleaved_queue_desc()
866 * that solves the fact we don't know the direction. at_xdmac_interleaved_queue_desc()
1039 * WARNING: We don't know the direction, it involves we can't at_xdmac_prep_dma_memcpy()
1044 * don't know the direction. at_xdmac_prep_dma_memcpy()
1142 * direction, it involves we can't dynamically set the source and dest at_xdmac_memset_create_desc()
1146 * that solves the fact we don't know the direction. at_xdmac_memset_create_desc()
541 at_xdmac_compute_chan_conf(struct dma_chan *chan, enum dma_transfer_direction direction) at_xdmac_compute_chan_conf() argument
634 at_xdmac_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) at_xdmac_prep_slave_sg() argument
735 at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) at_xdmac_prep_dma_cyclic() argument
|
| H A D | idma64.c | 244 enum dma_transfer_direction direction, u64 llp) idma64_hw_desc_fill()
252 if (direction == DMA_MEM_TO_DEV) { idma64_hw_desc_fill()
294 llp = idma64_hw_desc_fill(hw, config, desc->direction, llp); idma64_desc_fill()
304 unsigned int sg_len, enum dma_transfer_direction direction, idma64_prep_slave_sg()
332 desc->direction = direction;
417 if (!is_slave_direction(config->direction)) idma64_slave_config()
242 idma64_hw_desc_fill(struct idma64_hw_desc *hw, struct dma_slave_config *config, enum dma_transfer_direction direction, u64 llp) idma64_hw_desc_fill() argument
302 idma64_prep_slave_sg( struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) idma64_prep_slave_sg() argument
|
| H A D | edma.c | 167 enum dma_transfer_direction direction; member in struct:edma_desc
911 * @direction: Direction of the transfer
916 enum dma_transfer_direction direction) edma_config_pset()
980 if (direction == DMA_MEM_TO_DEV) { edma_config_pset()
986 } else if (direction == DMA_DEV_TO_MEM) { edma_config_pset()
992 } else if (direction == DMA_MEM_TO_MEM) { edma_config_pset()
998 dev_err(dev, "%s: direction not implemented yet\n", __func__); edma_config_pset()
1027 unsigned int sg_len, enum dma_transfer_direction direction, edma_prep_slave_sg()
1042 if (direction == DMA_DEV_TO_MEM) { edma_prep_slave_sg()
1046 } else if (direction == DMA_MEM_TO_DEV) { edma_prep_slave_sg()
1051 dev_err(dev, "%s: bad direction: %d\n", __func__, direction); edma_prep_slave_sg()
1069 edesc->direction = direction; edma_prep_slave_sg()
1091 if (direction == DMA_DEV_TO_MEM) for_each_sg()
1098 sg_dma_len(sg), direction); for_each_sg()
1173 edesc->direction = DMA_MEM_TO_MEM; edma_prep_dma_memcpy()
1223 size_t period_len, enum dma_transfer_direction direction, edma_prep_dma_cyclic()
1237 if (direction == DMA_DEV_TO_MEM) { edma_prep_dma_cyclic()
1242 } else if (direction == DMA_MEM_TO_DEV) { edma_prep_dma_cyclic()
1248 dev_err(dev, "%s: bad direction: %d\n", __func__, direction); edma_prep_dma_cyclic()
1285 edesc->direction = direction; edma_prep_dma_cyclic()
1312 direction); edma_prep_dma_cyclic()
1318 if (direction == DMA_DEV_TO_MEM) edma_prep_dma_cyclic()
1685 bool dst = edesc->direction == DMA_DEV_TO_MEM; edma_residue()
913 edma_config_pset(struct dma_chan *chan, struct edma_pset *epset, dma_addr_t src_addr, dma_addr_t dst_addr, u32 burst, unsigned int acnt, unsigned int dma_length, enum dma_transfer_direction direction) edma_config_pset() argument
1025 edma_prep_slave_sg( struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long tx_flags, void *context) edma_prep_slave_sg() argument
1221 edma_prep_dma_cyclic( struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long tx_flags) edma_prep_dma_cyclic() argument
|
| H A D | imx-dma.c | 133 enum dma_transfer_direction direction; member in struct:imxdma_desc
293 if (d->direction == DMA_DEV_TO_MEM) imxdma_sg_next()
580 if (d->direction == DMA_DEV_TO_MEM) { imxdma_xfer_desc()
591 } else if (d->direction == DMA_MEM_TO_DEV) { imxdma_xfer_desc()
689 if (dmaengine_cfg->direction == DMA_DEV_TO_MEM) { imxdma_config()
810 unsigned int sg_len, enum dma_transfer_direction direction, imxdma_prep_slave_sg()
847 desc->direction = direction;
848 if (direction == DMA_DEV_TO_MEM) {
861 size_t period_len, enum dma_transfer_direction direction, imxdma_prep_dma_cyclic()
906 desc->direction = direction; imxdma_prep_dma_cyclic()
907 if (direction == DMA_DEV_TO_MEM) { imxdma_prep_dma_cyclic()
940 desc->direction = DMA_MEM_TO_MEM; imxdma_prep_dma_memcpy()
980 desc->direction = DMA_MEM_TO_MEM; imxdma_prep_dma_interleaved()
808 imxdma_prep_slave_sg( struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) imxdma_prep_slave_sg() argument
859 imxdma_prep_dma_cyclic( struct dma_chan *chan, dma_addr_t dma_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) imxdma_prep_dma_cyclic() argument
|
| H A D | coh901318.h | 109 * @dir: direction of transfer (to or from device)
129 * @dir: direction of transfer (to or from device)
|
| H A D | idma64.h | 117 enum dma_transfer_direction direction; member in struct:idma64_desc
135 enum dma_transfer_direction direction; member in struct:idma64_chan
|
| H A D | timb_dma.c | 90 enum dma_transfer_direction direction; member in struct:timb_dma_chan
203 if (td_chan->direction == DMA_DEV_TO_MEM) { __td_start_dma()
246 if (td_chan->direction == DMA_DEV_TO_MEM) __td_finish()
506 enum dma_transfer_direction direction, unsigned long flags, td_prep_slave_sg()
522 if (td_chan->direction != direction) { td_prep_slave_sg()
524 "Requesting channel in wrong direction\n"); td_prep_slave_sg()
720 td_chan->direction = pchan->rx ? DMA_DEV_TO_MEM : td_probe()
504 td_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) td_prep_slave_sg() argument
|
| /linux-4.4.14/drivers/dma/sh/ |
| H A D | shdma-base.c | 266 * .direction, and either .src_addr or .dst_addr set.
493 * @dst: destination DMA address, incremented when direction equals
495 * @src: source DMA address, incremented when direction equals
499 * @direction: needed for slave DMA to decide which address to keep constant,
506 struct shdma_desc **first, enum dma_transfer_direction direction) shdma_add_desc()
541 new->direction = direction; shdma_add_desc()
545 if (direction == DMA_MEM_TO_MEM || direction == DMA_MEM_TO_DEV) shdma_add_desc()
547 if (direction == DMA_MEM_TO_MEM || direction == DMA_DEV_TO_MEM) shdma_add_desc()
558 * list manipulation. For slave DMA direction carries the usual meaning, and,
560 * e.g., the FIFO I/O register. For MEMCPY direction equals DMA_MEM_TO_MEM
565 enum dma_transfer_direction direction, unsigned long flags, bool cyclic) shdma_prep_sg()
602 if (direction == DMA_DEV_TO_MEM) for_each_sg()
605 direction); for_each_sg()
609 direction); for_each_sg()
666 enum dma_transfer_direction direction, unsigned long flags, void *context) shdma_prep_slave_sg()
689 direction, flags, false); shdma_prep_slave_sg()
696 size_t period_len, enum dma_transfer_direction direction, shdma_prep_dma_cyclic()
750 direction, flags, true); shdma_prep_dma_cyclic()
787 * encouraged to also set a transfer direction and an address. shdma_config()
805 config->direction == DMA_DEV_TO_MEM ? shdma_config()
504 shdma_add_desc(struct shdma_chan *schan, unsigned long flags, dma_addr_t *dst, dma_addr_t *src, size_t *len, struct shdma_desc **first, enum dma_transfer_direction direction) shdma_add_desc() argument
563 shdma_prep_sg(struct shdma_chan *schan, struct scatterlist *sgl, unsigned int sg_len, dma_addr_t *addr, enum dma_transfer_direction direction, unsigned long flags, bool cyclic) shdma_prep_sg() argument
664 shdma_prep_slave_sg( struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) shdma_prep_slave_sg() argument
694 shdma_prep_dma_cyclic( struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction, unsigned long flags) shdma_prep_dma_cyclic() argument
|
| /linux-4.4.14/drivers/staging/most/hdm-i2c/ |
| H A D | hdm_i2c.c | 90 if (channel_config->direction != dev->capabilities[ch_idx].direction) { configure_channel()
91 pr_err("bad direction for channel %d\n", ch_idx); configure_channel()
95 if ((channel_config->direction == MOST_CH_RX) && (dev->polling_mode)) { configure_channel()
154 * If channel direction is RX, complete the buffers in list with
334 dev->capabilities[CH_RX].direction = MOST_CH_RX; i2c_probe()
336 dev->capabilities[CH_TX].direction = MOST_CH_TX; i2c_probe()
|
| /linux-4.4.14/drivers/video/fbdev/aty/ |
| H A D | mach64_accel.c | 27 static u32 rotation24bpp(u32 dx, u32 direction) rotation24bpp() argument
30 if (direction & DST_X_LEFT_TO_RIGHT) { rotation24bpp()
199 u32 dy = area->dy, sy = area->sy, direction = DST_LAST_PEL; atyfb_copyarea() local
223 direction |= DST_Y_TOP_TO_BOTTOM; atyfb_copyarea()
229 direction |= DST_X_LEFT_TO_RIGHT; atyfb_copyarea()
232 rotation = rotation24bpp(dx, direction); atyfb_copyarea()
239 aty_st_le32(DST_CNTL, direction | rotation, par); atyfb_copyarea()
|
| /linux-4.4.14/drivers/firewire/ |
| H A D | core-iso.c | 68 enum dma_data_direction direction) fw_iso_buffer_map_dma()
73 buffer->direction = direction; fw_iso_buffer_map_dma()
77 0, PAGE_SIZE, direction); fw_iso_buffer_map_dma()
91 int page_count, enum dma_data_direction direction) fw_iso_buffer_init()
99 ret = fw_iso_buffer_map_dma(buffer, card, direction); fw_iso_buffer_init()
134 PAGE_SIZE, buffer->direction); fw_iso_buffer_destroy()
67 fw_iso_buffer_map_dma(struct fw_iso_buffer *buffer, struct fw_card *card, enum dma_data_direction direction) fw_iso_buffer_map_dma() argument
90 fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card, int page_count, enum dma_data_direction direction) fw_iso_buffer_init() argument
|
| /linux-4.4.14/arch/powerpc/mm/ |
| H A D | dma-noncoherent.c | 317 void __dma_sync(void *vaddr, size_t size, int direction) __dma_sync() argument
322 switch (direction) { __dma_sync()
356 unsigned long offset, size_t size, int direction) __dma_sync_page_highmem()
370 __dma_sync((void *)start, seg_size, direction); __dma_sync_page_highmem()
391 size_t size, int direction) __dma_sync_page()
394 __dma_sync_page_highmem(page, offset, size, direction); __dma_sync_page()
397 __dma_sync((void *)start, size, direction); __dma_sync_page()
355 __dma_sync_page_highmem(struct page *page, unsigned long offset, size_t size, int direction) __dma_sync_page_highmem() argument
390 __dma_sync_page(struct page *page, unsigned long offset, size_t size, int direction) __dma_sync_page() argument
|
| /linux-4.4.14/drivers/staging/most/mostcore/ |
| H A D | mostcore.h | 46 * Channel direction.
75 * @direction: Supported channel directions.
110 u16 direction; member in struct:most_channel_capability
121 * @direction: direction of the channel
138 enum most_channel_direction direction; member in struct:most_channel_config
169 * channel direction, set "processed_length" and "status" and completes
183 * de-registers an interface or gets unloaded from the kernel. If this direction
221 * configurable. Parameter channel_config describes direction and data
|
| /linux-4.4.14/drivers/media/pci/ivtv/ |
| H A D | ivtv-cards.c | 224 .gpio_init = { .direction = 0x1f01, .initial_value = 0x26f3 },
255 .gpio_init = { .direction = 0xe380, .initial_value = 0x8290 },
298 .gpio_init = { .direction = 0x3080, .initial_value = 0x0004 },
340 .gpio_init = { .direction = 0x7080, .initial_value = 0x400c },
491 .gpio_init = { .direction = 0xe080, .initial_value = 0x8000 },
568 .gpio_init = { .direction = 0xf880, .initial_value = 0x8800 },
600 .gpio_init = { .direction = 0xf880, .initial_value = 0x8800 },
630 .gpio_init = { .direction = 0xf880, .initial_value = 0x8800 },
672 .gpio_init = { .direction = 0xc301, .initial_value = 0x0200 },
709 .gpio_init = { .direction = 0xc301, .initial_value = 0x0200 },
745 .gpio_init = { .direction = 0xf000, .initial_value = 0xA000 },
783 .gpio_init = { .direction = 0x0800, .initial_value = 0 },
820 .gpio_init = { .direction = 0x00ff, .initial_value = 0x0002 },
857 .gpio_init = { .direction = 0xe080, .initial_value = 0x8000 },
975 .gpio_init = { .direction = 0xe000, .initial_value = 0x4000 },
1015 .gpio_init = { .direction = 0xc000, .initial_value = 0 },
1061 .gpio_init = { .direction = 0xc000, .initial_value = 0 },
1099 .gpio_init = { .direction = 0x4000, .initial_value = 0x4000 },
1170 .gpio_init = { .direction = 0xe000, .initial_value = 0x4000 },
1240 .gpio_init = { .direction = 0x03e1, .initial_value = 0x0320 },
|
| /linux-4.4.14/arch/blackfin/include/asm/ |
| H A D | dma.h | 226 set_bfin_dma_config2(char direction, char flow_mode, char intr_mode, set_bfin_dma_config2() argument
246 return config | (direction << 1) | (mem_width << 8) | (dma_mode << 26) | set_bfin_dma_config2()
252 set_bfin_dma_config(char direction, char flow_mode, set_bfin_dma_config() argument
256 return set_bfin_dma_config2(direction, flow_mode, intr_mode, dma_mode, set_bfin_dma_config()
259 return (direction << 1) | (mem_width << 2) | (dma_mode << 4) | set_bfin_dma_config()
|
| /linux-4.4.14/arch/powerpc/platforms/cell/ |
| H A D | iommu.c | 53 * IO PTEs based on the transfer direction. That can be enabled
54 * once spider-net has been fixed to pass the correct direction
168 unsigned long uaddr, enum dma_data_direction direction, tce_build_cell()
182 * together for each of the 3 supported direction values. It is then tce_build_cell()
183 * shifted left so that the fields matching the desired direction tce_build_cell()
188 ((prot << (52 + 4 * direction)) & tce_build_cell()
209 index, npages, direction, base_pte); tce_build_cell()
600 enum dma_data_direction direction, dma_fixed_map_page()
605 direction, attrs); dma_fixed_map_page()
609 direction, attrs); dma_fixed_map_page()
613 size_t size, enum dma_data_direction direction, dma_fixed_unmap_page()
617 dma_direct_ops.unmap_page(dev, dma_addr, size, direction, dma_fixed_unmap_page()
621 direction, attrs); dma_fixed_unmap_page() local
625 int nents, enum dma_data_direction direction, dma_fixed_map_sg()
629 return dma_direct_ops.map_sg(dev, sg, nents, direction, attrs); dma_fixed_map_sg()
633 direction, attrs); dma_fixed_map_sg()
637 int nents, enum dma_data_direction direction, dma_fixed_unmap_sg()
641 dma_direct_ops.unmap_sg(dev, sg, nents, direction, attrs); dma_fixed_unmap_sg()
644 direction, attrs); dma_fixed_unmap_sg() local
167 tce_build_cell(struct iommu_table *tbl, long index, long npages, unsigned long uaddr, enum dma_data_direction direction, struct dma_attrs *attrs) tce_build_cell() argument
598 dma_fixed_map_page(struct device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_fixed_map_page() argument
612 dma_fixed_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) dma_fixed_unmap_page() argument
624 dma_fixed_map_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) dma_fixed_map_sg() argument
636 dma_fixed_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) dma_fixed_unmap_sg() argument
|
| /linux-4.4.14/drivers/net/wireless/brcm80211/brcmsmac/ |
| H A D | dma.h | 24 /* map/unmap direction */
25 #define DMA_TX 1 /* TX direction for DMA */
26 #define DMA_RX 2 /* RX direction for DMA */
|
| /linux-4.4.14/sound/firewire/tascam/ |
| H A D | amdtp-tascam.c | 34 if (s->direction == AMDTP_IN_STREAM) amdtp_tscm_set_parameters()
161 if (s->direction == AMDTP_OUT_STREAM) { amdtp_tscm_set_pcm_format()
168 if (s->direction == AMDTP_OUT_STREAM) amdtp_tscm_set_pcm_format()
|
| /linux-4.4.14/net/sunrpc/xprtrdma/ |
| H A D | backchannel.c | 4 * Support for backward direction RPCs on RPC/RDMA.
127 * direction request before the rpc_rqst is returned to the xprt_rdma_bc_setup()
198 * rpcrdma_bc_marshal_reply - Send backwards direction reply
283 * rpcrdma_bc_receive_call - Handle a backward direction call
355 * direction reply. rpcrdma_bc_receive_call()
387 pr_warn("RPC/RDMA short backward direction call\n"); rpcrdma_bc_receive_call()
|
| H A D | fmr_ops.c | 125 enum dma_data_direction direction = rpcrdma_data_dir(writing); fmr_op_map() local
150 rpcrdma_map_one(device, seg, direction); fmr_op_map()
|
| /linux-4.4.14/sound/core/ |
| H A D | pcm_dmaengine.c | 83 slave_config->direction = DMA_MEM_TO_DEV; snd_hwparams_to_dma_slave_config()
86 slave_config->direction = DMA_DEV_TO_MEM; snd_hwparams_to_dma_slave_config()
106 * direction of the substream. If the substream is a playback stream the dst
150 enum dma_transfer_direction direction; dmaengine_pcm_prepare_and_submit() local
153 direction = snd_pcm_substream_to_dma_direction(substream); dmaengine_pcm_prepare_and_submit()
162 snd_pcm_lib_period_bytes(substream), direction, flags); dmaengine_pcm_prepare_and_submit()
|
| H A D | compress_offload.c | 110 if (dirn != compr->direction) { snd_compr_open()
111 pr_err("this device doesn't support this direction\n"); snd_compr_open()
122 data->stream.direction = dirn; snd_compr_open()
176 if (stream->direction == SND_COMPRESS_PLAYBACK) snd_compr_update_tstamp()
192 stream->direction == SND_COMPRESS_PLAYBACK) { snd_compr_calc_avail()
201 if (stream->direction == SND_COMPRESS_PLAYBACK) { snd_compr_calc_avail()
212 if (stream->direction == SND_COMPRESS_PLAYBACK) snd_compr_calc_avail()
374 if (stream->direction == SND_COMPRESS_PLAYBACK) snd_compr_get_poll()
418 if (stream->direction == SND_COMPRESS_PLAYBACK) snd_compr_poll()
552 if (stream->direction == SND_COMPRESS_PLAYBACK) snd_compr_set_params()
882 pr_debug("reg %s for device %s, direction %d\n", str, compr->name, snd_compress_dev_register()
883 compr->direction); snd_compress_dev_register()
918 * @dirn: device direction, should be of type enum snd_compr_direction
932 compr->direction = dirn; snd_compress_new()
|
| /linux-4.4.14/drivers/tty/serial/ |
| H A D | serial_mctrl_gpio.h | 65 * Request and set direction of modem control lines GPIOs and sets up irq
74 * Request and set direction of modem control lines GPIOs.
|
| /linux-4.4.14/drivers/scsi/ |
| H A D | mvme147.c | 37 /* setup dma direction */ dma_setup()
41 /* remember direction */ dma_setup()
|
| H A D | gdth_ioctl.h | 87 u32 direction; /* data direction */ member in struct:__anon9444::__anon9445::__anon9452
106 u32 direction; /* data direction */ member in struct:__anon9444::__anon9445::__anon9453
|
| /linux-4.4.14/drivers/media/pci/cx18/ |
| H A D | cx18-cards.c | 98 .gpio_init.direction = 0x3001,
145 .gpio_init.direction = 0x3801,
192 .gpio_init.direction = 0x3001,
298 .gpio_init.direction = 0x3,
358 .gpio_init.direction = 0x3,
414 .gpio_init.direction = 0xf002,
511 .gpio_init.direction = 0x7,
564 .gpio_init.direction = 0x7,
|
| /linux-4.4.14/drivers/net/phy/ |
| H A D | dp83640_reg.h | 115 #define E7_RISE (1<<15) /* Indicates direction of Event 7 */
117 #define E6_RISE (1<<13) /* Indicates direction of Event 6 */
119 #define E5_RISE (1<<11) /* Indicates direction of Event 5 */
121 #define E4_RISE (1<<9) /* Indicates direction of Event 4 */
123 #define E3_RISE (1<<7) /* Indicates direction of Event 3 */
125 #define E2_RISE (1<<5) /* Indicates direction of Event 2 */
127 #define E1_RISE (1<<3) /* Indicates direction of Event 1 */
129 #define E0_RISE (1<<1) /* Indicates direction of Event 0 */
|
| /linux-4.4.14/arch/c6x/include/asm/ |
| H A D | dma-mapping.h | 54 int nents, enum dma_data_direction direction);
57 int nents, enum dma_data_direction direction);
|
| /linux-4.4.14/arch/sh/mm/ |
| H A D | consistent.c | 82 enum dma_data_direction direction) dma_cache_sync()
89 switch (direction) { dma_cache_sync()
81 dma_cache_sync(struct device *dev, void *vaddr, size_t size, enum dma_data_direction direction) dma_cache_sync() argument
|
| /linux-4.4.14/arch/ia64/sn/pci/ |
| H A D | pci_dma.c | 157 * @direction: DMA direction
212 * @direction: DMA direction
236 * @direction: DMA direction
264 * @direction: direction of the DMA transaction
|
| /linux-4.4.14/arch/avr32/mm/ |
| H A D | dma-coherent.c | 16 void dma_cache_sync(struct device *dev, void *vaddr, size_t size, int direction) dma_cache_sync() argument
24 switch (direction) { dma_cache_sync()
|
| /linux-4.4.14/sound/usb/line6/ |
| H A D | pcm.c | 143 get_stream(struct snd_line6_pcm *line6pcm, int direction) get_stream() argument
145 return (direction == SNDRV_PCM_STREAM_PLAYBACK) ? get_stream()
181 static int line6_stream_start(struct snd_line6_pcm *line6pcm, int direction, line6_stream_start() argument
185 struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); line6_stream_start()
193 if (direction == SNDRV_PCM_STREAM_PLAYBACK) line6_stream_start()
205 static void line6_stream_stop(struct snd_line6_pcm *line6pcm, int direction, line6_stream_stop() argument
209 struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); line6_stream_stop()
215 if (direction == SNDRV_PCM_STREAM_CAPTURE) { line6_stream_stop()
|
| /linux-4.4.14/include/rdma/ |
| H A D | ib_verbs.h | 1536 enum dma_data_direction direction);
1539 enum dma_data_direction direction);
1543 enum dma_data_direction direction);
1546 enum dma_data_direction direction);
1549 enum dma_data_direction direction);
1552 enum dma_data_direction direction);
2606 * @direction: The direction of the DMA
2610 enum dma_data_direction direction) ib_dma_map_single()
2613 return dev->dma_ops->map_single(dev, cpu_addr, size, direction); ib_dma_map_single()
2614 return dma_map_single(dev->dma_device, cpu_addr, size, direction); ib_dma_map_single()
2622 * @direction: The direction of the DMA
2626 enum dma_data_direction direction) ib_dma_unmap_single()
2629 dev->dma_ops->unmap_single(dev, addr, size, direction); ib_dma_unmap_single()
2631 dma_unmap_single(dev->dma_device, addr, size, direction); ib_dma_unmap_single()
2636 enum dma_data_direction direction, ib_dma_map_single_attrs()
2640 direction, attrs); ib_dma_map_single_attrs()
2645 enum dma_data_direction direction, ib_dma_unmap_single_attrs()
2649 direction, attrs); ib_dma_unmap_single_attrs()
2658 * @direction: The direction of the DMA
2664 enum dma_data_direction direction) ib_dma_map_page()
2667 return dev->dma_ops->map_page(dev, page, offset, size, direction); ib_dma_map_page()
2668 return dma_map_page(dev->dma_device, page, offset, size, direction); ib_dma_map_page()
2676 * @direction: The direction of the DMA
2680 enum dma_data_direction direction) ib_dma_unmap_page()
2683 dev->dma_ops->unmap_page(dev, addr, size, direction); ib_dma_unmap_page()
2685 dma_unmap_page(dev->dma_device, addr, size, direction); ib_dma_unmap_page()
2693 * @direction: The direction of the DMA
2697 enum dma_data_direction direction) ib_dma_map_sg()
2700 return dev->dma_ops->map_sg(dev, sg, nents, direction); ib_dma_map_sg()
2701 return dma_map_sg(dev->dma_device, sg, nents, direction); ib_dma_map_sg()
2709 * @direction: The direction of the DMA
2713 enum dma_data_direction direction) ib_dma_unmap_sg()
2716 dev->dma_ops->unmap_sg(dev, sg, nents, direction); ib_dma_unmap_sg()
2718 dma_unmap_sg(dev->dma_device, sg, nents, direction); ib_dma_unmap_sg()
2723 enum dma_data_direction direction, ib_dma_map_sg_attrs()
2726 return dma_map_sg_attrs(dev->dma_device, sg, nents, direction, attrs); ib_dma_map_sg_attrs()
2731 enum dma_data_direction direction, ib_dma_unmap_sg_attrs()
2734 dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, attrs); ib_dma_unmap_sg_attrs()
2769 * @dir: The direction of the DMA
2787 * @dir: The direction of the DMA
2608 ib_dma_map_single(struct ib_device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction) ib_dma_map_single() argument
2624 ib_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) ib_dma_unmap_single() argument
2634 ib_dma_map_single_attrs(struct ib_device *dev, void *cpu_addr, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) ib_dma_map_single_attrs() argument
2643 ib_dma_unmap_single_attrs(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction, struct dma_attrs *attrs) ib_dma_unmap_single_attrs() argument
2660 ib_dma_map_page(struct ib_device *dev, struct page *page, unsigned long offset, size_t size, enum dma_data_direction direction) ib_dma_map_page() argument
2678 ib_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, enum dma_data_direction direction) ib_dma_unmap_page() argument
2695 ib_dma_map_sg(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) ib_dma_map_sg() argument
2711 ib_dma_unmap_sg(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction) ib_dma_unmap_sg() argument
2721 ib_dma_map_sg_attrs(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) ib_dma_map_sg_attrs() argument
2729 ib_dma_unmap_sg_attrs(struct ib_device *dev, struct scatterlist *sg, int nents, enum dma_data_direction direction, struct dma_attrs *attrs) ib_dma_unmap_sg_attrs() argument
|
| /linux-4.4.14/drivers/media/usb/cx231xx/ |
| H A D | cx231xx-core.c | 184 if (req_data->direction & I2C_M_RD) { cx231xx_send_usb_command()
209 /* set the direction */ cx231xx_send_usb_command()
210 if (req_data->direction) { cx231xx_send_usb_command()
211 ven_req.direction = USB_DIR_IN; cx231xx_send_usb_command()
214 ven_req.direction = USB_DIR_OUT; cx231xx_send_usb_command()
348 if (ven_req->direction) cx231xx_send_vendor_cmd()
370 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, cx231xx_send_vendor_cmd()
381 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, cx231xx_send_vendor_cmd()
391 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, cx231xx_send_vendor_cmd()
396 ven_req->direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, cx231xx_send_vendor_cmd()
1428 u8 len, u8 request, u8 direction) cx231xx_send_gpio_cmd()
1438 if (direction) cx231xx_send_gpio_cmd()
1443 if (direction) cx231xx_send_gpio_cmd()
1461 /* set the direction */ cx231xx_send_gpio_cmd()
1462 if (direction) { cx231xx_send_gpio_cmd()
1463 ven_req.direction = USB_DIR_IN; cx231xx_send_gpio_cmd()
1466 ven_req.direction = USB_DIR_OUT; cx231xx_send_gpio_cmd()
1525 req_data.direction = I2C_M_RD; cx231xx_read_i2c_master()
1576 req_data.direction = 0; cx231xx_write_i2c_master()
1610 req_data.direction = I2C_M_RD; cx231xx_read_i2c_data()
1651 req_data.direction = 0; cx231xx_write_i2c_data()
1427 cx231xx_send_gpio_cmd(struct cx231xx *dev, u32 gpio_bit, u8 *gpio_val, u8 len, u8 request, u8 direction) cx231xx_send_gpio_cmd() argument
|
| H A D | cx231xx-i2c.c | 151 req_data.direction = msg->flags; cx231xx_i2c_send_bytes()
178 req_data.direction = msg->flags; cx231xx_i2c_send_bytes()
251 req_data.direction = msg->flags; cx231xx_i2c_recv_bytes()
264 req_data.direction = msg->flags; cx231xx_i2c_recv_bytes()
329 req_data.direction = msg2->flags; cx231xx_i2c_recv_bytes_with_saddr()
356 req_data.direction = I2C_M_RD; cx231xx_i2c_check_for_device()
|
| /linux-4.4.14/drivers/staging/iio/ |
| H A D | iio_simple_dummy_events.c | 28 * @dir: direction of the vent whose state is being queried
48 * @dir: direction of the vent whose state is being set
109 * @dir: direction of the vent whose value is being read
138 * @dir: direction of the vent whose value is being set
|
| /linux-4.4.14/drivers/vfio/ |
| H A D | vfio_iommu_spapr_tce.c | 421 enum dma_data_direction direction; tce_iommu_clear() local
424 direction = DMA_NONE; tce_iommu_clear()
426 ret = iommu_tce_xchg(tbl, entry, &oldhpa, &direction); tce_iommu_clear()
430 if (direction == DMA_NONE) tce_iommu_clear()
447 enum dma_data_direction direction = iommu_tce_direction(tce); tce_iommu_use_page() local
450 direction != DMA_TO_DEVICE, &page) != 1) tce_iommu_use_page()
461 enum dma_data_direction direction) tce_iommu_build()
482 dirtmp = direction; tce_iommu_build()
507 enum dma_data_direction direction) tce_iommu_build_v2()
532 dirtmp = direction; tce_iommu_build_v2()
785 enum dma_data_direction direction; tce_iommu_ioctl() local
813 direction = DMA_BIDIRECTIONAL; tce_iommu_ioctl()
815 direction = DMA_TO_DEVICE; tce_iommu_ioctl()
818 direction = DMA_FROM_DEVICE; tce_iommu_ioctl()
832 direction); tce_iommu_ioctl()
838 direction); tce_iommu_ioctl()
458 tce_iommu_build(struct tce_container *container, struct iommu_table *tbl, unsigned long entry, unsigned long tce, unsigned long pages, enum dma_data_direction direction) tce_iommu_build() argument
504 tce_iommu_build_v2(struct tce_container *container, struct iommu_table *tbl, unsigned long entry, unsigned long tce, unsigned long pages, enum dma_data_direction direction) tce_iommu_build_v2() argument
|
| /linux-4.4.14/drivers/misc/ |
| H A D | tifm_core.c | 299 int direction) tifm_map_sg()
301 return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); tifm_map_sg()
306 int direction) tifm_unmap_sg()
308 pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); tifm_unmap_sg()
298 tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, int direction) tifm_map_sg() argument
305 tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, int direction) tifm_unmap_sg() argument
|
| /linux-4.4.14/drivers/gpu/drm/nouveau/nvkm/subdev/gpio/ |
| H A D | priv.h | 20 /* configure gpio direction and output value */
|
| /linux-4.4.14/drivers/net/wireless/mediatek/mt7601u/ |
| H A D | usb.h | 73 const u8 direction, const u16 val, const u16 offset,
|
| /linux-4.4.14/drivers/dma-buf/ |
| H A D | dma-buf.c | 489 * @direction: [in] direction of DMA transfer
495 enum dma_data_direction direction) dma_buf_map_attachment()
504 sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); dma_buf_map_attachment()
518 * @direction: [in] direction of DMA transfer
523 enum dma_data_direction direction) dma_buf_unmap_attachment()
531 direction); dma_buf_unmap_attachment()
540 * specified access direction.
544 * @direction: [in] length of range for cpu access.
549 enum dma_data_direction direction) dma_buf_begin_cpu_access()
558 len, direction); dma_buf_begin_cpu_access()
568 * specified access direction.
572 * @direction: [in] length of range for cpu access.
577 enum dma_data_direction direction) dma_buf_end_cpu_access()
582 dmabuf->ops->end_cpu_access(dmabuf, start, len, direction); dma_buf_end_cpu_access()
494 dma_buf_map_attachment(struct dma_buf_attachment *attach, enum dma_data_direction direction) dma_buf_map_attachment() argument
521 dma_buf_unmap_attachment(struct dma_buf_attachment *attach, struct sg_table *sg_table, enum dma_data_direction direction) dma_buf_unmap_attachment() argument
548 dma_buf_begin_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len, enum dma_data_direction direction) dma_buf_begin_cpu_access() argument
576 dma_buf_end_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len, enum dma_data_direction direction) dma_buf_end_cpu_access() argument
|
| /linux-4.4.14/arch/x86/include/asm/ |
| H A D | tce.h | 42 unsigned int npages, unsigned long uaddr, int direction);
|
| /linux-4.4.14/include/xen/ |
| H A D | swiotlb-xen.h | 4 #include <linux/dma-direction.h>
|
| /linux-4.4.14/include/linux/dma/ |
| H A D | dw.h | 55 enum dma_transfer_direction direction);
|
| /linux-4.4.14/arch/mips/include/asm/mach-ath25/ |
| H A D | dma-coherence.h | 53 enum dma_data_direction direction) plat_unmap_dma_mem()
52 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/mips/include/asm/mach-bmips/ |
| H A D | dma-coherence.h | 30 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
29 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/mips/include/asm/mach-cavium-octeon/ |
| H A D | dma-coherence.h | 44 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
43 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/mips/include/asm/mach-generic/ |
| H A D | dma-coherence.h | 33 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
32 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/mips/include/asm/mach-ip27/ |
| H A D | dma-coherence.h | 44 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
43 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/mips/include/asm/mach-loongson64/ |
| H A D | dma-coherence.h | 55 size_t size, enum dma_data_direction direction) plat_unmap_dma_mem()
54 plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, size_t size, enum dma_data_direction direction) plat_unmap_dma_mem() argument
|
| /linux-4.4.14/arch/microblaze/mm/ |
| H A D | consistent.c | 226 void consistent_sync(void *vaddr, size_t size, int direction) consistent_sync() argument
239 switch (direction) { consistent_sync()
261 size_t size, int direction) consistent_sync_page()
264 consistent_sync((void *)start, size, direction); consistent_sync_page()
260 consistent_sync_page(struct page *page, unsigned long offset, size_t size, int direction) consistent_sync_page() argument
|
| /linux-4.4.14/arch/hexagon/include/asm/ |
| H A D | dma-mapping.h | 50 enum dma_data_direction direction);
|
| /linux-4.4.14/sound/soc/intel/skylake/ |
| H A D | skl-nhlt.h | 85 u8 direction; member in struct:nhlt_endpoint
|
| /linux-4.4.14/sound/soc/sh/rcar/ |
| H A D | rcar_snd.h | 33 * B : SSI direction
|
| /linux-4.4.14/sound/soc/cirrus/ |
| H A D | ep93xx-pcm.c | 45 if (data->direction == ep93xx_dma_chan_direction(chan)) { ep93xx_pcm_dma_filter()
|
| /linux-4.4.14/drivers/input/joystick/iforce/ |
| H A D | iforce-ff.c | 297 if (old->direction != new->direction need_core()
311 u16 interval, u16 direction) make_core()
326 data[5] = HI(direction); make_core()
409 effect->direction); iforce_upload_periodic()
469 effect->direction); iforce_upload_constant()
533 effect->direction); iforce_upload_condition()
309 make_core(struct iforce* iforce, u16 id, u16 mod_id1, u16 mod_id2, u8 effect_type, u8 axes, u16 duration, u16 delay, u16 button, u16 interval, u16 direction) make_core() argument
|
| /linux-4.4.14/sound/hda/ext/ |
| H A D | hdac_ext_stream.c | 31 * @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE)
39 int idx, int direction, int tag) snd_hdac_ext_stream_init()
63 snd_hdac_stream_init(bus, &stream->hstream, idx, direction, tag); snd_hdac_ext_stream_init()
73 * @dir: direction of streams
263 if (stream->direction != substream->stream) hdac_ext_link_stream_assign()
304 if (stream->direction != substream->stream) hdac_ext_host_stream_assign()
37 snd_hdac_ext_stream_init(struct hdac_ext_bus *ebus, struct hdac_ext_stream *stream, int idx, int direction, int tag) snd_hdac_ext_stream_init() argument
|
| /linux-4.4.14/drivers/staging/most/aim-sound/ |
| H A D | sound.c | 191 if (channel->cfg->direction & MOST_CH_RX) copy_data()
281 if (cfg->direction == MOST_CH_TX) { pcm_open()
292 if (cfg->direction == MOST_CH_TX) pcm_open()
315 if (channel->cfg->direction == MOST_CH_TX) pcm_close()
380 if (cfg->direction == MOST_CH_TX) { pcm_prepare()
570 int direction; audio_probe_channel() local
588 if (cfg->direction == MOST_CH_TX) { audio_probe_channel()
590 direction = SNDRV_PCM_STREAM_PLAYBACK; audio_probe_channel()
593 direction = SNDRV_PCM_STREAM_CAPTURE; audio_probe_channel()
630 snd_pcm_set_ops(pcm, direction, &pcm_ops); audio_probe_channel()
|
| /linux-4.4.14/arch/sparc/include/asm/ |
| H A D | floppy_64.h | 149 * underruns. If non-zero, doing_pdma encodes the direction of
293 int direction; member in struct:sun_pci_dma_op
356 (0 == sun_pci_dma_pending.direction)); sun_pci_fd_enable_dma()
360 sun_pci_dma_current.direction = sun_pci_dma_pending.direction; sun_pci_fd_enable_dma()
364 sun_pci_dma_pending.direction = 0; sun_pci_fd_enable_dma()
371 sun_pci_dma_current.direction); sun_pci_fd_enable_dma()
388 sun_pci_dma_current.direction); sun_pci_fd_disable_dma()
395 sun_pci_dma_pending.direction = DMA_TO_DEVICE; sun_pci_fd_set_dma_mode()
397 sun_pci_dma_pending.direction = DMA_FROM_DEVICE; sun_pci_fd_set_dma_mode()
|
| /linux-4.4.14/sound/hda/ |
| H A D | hdac_stream.c | 20 * @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE)
26 int idx, int direction, int tag) snd_hdac_stream_init()
34 azx_dev->direction = direction; snd_hdac_stream_init()
186 if (azx_dev->direction == SNDRV_PCM_STREAM_PLAYBACK) snd_hdac_stream_setup()
248 if (azx_dev->direction != substream->stream) snd_hdac_stream_assign()
291 * direction
294 * @dir: direction for the stream to be found
303 if (s->direction == dir && s->stream_tag == stream_tag) snd_hdac_get_stream()
25 snd_hdac_stream_init(struct hdac_bus *bus, struct hdac_stream *azx_dev, int idx, int direction, int tag) snd_hdac_stream_init() argument
|
| /linux-4.4.14/sound/pci/ice1712/ |
| H A D | ice1712.h | 79 #define ICE1712_I2C_WRITE 0x01 /* write direction */
363 unsigned int direction; /* current direction bits */ member in struct:snd_ice1712::ice1712_gpio
441 ice->gpio.saved[0] = ice->gpio.direction; snd_ice1712_save_gpio_status()
449 ice->gpio.direction = ice->gpio.saved[0]; snd_ice1712_restore_gpio_status()
464 * set gpio direction, write mask and data
471 ice->gpio.direction |= mask; snd_ice1712_gpio_write_bits()
472 snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); snd_ice1712_gpio_write_bits()
482 ice->gpio.direction &= ~mask; snd_ice1712_gpio_read_bits()
483 snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); snd_ice1712_gpio_read_bits()
|
| /linux-4.4.14/drivers/usb/musb/ |
| H A D | ux500_dma.c | 90 enum dma_transfer_direction direction; ux500_configure_channel() local
111 direction = ux500_channel->is_tx ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; ux500_configure_channel()
115 slave_conf.direction = direction; ux500_configure_channel()
126 dma_desc = dmaengine_prep_slave_sg(dma_chan, &sg, 1, direction, ux500_configure_channel()
|
| H A D | musb_cppi41.c | 153 enum dma_transfer_direction direction; cppi41_trans_done() local
163 direction = cppi41_channel->is_tx ? DMA_MEM_TO_DEV cppi41_trans_done()
168 direction, cppi41_trans_done()
373 enum dma_transfer_direction direction; cppi41_configure_channel() local
423 direction = cppi41_channel->is_tx ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; cppi41_configure_channel()
424 dma_desc = dmaengine_prep_slave_single(dc, dma_addr, len, direction, cppi41_configure_channel()
|
| /linux-4.4.14/drivers/dma/dw/ |
| H A D | core.c | 43 bool _is_slave = is_slave_direction(_dwc->direction); \
705 dwc->direction = DMA_MEM_TO_MEM; dwc_prep_dma_memcpy()
762 unsigned int sg_len, enum dma_transfer_direction direction, dwc_prep_slave_sg()
781 if (unlikely(!is_slave_direction(direction) || !sg_len)) dwc_prep_slave_sg()
784 dwc->direction = direction; dwc_prep_slave_sg()
788 switch (direction) { dwc_prep_slave_sg()
917 "not enough descriptors available. Direction %d\n", direction); local
963 if (!is_slave_direction(sconfig->direction)) dwc_config()
967 dwc->direction = sconfig->direction; dwc_config()
1309 * @direction: transfer direction, to or from device
1316 enum dma_transfer_direction direction) dw_dma_cyclic_prep()
1355 if (unlikely(!is_slave_direction(direction))) dw_dma_cyclic_prep()
1358 dwc->direction = direction; dw_dma_cyclic_prep()
1360 if (direction == DMA_MEM_TO_DEV) dw_dma_cyclic_prep()
1393 switch (direction) { dw_dma_cyclic_prep()
1614 dwc->direction = DMA_TRANS_NONE; dw_dma_probe()
761 dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len, enum dma_transfer_direction direction, unsigned long flags, void *context) dwc_prep_slave_sg() argument
1314 dw_dma_cyclic_prep(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len, enum dma_transfer_direction direction) dw_dma_cyclic_prep() argument
|
| /linux-4.4.14/drivers/atm/ |
| H A D | fore200e.c | 178 fore200e_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, int size, int alignment, int direction) fore200e_chunk_alloc() argument
187 chunk->direction = direction; fore200e_chunk_alloc()
198 chunk->dma_addr = fore200e->bus->dma_map(fore200e, chunk->align_addr, chunk->align_size, direction); fore200e_chunk_alloc()
209 fore200e->bus->dma_unmap(fore200e, chunk->dma_addr, chunk->dma_size, chunk->direction); fore200e_chunk_free()
426 fore200e_pca_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction) fore200e_pca_dma_map() argument
428 u32 dma_addr = dma_map_single(&((struct pci_dev *) fore200e->bus_dev)->dev, virt_addr, size, direction); fore200e_pca_dma_map()
430 DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d, --> dma_addr = 0x%08x\n", fore200e_pca_dma_map()
431 virt_addr, size, direction, dma_addr); fore200e_pca_dma_map()
438 fore200e_pca_dma_unmap(struct fore200e* fore200e, u32 dma_addr, int size, int direction) fore200e_pca_dma_unmap() argument
440 DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n", fore200e_pca_dma_unmap()
441 dma_addr, size, direction); fore200e_pca_dma_unmap()
443 dma_unmap_single(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); fore200e_pca_dma_unmap()
448 fore200e_pca_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, int direction) fore200e_pca_dma_sync_for_cpu() argument
450 DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); fore200e_pca_dma_sync_for_cpu()
452 dma_sync_single_for_cpu(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); fore200e_pca_dma_sync_for_cpu()
456 fore200e_pca_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int size, int direction) fore200e_pca_dma_sync_for_device() argument
458 DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); fore200e_pca_dma_sync_for_device()
460 dma_sync_single_for_device(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); fore200e_pca_dma_sync_for_device()
674 static u32 fore200e_sba_dma_map(struct fore200e *fore200e, void* virt_addr, int size, int direction) fore200e_sba_dma_map() argument
679 dma_addr = dma_map_single(&op->dev, virt_addr, size, direction); fore200e_sba_dma_map()
681 DPRINTK(3, "SBUS DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d --> dma_addr = 0x%08x\n", fore200e_sba_dma_map()
682 virt_addr, size, direction, dma_addr); fore200e_sba_dma_map()
687 static void fore200e_sba_dma_unmap(struct fore200e *fore200e, u32 dma_addr, int size, int direction) fore200e_sba_dma_unmap() argument
691 DPRINTK(3, "SBUS DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d,\n", fore200e_sba_dma_unmap()
692 dma_addr, size, direction); fore200e_sba_dma_unmap()
694 dma_unmap_single(&op->dev, dma_addr, size, direction); fore200e_sba_dma_unmap()
697 static void fore200e_sba_dma_sync_for_cpu(struct fore200e *fore200e, u32 dma_addr, int size, int direction) fore200e_sba_dma_sync_for_cpu() argument
701 DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); fore200e_sba_dma_sync_for_cpu()
703 dma_sync_single_for_cpu(&op->dev, dma_addr, size, direction); fore200e_sba_dma_sync_for_cpu()
706 static void fore200e_sba_dma_sync_for_device(struct fore200e *fore200e, u32 dma_addr, int size, int direction) fore200e_sba_dma_sync_for_device() argument
710 DPRINTK(3, "SBUS DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); fore200e_sba_dma_sync_for_device()
712 dma_sync_single_for_device(&op->dev, dma_addr, size, direction); fore200e_sba_dma_sync_for_device()
|
| /linux-4.4.14/drivers/staging/most/hdm-dim2/ |
| H A D | dim2_hdm.c | 69 * @direction: channel direction (TX or RX)
78 enum most_channel_direction direction; member in struct:hdm_channel
372 hdm_ch->direction == MOST_CH_RX && service_done_flag()
523 bool const is_tx = ccfg->direction == MOST_CH_TX; configure_channel()
607 hdm_ch->direction = ccfg->direction; configure_channel()
611 hdm_ch->direction == MOST_CH_TX && configure_channel()
804 cap->direction = MOST_CH_RX | MOST_CH_TX; dim2_probe()
|
| /linux-4.4.14/drivers/spi/ |
| H A D | spi-rockchip.c | 159 enum dma_transfer_direction direction; member in struct:rockchip_spi_dma_data
454 rxconf.direction = rs->dma_rx.direction; rockchip_spi_prepare_dma()
463 rs->dma_rx.direction, DMA_PREP_INTERRUPT); rockchip_spi_prepare_dma()
471 txconf.direction = rs->dma_tx.direction; rockchip_spi_prepare_dma()
480 rs->dma_tx.direction, DMA_PREP_INTERRUPT); rockchip_spi_prepare_dma()
740 rs->dma_tx.direction = DMA_MEM_TO_DEV; rockchip_spi_probe()
741 rs->dma_rx.direction = DMA_DEV_TO_MEM; rockchip_spi_probe()
|
| /linux-4.4.14/drivers/s390/net/ |
| H A D | ctcm_main.c | 247 * direction Direction we want to use this channel for.
252 char *id, int direction) channel_get()
261 CTCM_FUNTAIL, type, id, direction); channel_get()
268 ch->flags |= (direction == CTCM_WRITE) channel_get()
1395 * 1: read or write (depending on direction) with fixed add_channel()
1407 * the channel's direction is yet unknown here. add_channel()
1530 int direction; ctcm_new_device() local
1591 for (direction = CTCM_READ; direction <= CTCM_WRITE; direction++) { ctcm_new_device()
1592 priv->channel[direction] = ctcm_new_device()
1593 channel_get(type, direction == CTCM_READ ? ctcm_new_device()
1594 read_id : write_id, direction); ctcm_new_device()
1595 if (priv->channel[direction] == NULL) { ctcm_new_device()
1596 if (direction == CTCM_WRITE) ctcm_new_device()
1600 priv->channel[direction]->netdev = dev; ctcm_new_device()
1601 priv->channel[direction]->protocol = priv->protocol; ctcm_new_device()
1602 priv->channel[direction]->max_bufsize = priv->buffer_size; ctcm_new_device()
251 channel_get(enum ctcm_channel_types type, char *id, int direction) channel_get() argument
|
| /linux-4.4.14/drivers/video/fbdev/ |
| H A D | tridentfb.c | 356 int direction = 2; blade_copy_rect() local
363 direction = 0; blade_copy_rect()
366 writemmr(par, CMD, 0xE0000000 | 1 << 19 | 1 << 4 | 1 << 2 | direction); blade_copy_rect()
368 writemmr(par, SRC1, direction ? s2 : s1); blade_copy_rect()
369 writemmr(par, SRC2, direction ? s1 : s2); blade_copy_rect()
370 writemmr(par, DST1, direction ? d2 : d1); blade_copy_rect()
371 writemmr(par, DST2, direction ? d1 : d2); blade_copy_rect()
445 int direction = 0x0004; xp_copy_rect() local
448 direction |= 0x0200; xp_copy_rect()
457 direction |= 0x0100; xp_copy_rect()
465 writemmr(par, DRAWFL, direction); xp_copy_rect()
518 int direction = 0x4; image_copy_rect() local
525 direction = 0; image_copy_rect()
530 writemmr(par, SRC1, direction ? s2 : s1); image_copy_rect()
531 writemmr(par, SRC2, direction ? s1 : s2); image_copy_rect()
532 writemmr(par, DST1, direction ? d2 : d1); image_copy_rect()
533 writemmr(par, DST2, direction ? d1 : d2); image_copy_rect()
535 0x80000000 | 1 << 22 | 1 << 10 | 1 << 7 | direction); image_copy_rect()
|
| /linux-4.4.14/drivers/mmc/host/ |
| H A D | mmc_spi.c | 574 enum dma_data_direction direction) mmc_spi_setup_data_message()
587 if (direction == DMA_TO_DEVICE) { mmc_spi_setup_data_message()
614 if (direction == DMA_TO_DEVICE) { mmc_spi_setup_data_message()
642 if (multiple || direction == DMA_TO_DEVICE) { mmc_spi_setup_data_message()
645 t->len = (direction == DMA_TO_DEVICE) mmc_spi_setup_data_message()
884 enum dma_data_direction direction; mmc_spi_data_do() local
892 direction = DMA_FROM_DEVICE; mmc_spi_data_do()
894 direction = DMA_TO_DEVICE; mmc_spi_data_do()
895 mmc_spi_setup_data_message(host, multiple, direction); mmc_spi_data_do()
915 enum dma_data_direction dir = direction; mmc_spi_data_do()
928 if (direction == DMA_TO_DEVICE) mmc_spi_data_do()
936 if (direction == DMA_TO_DEVICE) mmc_spi_data_do()
947 (direction == DMA_TO_DEVICE) mmc_spi_data_do()
952 if (direction == DMA_TO_DEVICE) mmc_spi_data_do()
967 if (direction == DMA_FROM_DEVICE) mmc_spi_data_do()
976 (direction == DMA_TO_DEVICE) mmc_spi_data_do()
989 if (direction == DMA_TO_DEVICE && multiple) { mmc_spi_data_do()
571 mmc_spi_setup_data_message( struct mmc_spi_host *host, int multiple, enum dma_data_direction direction) mmc_spi_setup_data_message() argument
|
| /linux-4.4.14/drivers/usb/dwc3/ |
| H A D | ep0.c | 139 unsigned direction; __dwc3_gadget_ep0_queue() local
141 direction = !!(dep->flags & DWC3_EP0_DIR_IN); __dwc3_gadget_ep0_queue()
148 __dwc3_ep0_do_control_data(dwc, dwc->eps[direction], req); __dwc3_gadget_ep0_queue()
161 unsigned direction; __dwc3_gadget_ep0_queue() local
163 direction = !dwc->ep0_expect_in; __dwc3_gadget_ep0_queue()
168 __dwc3_ep0_do_control_status(dwc, dwc->eps[direction]); __dwc3_gadget_ep0_queue()
209 unsigned direction; __dwc3_gadget_ep0_queue() local
211 direction = dwc->ep0_expect_in; __dwc3_gadget_ep0_queue()
214 __dwc3_ep0_do_control_data(dwc, dwc->eps[direction], req); __dwc3_gadget_ep0_queue()
672 * aligned transfers on the OUT direction, so we queue a request for dwc3_ep0_set_sel()
955 req->direction = !!dep->number; __dwc3_ep0_do_control_data()
1070 * it's for the wrong direction. dwc3_ep0_xfernotready()
1080 "Wrong direction for Data phase"); dwc3_ep0_xfernotready()
|
| /linux-4.4.14/drivers/tty/serial/8250/ |
| H A D | 8250_dma.c | 163 dma->rxconf.direction = DMA_DEV_TO_MEM; serial8250_request_dma()
167 dma->txconf.direction = DMA_MEM_TO_DEV; serial8250_request_dma()
|
| /linux-4.4.14/drivers/i2c/busses/ |
| H A D | i2c-via.c | 44 open drain. So a we set a low value by setting the direction to
45 output and a high value by setting the direction to input and
|
| /linux-4.4.14/drivers/gpu/drm/via/ |
| H A D | via_dmablit.h | 46 enum dma_data_direction direction; member in struct:_drm_via_sg_info
123 #define VIA_DMA_DPR_DT (1<<3) /* direction of transfer (RO) */
|
| /linux-4.4.14/drivers/input/mouse/ |
| H A D | cypress_ps2.h | 160 int tp_width; /* X direction physical size in mm. */
161 int tp_high; /* Y direction physical size in mm. */
|
| /linux-4.4.14/drivers/media/usb/cpia2/ |
| H A D | cpia2_usb.c | 405 cmd.direction = TRANSFER_WRITE; configure_transfer_mode()
419 cmd.direction = TRANSFER_READ; configure_transfer_mode()
442 cmd.direction = TRANSFER_WRITE; configure_transfer_mode()
591 u8 request, u8 start, u8 count, u8 direction) cpia2_usb_transfer_cmd()
606 if (direction == TRANSFER_READ) { cpia2_usb_transfer_cmd()
610 } else if (direction == TRANSFER_WRITE) { cpia2_usb_transfer_cmd()
621 LOG("Unexpected first byte of direction: %d\n", cpia2_usb_transfer_cmd()
622 direction); cpia2_usb_transfer_cmd()
589 cpia2_usb_transfer_cmd(struct camera_data *cam, void *registers, u8 request, u8 start, u8 count, u8 direction) cpia2_usb_transfer_cmd() argument
|
| /linux-4.4.14/drivers/pinctrl/uniphier/ |
| H A D | pinctrl-uniphier.h | 56 /* direction of pull register */
79 /* direction of pull register (no pin supports bi-directional pull biasing) */
|
| /linux-4.4.14/arch/x86/kernel/ |
| H A D | tce_64.c | 50 unsigned int npages, unsigned long uaddr, int direction) tce_build()
57 if (direction != DMA_TO_DEVICE) tce_build()
49 tce_build(struct iommu_table *tbl, unsigned long index, unsigned int npages, unsigned long uaddr, int direction) tce_build() argument
|
| /linux-4.4.14/arch/arc/include/asm/ |
| H A D | dma-mapping.h | 146 enum dma_data_direction direction) dma_sync_single_range_for_cpu()
154 enum dma_data_direction direction) dma_sync_single_range_for_device()
144 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) dma_sync_single_range_for_cpu() argument
152 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle, unsigned long offset, size_t size, enum dma_data_direction direction) dma_sync_single_range_for_device() argument
|
| /linux-4.4.14/arch/cris/arch-v10/drivers/ |
| H A D | gpio.c | 94 /* What direction bits that are user changeable 1=changeable*/
133 and outputs at the same time, only some of the bits can change direction
404 /* Set direction 0=unchanged 1=input, setget_input()
585 /* Read direction 0=input 1=output */ gpio_ioctl()
598 /* Set direction 0=unchanged 1=input, gpio_ioctl()
606 /* Set direction 0=unchanged 1=output, gpio_ioctl()
633 * the direction is correct gpio_ioctl()
783 /* Correct the bits that can change direction */ ioif_watcher()
|