async_xor: permit callers to pass in a 'dma/page scribble' region
[linux-2.6.git] / Documentation / crypto / async-tx-api.txt
1                  Asynchronous Transfers/Transforms API
2
3 1 INTRODUCTION
4
5 2 GENEALOGY
6
7 3 USAGE
8 3.1 General format of the API
9 3.2 Supported operations
10 3.3 Descriptor management
11 3.4 When does the operation execute?
12 3.5 When does the operation complete?
13 3.6 Constraints
14 3.7 Example
15
16 4 DMAENGINE DRIVER DEVELOPER NOTES
17 4.1 Conformance points
18 4.2 "My application needs exclusive control of hardware channels"
19
20 5 SOURCE
21
22 ---
23
24 1 INTRODUCTION
25
26 The async_tx API provides methods for describing a chain of asynchronous
27 bulk memory transfers/transforms with support for inter-transactional
28 dependencies.  It is implemented as a dmaengine client that smooths over
29 the details of different hardware offload engine implementations.  Code
30 that is written to the API can optimize for asynchronous operation and
31 the API will fit the chain of operations to the available offload
32 resources.
33
34 2 GENEALOGY
35
36 The API was initially designed to offload the memory copy and
37 xor-parity-calculations of the md-raid5 driver using the offload engines
38 present in the Intel(R) Xscale series of I/O processors.  It also built
39 on the 'dmaengine' layer developed for offloading memory copies in the
40 network stack using Intel(R) I/OAT engines.  The following design
41 features surfaced as a result:
42 1/ implicit synchronous path: users of the API do not need to know if
43    the platform they are running on has offload capabilities.  The
44    operation will be offloaded when an engine is available and carried out
45    in software otherwise.
46 2/ cross channel dependency chains: the API allows a chain of dependent
47    operations to be submitted, like xor->copy->xor in the raid5 case.  The
48    API automatically handles cases where the transition from one operation
49    to another implies a hardware channel switch.
50 3/ dmaengine extensions to support multiple clients and operation types
51    beyond 'memcpy'
52
53 3 USAGE
54
55 3.1 General format of the API:
56 struct dma_async_tx_descriptor *
57 async_<operation>(<op specific parameters>, struct async_submit ctl *submit)
58
59 3.2 Supported operations:
60 memcpy  - memory copy between a source and a destination buffer
61 memset  - fill a destination buffer with a byte value
62 xor     - xor a series of source buffers and write the result to a
63           destination buffer
64 xor_val - xor a series of source buffers and set a flag if the
65           result is zero.  The implementation attempts to prevent
66           writes to memory
67
68 3.3 Descriptor management:
69 The return value is non-NULL and points to a 'descriptor' when the operation
70 has been queued to execute asynchronously.  Descriptors are recycled
71 resources, under control of the offload engine driver, to be reused as
72 operations complete.  When an application needs to submit a chain of
73 operations it must guarantee that the descriptor is not automatically recycled
74 before the dependency is submitted.  This requires that all descriptors be
75 acknowledged by the application before the offload engine driver is allowed to
76 recycle (or free) the descriptor.  A descriptor can be acked by one of the
77 following methods:
78 1/ setting the ASYNC_TX_ACK flag if no child operations are to be submitted
79 2/ submitting an unacknowledged descriptor as a dependency to another
80    async_tx call will implicitly set the acknowledged state.
81 3/ calling async_tx_ack() on the descriptor.
82
83 3.4 When does the operation execute?
84 Operations do not immediately issue after return from the
85 async_<operation> call.  Offload engine drivers batch operations to
86 improve performance by reducing the number of mmio cycles needed to
87 manage the channel.  Once a driver-specific threshold is met the driver
88 automatically issues pending operations.  An application can force this
89 event by calling async_tx_issue_pending_all().  This operates on all
90 channels since the application has no knowledge of channel to operation
91 mapping.
92
93 3.5 When does the operation complete?
94 There are two methods for an application to learn about the completion
95 of an operation.
96 1/ Call dma_wait_for_async_tx().  This call causes the CPU to spin while
97    it polls for the completion of the operation.  It handles dependency
98    chains and issuing pending operations.
99 2/ Specify a completion callback.  The callback routine runs in tasklet
100    context if the offload engine driver supports interrupts, or it is
101    called in application context if the operation is carried out
102    synchronously in software.  The callback can be set in the call to
103    async_<operation>, or when the application needs to submit a chain of
104    unknown length it can use the async_trigger_callback() routine to set a
105    completion interrupt/callback at the end of the chain.
106
107 3.6 Constraints:
108 1/ Calls to async_<operation> are not permitted in IRQ context.  Other
109    contexts are permitted provided constraint #2 is not violated.
110 2/ Completion callback routines cannot submit new operations.  This
111    results in recursion in the synchronous case and spin_locks being
112    acquired twice in the asynchronous case.
113
114 3.7 Example:
115 Perform a xor->copy->xor operation where each operation depends on the
116 result from the previous operation:
117
118 void callback(void *param)
119 {
120         struct completion *cmp = param;
121
122         complete(cmp);
123 }
124
125 void run_xor_copy_xor(struct page **xor_srcs,
126                       int xor_src_cnt,
127                       struct page *xor_dest,
128                       size_t xor_len,
129                       struct page *copy_src,
130                       struct page *copy_dest,
131                       size_t copy_len)
132 {
133         struct dma_async_tx_descriptor *tx;
134         addr_conv_t addr_conv[xor_src_cnt];
135         struct async_submit_ctl submit;
136         addr_conv_t addr_conv[NDISKS];
137         struct completion cmp;
138
139         init_async_submit(&submit, ASYNC_TX_XOR_DROP_DST, NULL, NULL, NULL,
140                           addr_conv);
141         tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len, &submit)
142
143         submit->depend_tx = tx;
144         tx = async_memcpy(copy_dest, copy_src, 0, 0, copy_len, &submit);
145
146         init_completion(&cmp);
147         init_async_submit(&submit, ASYNC_TX_XOR_DROP_DST | ASYNC_TX_ACK, tx,
148                           callback, &cmp, addr_conv);
149         tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len, &submit);
150
151         async_tx_issue_pending_all();
152
153         wait_for_completion(&cmp);
154 }
155
156 See include/linux/async_tx.h for more information on the flags.  See the
157 ops_run_* and ops_complete_* routines in drivers/md/raid5.c for more
158 implementation examples.
159
160 4 DRIVER DEVELOPMENT NOTES
161
162 4.1 Conformance points:
163 There are a few conformance points required in dmaengine drivers to
164 accommodate assumptions made by applications using the async_tx API:
165 1/ Completion callbacks are expected to happen in tasklet context
166 2/ dma_async_tx_descriptor fields are never manipulated in IRQ context
167 3/ Use async_tx_run_dependencies() in the descriptor clean up path to
168    handle submission of dependent operations
169
170 4.2 "My application needs exclusive control of hardware channels"
171 Primarily this requirement arises from cases where a DMA engine driver
172 is being used to support device-to-memory operations.  A channel that is
173 performing these operations cannot, for many platform specific reasons,
174 be shared.  For these cases the dma_request_channel() interface is
175 provided.
176
177 The interface is:
178 struct dma_chan *dma_request_channel(dma_cap_mask_t mask,
179                                      dma_filter_fn filter_fn,
180                                      void *filter_param);
181
182 Where dma_filter_fn is defined as:
183 typedef bool (*dma_filter_fn)(struct dma_chan *chan, void *filter_param);
184
185 When the optional 'filter_fn' parameter is set to NULL
186 dma_request_channel simply returns the first channel that satisfies the
187 capability mask.  Otherwise, when the mask parameter is insufficient for
188 specifying the necessary channel, the filter_fn routine can be used to
189 disposition the available channels in the system. The filter_fn routine
190 is called once for each free channel in the system.  Upon seeing a
191 suitable channel filter_fn returns DMA_ACK which flags that channel to
192 be the return value from dma_request_channel.  A channel allocated via
193 this interface is exclusive to the caller, until dma_release_channel()
194 is called.
195
196 The DMA_PRIVATE capability flag is used to tag dma devices that should
197 not be used by the general-purpose allocator.  It can be set at
198 initialization time if it is known that a channel will always be
199 private.  Alternatively, it is set when dma_request_channel() finds an
200 unused "public" channel.
201
202 A couple caveats to note when implementing a driver and consumer:
203 1/ Once a channel has been privately allocated it will no longer be
204    considered by the general-purpose allocator even after a call to
205    dma_release_channel().
206 2/ Since capabilities are specified at the device level a dma_device
207    with multiple channels will either have all channels public, or all
208    channels private.
209
210 5 SOURCE
211
212 include/linux/dmaengine.h: core header file for DMA drivers and api users
213 drivers/dma/dmaengine.c: offload engine channel management routines
214 drivers/dma/: location for offload engine drivers
215 include/linux/async_tx.h: core header file for the async_tx api
216 crypto/async_tx/async_tx.c: async_tx interface to dmaengine and common code
217 crypto/async_tx/async_memcpy.c: copy offload
218 crypto/async_tx/async_memset.c: memory fill offload
219 crypto/async_tx/async_xor.c: xor and xor zero sum offload