dmaengine.h 33.5 KB
Newer Older
C
Chris Leech 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The full GNU General Public License is included in this distribution in the
 * file called COPYING.
 */
21 22
#ifndef LINUX_DMAENGINE_H
#define LINUX_DMAENGINE_H
23

C
Chris Leech 已提交
24 25
#include <linux/device.h>
#include <linux/uio.h>
26
#include <linux/bug.h>
27
#include <linux/scatterlist.h>
28
#include <linux/bitmap.h>
29
#include <linux/types.h>
30
#include <asm/page.h>
31

C
Chris Leech 已提交
32
/**
33
 * typedef dma_cookie_t - an opaque DMA cookie
C
Chris Leech 已提交
34 35 36 37
 *
 * if dma_cookie_t is >0 it's a DMA request cookie, <0 it's an error code
 */
typedef s32 dma_cookie_t;
S
Steven J. Magnani 已提交
38 39
#define DMA_MIN_COOKIE	1
#define DMA_MAX_COOKIE	INT_MAX
C
Chris Leech 已提交
40

41 42 43 44
static inline int dma_submit_error(dma_cookie_t cookie)
{
	return cookie < 0 ? cookie : 0;
}
C
Chris Leech 已提交
45 46 47 48 49

/**
 * enum dma_status - DMA transaction status
 * @DMA_SUCCESS: transaction completed successfully
 * @DMA_IN_PROGRESS: transaction not yet processed
50
 * @DMA_PAUSED: transaction is paused
C
Chris Leech 已提交
51 52 53 54 55
 * @DMA_ERROR: transaction failed
 */
enum dma_status {
	DMA_SUCCESS,
	DMA_IN_PROGRESS,
56
	DMA_PAUSED,
C
Chris Leech 已提交
57 58 59
	DMA_ERROR,
};

60 61
/**
 * enum dma_transaction_type - DMA transaction types/indexes
62 63 64
 *
 * Note: The DMA_ASYNC_TX capability is not to be set by drivers.  It is
 * automatically set as dma devices are registered.
65 66 67 68
 */
enum dma_transaction_type {
	DMA_MEMCPY,
	DMA_XOR,
69
	DMA_PQ,
D
Dan Williams 已提交
70 71
	DMA_XOR_VAL,
	DMA_PQ_VAL,
72
	DMA_INTERRUPT,
73
	DMA_SG,
74
	DMA_PRIVATE,
75
	DMA_ASYNC_TX,
76
	DMA_SLAVE,
77
	DMA_CYCLIC,
78
	DMA_INTERLEAVE,
79
/* last transaction type for creation of the capabilities mask */
80 81
	DMA_TX_TYPE_END,
};
82

83 84 85 86 87 88 89 90 91 92 93 94
/**
 * enum dma_transfer_direction - dma transfer mode and direction indicator
 * @DMA_MEM_TO_MEM: Async/Memcpy mode
 * @DMA_MEM_TO_DEV: Slave mode & From Memory to Device
 * @DMA_DEV_TO_MEM: Slave mode & From Device to Memory
 * @DMA_DEV_TO_DEV: Slave mode & From Device to Device
 */
enum dma_transfer_direction {
	DMA_MEM_TO_MEM,
	DMA_MEM_TO_DEV,
	DMA_DEV_TO_MEM,
	DMA_DEV_TO_DEV,
95
	DMA_TRANS_NONE,
96
};
97

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
/**
 * Interleaved Transfer Request
 * ----------------------------
 * A chunk is collection of contiguous bytes to be transfered.
 * The gap(in bytes) between two chunks is called inter-chunk-gap(ICG).
 * ICGs may or maynot change between chunks.
 * A FRAME is the smallest series of contiguous {chunk,icg} pairs,
 *  that when repeated an integral number of times, specifies the transfer.
 * A transfer template is specification of a Frame, the number of times
 *  it is to be repeated and other per-transfer attributes.
 *
 * Practically, a client driver would have ready a template for each
 *  type of transfer it is going to need during its lifetime and
 *  set only 'src_start' and 'dst_start' before submitting the requests.
 *
 *
 *  |      Frame-1        |       Frame-2       | ~ |       Frame-'numf'  |
 *  |====....==.===...=...|====....==.===...=...| ~ |====....==.===...=...|
 *
 *    ==  Chunk size
 *    ... ICG
 */

/**
 * struct data_chunk - Element of scatter-gather list that makes a frame.
 * @size: Number of bytes to read from source.
 *	  size_dst := fn(op, size_src), so doesn't mean much for destination.
 * @icg: Number of bytes to jump after last src/dst address of this
 *	 chunk and before first src/dst address for next chunk.
 *	 Ignored for dst(assumed 0), if dst_inc is true and dst_sgl is false.
 *	 Ignored for src(assumed 0), if src_inc is true and src_sgl is false.
 */
struct data_chunk {
	size_t size;
	size_t icg;
};

/**
 * struct dma_interleaved_template - Template to convey DMAC the transfer pattern
 *	 and attributes.
 * @src_start: Bus address of source for the first chunk.
 * @dst_start: Bus address of destination for the first chunk.
 * @dir: Specifies the type of Source and Destination.
 * @src_inc: If the source address increments after reading from it.
 * @dst_inc: If the destination address increments after writing to it.
 * @src_sgl: If the 'icg' of sgl[] applies to Source (scattered read).
 *		Otherwise, source is read contiguously (icg ignored).
 *		Ignored if src_inc is false.
 * @dst_sgl: If the 'icg' of sgl[] applies to Destination (scattered write).
 *		Otherwise, destination is filled contiguously (icg ignored).
 *		Ignored if dst_inc is false.
 * @numf: Number of frames in this template.
 * @frame_size: Number of chunks in a frame i.e, size of sgl[].
 * @sgl: Array of {chunk,icg} pairs that make up a frame.
 */
struct dma_interleaved_template {
	dma_addr_t src_start;
	dma_addr_t dst_start;
	enum dma_transfer_direction dir;
	bool src_inc;
	bool dst_inc;
	bool src_sgl;
	bool dst_sgl;
	size_t numf;
	size_t frame_size;
	struct data_chunk sgl[0];
};

166
/**
167
 * enum dma_ctrl_flags - DMA flags to augment operation preparation,
168
 *  control completion, and communicate status.
169
 * @DMA_PREP_INTERRUPT - trigger an interrupt (callback) upon completion of
170
 *  this transaction
171
 * @DMA_CTRL_ACK - if clear, the descriptor cannot be reused until the client
172 173
 *  acknowledges receipt, i.e. has has a chance to establish any dependency
 *  chains
174 175
 * @DMA_COMPL_SKIP_SRC_UNMAP - set to disable dma-unmapping the source buffer(s)
 * @DMA_COMPL_SKIP_DEST_UNMAP - set to disable dma-unmapping the destination(s)
176 177 178 179
 * @DMA_COMPL_SRC_UNMAP_SINGLE - set to do the source dma-unmapping as single
 * 	(if not set, do the source dma-unmapping as page)
 * @DMA_COMPL_DEST_UNMAP_SINGLE - set to do the destination dma-unmapping as single
 * 	(if not set, do the destination dma-unmapping as page)
180 181 182 183 184
 * @DMA_PREP_PQ_DISABLE_P - prevent generation of P while generating Q
 * @DMA_PREP_PQ_DISABLE_Q - prevent generation of Q while generating P
 * @DMA_PREP_CONTINUE - indicate to a driver that it is reusing buffers as
 *  sources that were the result of a previous operation, in the case of a PQ
 *  operation it continues the calculation with new sources
D
Dan Williams 已提交
185 186
 * @DMA_PREP_FENCE - tell the driver that subsequent operations depend
 *  on the result of this operation
187
 */
188
enum dma_ctrl_flags {
189
	DMA_PREP_INTERRUPT = (1 << 0),
190
	DMA_CTRL_ACK = (1 << 1),
191 192
	DMA_COMPL_SKIP_SRC_UNMAP = (1 << 2),
	DMA_COMPL_SKIP_DEST_UNMAP = (1 << 3),
193 194
	DMA_COMPL_SRC_UNMAP_SINGLE = (1 << 4),
	DMA_COMPL_DEST_UNMAP_SINGLE = (1 << 5),
195 196 197
	DMA_PREP_PQ_DISABLE_P = (1 << 6),
	DMA_PREP_PQ_DISABLE_Q = (1 << 7),
	DMA_PREP_CONTINUE = (1 << 8),
D
Dan Williams 已提交
198
	DMA_PREP_FENCE = (1 << 9),
199 200
};

201 202 203 204 205 206
/**
 * enum dma_ctrl_cmd - DMA operations that can optionally be exercised
 * on a running channel.
 * @DMA_TERMINATE_ALL: terminate all ongoing transfers
 * @DMA_PAUSE: pause ongoing transfers
 * @DMA_RESUME: resume paused transfer
207 208 209 210 211
 * @DMA_SLAVE_CONFIG: this command is only implemented by DMA controllers
 * that need to runtime reconfigure the slave channels (as opposed to passing
 * configuration data in statically from the platform). An additional
 * argument of struct dma_slave_config must be passed in with this
 * command.
I
Ira Snyder 已提交
212 213
 * @FSLDMA_EXTERNAL_START: this command will put the Freescale DMA controller
 * into external start mode.
214 215 216 217 218
 */
enum dma_ctrl_cmd {
	DMA_TERMINATE_ALL,
	DMA_PAUSE,
	DMA_RESUME,
219
	DMA_SLAVE_CONFIG,
I
Ira Snyder 已提交
220
	FSLDMA_EXTERNAL_START,
221 222
};

D
Dan Williams 已提交
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
/**
 * enum sum_check_bits - bit position of pq_check_flags
 */
enum sum_check_bits {
	SUM_CHECK_P = 0,
	SUM_CHECK_Q = 1,
};

/**
 * enum pq_check_flags - result of async_{xor,pq}_zero_sum operations
 * @SUM_CHECK_P_RESULT - 1 if xor zero sum error, 0 otherwise
 * @SUM_CHECK_Q_RESULT - 1 if reed-solomon zero sum error, 0 otherwise
 */
enum sum_check_flags {
	SUM_CHECK_P_RESULT = (1 << SUM_CHECK_P),
	SUM_CHECK_Q_RESULT = (1 << SUM_CHECK_Q),
};


242 243 244 245 246 247
/**
 * dma_cap_mask_t - capabilities bitmap modeled after cpumask_t.
 * See linux/cpumask.h
 */
typedef struct { DECLARE_BITMAP(bits, DMA_TX_TYPE_END); } dma_cap_mask_t;

C
Chris Leech 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260 261
/**
 * struct dma_chan_percpu - the per-CPU part of struct dma_chan
 * @memcpy_count: transaction counter
 * @bytes_transferred: byte counter
 */

struct dma_chan_percpu {
	/* stats */
	unsigned long memcpy_count;
	unsigned long bytes_transferred;
};

/**
 * struct dma_chan - devices supply DMA channels, clients use them
262
 * @device: ptr to the dma device who supplies this channel, always !%NULL
C
Chris Leech 已提交
263
 * @cookie: last cookie value returned to client
264
 * @completed_cookie: last completed cookie for this channel
265
 * @chan_id: channel ID for sysfs
266
 * @dev: class device for sysfs
C
Chris Leech 已提交
267 268
 * @device_node: used to add this to the device chan list
 * @local: per-cpu pointer to a struct dma_chan_percpu
269
 * @client-count: how many clients are using this channel
270
 * @table_count: number of appearances in the mem-to-mem allocation table
271
 * @private: private data for certain client-channel associations
C
Chris Leech 已提交
272 273 274 275
 */
struct dma_chan {
	struct dma_device *device;
	dma_cookie_t cookie;
276
	dma_cookie_t completed_cookie;
C
Chris Leech 已提交
277 278 279

	/* sysfs */
	int chan_id;
280
	struct dma_chan_dev *dev;
C
Chris Leech 已提交
281 282

	struct list_head device_node;
283
	struct dma_chan_percpu __percpu *local;
284
	int client_count;
285
	int table_count;
286
	void *private;
C
Chris Leech 已提交
287 288
};

289 290 291 292
/**
 * struct dma_chan_dev - relate sysfs device node to backing channel device
 * @chan - driver channel device
 * @device - sysfs device
293 294
 * @dev_id - parent dma_device dev_id
 * @idr_ref - reference count to gate release of dma_device dev_id
295 296 297 298
 */
struct dma_chan_dev {
	struct dma_chan *chan;
	struct device device;
299 300
	int dev_id;
	atomic_t *idr_ref;
301 302
};

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
/**
 * enum dma_slave_buswidth - defines bus with of the DMA slave
 * device, source or target buses
 */
enum dma_slave_buswidth {
	DMA_SLAVE_BUSWIDTH_UNDEFINED = 0,
	DMA_SLAVE_BUSWIDTH_1_BYTE = 1,
	DMA_SLAVE_BUSWIDTH_2_BYTES = 2,
	DMA_SLAVE_BUSWIDTH_4_BYTES = 4,
	DMA_SLAVE_BUSWIDTH_8_BYTES = 8,
};

/**
 * struct dma_slave_config - dma slave channel runtime config
 * @direction: whether the data shall go in or out on this slave
 * channel, right now. DMA_TO_DEVICE and DMA_FROM_DEVICE are
 * legal values, DMA_BIDIRECTIONAL is not acceptable since we
 * need to differentiate source and target addresses.
 * @src_addr: this is the physical address where DMA slave data
 * should be read (RX), if the source is memory this argument is
 * ignored.
 * @dst_addr: this is the physical address where DMA slave data
 * should be written (TX), if the source is memory this argument
 * is ignored.
 * @src_addr_width: this is the width in bytes of the source (RX)
 * register where DMA data shall be read. If the source
 * is memory this may be ignored depending on architecture.
 * Legal values: 1, 2, 4, 8.
 * @dst_addr_width: same as src_addr_width but for destination
 * target (TX) mutatis mutandis.
 * @src_maxburst: the maximum number of words (note: words, as in
 * units of the src_addr_width member, not bytes) that can be sent
 * in one burst to the device. Typically something like half the
 * FIFO depth on I/O peripherals so you don't overflow it. This
 * may or may not be applicable on memory sources.
 * @dst_maxburst: same as src_maxburst but for destination target
 * mutatis mutandis.
340 341 342
 * @device_fc: Flow Controller Settings. Only valid for slave channels. Fill
 * with 'true' if peripheral should be flow controller. Direction will be
 * selected at Runtime.
343 344 345
 * @slave_id: Slave requester id. Only valid for slave channels. The dma
 * slave peripheral will have unique id as dma requester which need to be
 * pass as slave config.
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
 *
 * This struct is passed in as configuration data to a DMA engine
 * in order to set up a certain channel for DMA transport at runtime.
 * The DMA device/engine has to provide support for an additional
 * command in the channel config interface, DMA_SLAVE_CONFIG
 * and this struct will then be passed in as an argument to the
 * DMA engine device_control() function.
 *
 * The rationale for adding configuration information to this struct
 * is as follows: if it is likely that most DMA slave controllers in
 * the world will support the configuration option, then make it
 * generic. If not: if it is fixed so that it be sent in static from
 * the platform data, then prefer to do that. Else, if it is neither
 * fixed at runtime, nor generic enough (such as bus mastership on
 * some CPU family and whatnot) then create a custom slave config
 * struct and pass that, then make this config a member of that
 * struct, if applicable.
 */
struct dma_slave_config {
365
	enum dma_transfer_direction direction;
366 367 368 369 370 371
	dma_addr_t src_addr;
	dma_addr_t dst_addr;
	enum dma_slave_buswidth src_addr_width;
	enum dma_slave_buswidth dst_addr_width;
	u32 src_maxburst;
	u32 dst_maxburst;
372
	bool device_fc;
373
	unsigned int slave_id;
374 375
};

376 377 378 379
static inline const char *dma_chan_name(struct dma_chan *chan)
{
	return dev_name(&chan->dev->device);
}
380

C
Chris Leech 已提交
381 382
void dma_chan_cleanup(struct kref *kref);

383 384 385 386 387 388 389 390
/**
 * typedef dma_filter_fn - callback filter for dma_request_channel
 * @chan: channel to be reviewed
 * @filter_param: opaque parameter passed through dma_request_channel
 *
 * When this optional parameter is specified in a call to dma_request_channel a
 * suitable channel is passed to this routine for further dispositioning before
 * being returned.  Where 'suitable' indicates a non-busy channel that
391 392
 * satisfies the given capability mask.  It returns 'true' to indicate that the
 * channel is suitable.
393
 */
394
typedef bool (*dma_filter_fn)(struct dma_chan *chan, void *filter_param);
395

396 397 398 399 400 401
typedef void (*dma_async_tx_callback)(void *dma_async_param);
/**
 * struct dma_async_tx_descriptor - async transaction descriptor
 * ---dma generic offload fields---
 * @cookie: tracking cookie for this transaction, set to -EBUSY if
 *	this tx is sitting on a dependency list
402 403
 * @flags: flags to augment operation preparation, control completion, and
 * 	communicate status
404 405 406 407 408 409
 * @phys: physical address of the descriptor
 * @chan: target channel for this operation
 * @tx_submit: set the prepared descriptor(s) to be executed by the engine
 * @callback: routine to call after this operation is complete
 * @callback_param: general parameter to pass to the callback routine
 * ---async_tx api specific fields---
410
 * @next: at completion submit this descriptor
411
 * @parent: pointer to the next level up in the dependency chain
412
 * @lock: protect the parent and next pointers
413 414 415
 */
struct dma_async_tx_descriptor {
	dma_cookie_t cookie;
416
	enum dma_ctrl_flags flags; /* not a 'long' to pack with cookie */
417 418 419 420 421
	dma_addr_t phys;
	struct dma_chan *chan;
	dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *tx);
	dma_async_tx_callback callback;
	void *callback_param;
422
#ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
423
	struct dma_async_tx_descriptor *next;
424 425
	struct dma_async_tx_descriptor *parent;
	spinlock_t lock;
426
#endif
427 428
};

429
#ifndef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
static inline void txd_lock(struct dma_async_tx_descriptor *txd)
{
}
static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
{
}
static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
{
	BUG();
}
static inline void txd_clear_parent(struct dma_async_tx_descriptor *txd)
{
}
static inline void txd_clear_next(struct dma_async_tx_descriptor *txd)
{
}
static inline struct dma_async_tx_descriptor *txd_next(struct dma_async_tx_descriptor *txd)
{
	return NULL;
}
static inline struct dma_async_tx_descriptor *txd_parent(struct dma_async_tx_descriptor *txd)
{
	return NULL;
}

#else
static inline void txd_lock(struct dma_async_tx_descriptor *txd)
{
	spin_lock_bh(&txd->lock);
}
static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
{
	spin_unlock_bh(&txd->lock);
}
static inline void txd_chain(struct dma_async_tx_descriptor *txd, struct dma_async_tx_descriptor *next)
{
	txd->next = next;
	next->parent = txd;
}
static inline void txd_clear_parent(struct dma_async_tx_descriptor *txd)
{
	txd->parent = NULL;
}
static inline void txd_clear_next(struct dma_async_tx_descriptor *txd)
{
	txd->next = NULL;
}
static inline struct dma_async_tx_descriptor *txd_parent(struct dma_async_tx_descriptor *txd)
{
	return txd->parent;
}
static inline struct dma_async_tx_descriptor *txd_next(struct dma_async_tx_descriptor *txd)
{
	return txd->next;
}
#endif

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
/**
 * struct dma_tx_state - filled in to report the status of
 * a transfer.
 * @last: last completed DMA cookie
 * @used: last issued DMA cookie (i.e. the one in progress)
 * @residue: the remaining number of bytes left to transmit
 *	on the selected transfer for states DMA_IN_PROGRESS and
 *	DMA_PAUSED if this is implemented in the driver, else 0
 */
struct dma_tx_state {
	dma_cookie_t last;
	dma_cookie_t used;
	u32 residue;
};

C
Chris Leech 已提交
502 503 504
/**
 * struct dma_device - info on the entity supplying DMA services
 * @chancnt: how many DMA channels are supported
505
 * @privatecnt: how many DMA channels are requested by dma_request_channel
C
Chris Leech 已提交
506 507
 * @channels: the list of struct dma_chan
 * @global_node: list_head for global dma_device_list
508 509
 * @cap_mask: one or more dma_capability flags
 * @max_xor: maximum number of xor sources, 0 if no capability
510
 * @max_pq: maximum number of PQ sources and PQ-continue capability
511 512 513 514
 * @copy_align: alignment shift for memcpy operations
 * @xor_align: alignment shift for xor operations
 * @pq_align: alignment shift for pq operations
 * @fill_align: alignment shift for memset operations
515
 * @dev_id: unique device ID
516
 * @dev: struct device reference for dma mapping api
517 518 519
 * @device_alloc_chan_resources: allocate resources and return the
 *	number of allocated descriptors
 * @device_free_chan_resources: release DMA channel's resources
520 521
 * @device_prep_dma_memcpy: prepares a memcpy operation
 * @device_prep_dma_xor: prepares a xor operation
D
Dan Williams 已提交
522
 * @device_prep_dma_xor_val: prepares a xor validation operation
523 524
 * @device_prep_dma_pq: prepares a pq operation
 * @device_prep_dma_pq_val: prepares a pqzero_sum operation
525
 * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
526
 * @device_prep_slave_sg: prepares a slave dma operation
527 528 529
 * @device_prep_dma_cyclic: prepare a cyclic dma operation suitable for audio.
 *	The function takes a buffer of size buf_len. The callback function will
 *	be called after period_len bytes have been transferred.
530
 * @device_prep_interleaved_dma: Transfer expression in a generic way.
531 532
 * @device_control: manipulate all pending operations on a channel, returns
 *	zero or error code
533 534
 * @device_tx_status: poll for transaction completion, the optional
 *	txstate parameter can be supplied with a pointer to get a
L
Lucas De Marchi 已提交
535
 *	struct with auxiliary transfer status information, otherwise the call
536
 *	will just return a simple status code
537
 * @device_issue_pending: push pending transactions to hardware
C
Chris Leech 已提交
538 539 540 541
 */
struct dma_device {

	unsigned int chancnt;
542
	unsigned int privatecnt;
C
Chris Leech 已提交
543 544
	struct list_head channels;
	struct list_head global_node;
545
	dma_cap_mask_t  cap_mask;
546 547
	unsigned short max_xor;
	unsigned short max_pq;
548 549 550 551
	u8 copy_align;
	u8 xor_align;
	u8 pq_align;
	u8 fill_align;
552
	#define DMA_HAS_PQ_CONTINUE (1 << 15)
C
Chris Leech 已提交
553 554

	int dev_id;
555
	struct device *dev;
C
Chris Leech 已提交
556

557
	int (*device_alloc_chan_resources)(struct dma_chan *chan);
C
Chris Leech 已提交
558
	void (*device_free_chan_resources)(struct dma_chan *chan);
559 560

	struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(
561
		struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
562
		size_t len, unsigned long flags);
563
	struct dma_async_tx_descriptor *(*device_prep_dma_xor)(
564
		struct dma_chan *chan, dma_addr_t dest, dma_addr_t *src,
565
		unsigned int src_cnt, size_t len, unsigned long flags);
D
Dan Williams 已提交
566
	struct dma_async_tx_descriptor *(*device_prep_dma_xor_val)(
567
		struct dma_chan *chan, dma_addr_t *src,	unsigned int src_cnt,
D
Dan Williams 已提交
568
		size_t len, enum sum_check_flags *result, unsigned long flags);
569 570 571 572 573 574 575 576
	struct dma_async_tx_descriptor *(*device_prep_dma_pq)(
		struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,
		unsigned int src_cnt, const unsigned char *scf,
		size_t len, unsigned long flags);
	struct dma_async_tx_descriptor *(*device_prep_dma_pq_val)(
		struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
		unsigned int src_cnt, const unsigned char *scf, size_t len,
		enum sum_check_flags *pqres, unsigned long flags);
577
	struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
578
		struct dma_chan *chan, unsigned long flags);
579 580 581 582 583
	struct dma_async_tx_descriptor *(*device_prep_dma_sg)(
		struct dma_chan *chan,
		struct scatterlist *dst_sg, unsigned int dst_nents,
		struct scatterlist *src_sg, unsigned int src_nents,
		unsigned long flags);
584

585 586
	struct dma_async_tx_descriptor *(*device_prep_slave_sg)(
		struct dma_chan *chan, struct scatterlist *sgl,
587
		unsigned int sg_len, enum dma_transfer_direction direction,
588
		unsigned long flags, void *context);
589 590
	struct dma_async_tx_descriptor *(*device_prep_dma_cyclic)(
		struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
591
		size_t period_len, enum dma_transfer_direction direction,
592
		unsigned long flags, void *context);
593 594 595
	struct dma_async_tx_descriptor *(*device_prep_interleaved_dma)(
		struct dma_chan *chan, struct dma_interleaved_template *xt,
		unsigned long flags);
596 597
	int (*device_control)(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
		unsigned long arg);
598

599 600 601
	enum dma_status (*device_tx_status)(struct dma_chan *chan,
					    dma_cookie_t cookie,
					    struct dma_tx_state *txstate);
602
	void (*device_issue_pending)(struct dma_chan *chan);
C
Chris Leech 已提交
603 604
};

605 606 607 608
static inline int dmaengine_device_control(struct dma_chan *chan,
					   enum dma_ctrl_cmd cmd,
					   unsigned long arg)
{
609 610
	if (chan->device->device_control)
		return chan->device->device_control(chan, cmd, arg);
611 612

	return -ENOSYS;
613 614 615 616 617 618 619 620 621
}

static inline int dmaengine_slave_config(struct dma_chan *chan,
					  struct dma_slave_config *config)
{
	return dmaengine_device_control(chan, DMA_SLAVE_CONFIG,
			(unsigned long)config);
}

622 623 624 625 626
static inline bool is_slave_direction(enum dma_transfer_direction direction)
{
	return (direction == DMA_MEM_TO_DEV) || (direction == DMA_DEV_TO_MEM);
}

627
static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
628
	struct dma_chan *chan, dma_addr_t buf, size_t len,
629
	enum dma_transfer_direction dir, unsigned long flags)
630 631
{
	struct scatterlist sg;
632 633 634
	sg_init_table(&sg, 1);
	sg_dma_address(&sg) = buf;
	sg_dma_len(&sg) = len;
635

636 637
	return chan->device->device_prep_slave_sg(chan, &sg, 1,
						  dir, flags, NULL);
638 639
}

640 641 642 643 644
static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(
	struct dma_chan *chan, struct scatterlist *sgl,	unsigned int sg_len,
	enum dma_transfer_direction dir, unsigned long flags)
{
	return chan->device->device_prep_slave_sg(chan, sgl, sg_len,
645
						  dir, flags, NULL);
646 647
}

648 649 650 651 652 653 654 655 656 657 658 659
#ifdef CONFIG_RAPIDIO_DMA_ENGINE
struct rio_dma_ext;
static inline struct dma_async_tx_descriptor *dmaengine_prep_rio_sg(
	struct dma_chan *chan, struct scatterlist *sgl,	unsigned int sg_len,
	enum dma_transfer_direction dir, unsigned long flags,
	struct rio_dma_ext *rio_ext)
{
	return chan->device->device_prep_slave_sg(chan, sgl, sg_len,
						  dir, flags, rio_ext);
}
#endif

660 661
static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(
		struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
662 663
		size_t period_len, enum dma_transfer_direction dir,
		unsigned long flags)
664 665
{
	return chan->device->device_prep_dma_cyclic(chan, buf_addr, buf_len,
666
						period_len, dir, flags, NULL);
667 668 669 670 671 672 673
}

static inline struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(
		struct dma_chan *chan, struct dma_interleaved_template *xt,
		unsigned long flags)
{
	return chan->device->device_prep_interleaved_dma(chan, xt, flags);
674 675
}

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
static inline int dmaengine_terminate_all(struct dma_chan *chan)
{
	return dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
}

static inline int dmaengine_pause(struct dma_chan *chan)
{
	return dmaengine_device_control(chan, DMA_PAUSE, 0);
}

static inline int dmaengine_resume(struct dma_chan *chan)
{
	return dmaengine_device_control(chan, DMA_RESUME, 0);
}

691 692 693 694 695 696
static inline enum dma_status dmaengine_tx_status(struct dma_chan *chan,
	dma_cookie_t cookie, struct dma_tx_state *state)
{
	return chan->device->device_tx_status(chan, cookie, state);
}

697
static inline dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)
698 699 700 701
{
	return desc->tx_submit(desc);
}

702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
static inline bool dmaengine_check_align(u8 align, size_t off1, size_t off2, size_t len)
{
	size_t mask;

	if (!align)
		return true;
	mask = (1 << align) - 1;
	if (mask & (off1 | off2 | len))
		return false;
	return true;
}

static inline bool is_dma_copy_aligned(struct dma_device *dev, size_t off1,
				       size_t off2, size_t len)
{
	return dmaengine_check_align(dev->copy_align, off1, off2, len);
}

static inline bool is_dma_xor_aligned(struct dma_device *dev, size_t off1,
				      size_t off2, size_t len)
{
	return dmaengine_check_align(dev->xor_align, off1, off2, len);
}

static inline bool is_dma_pq_aligned(struct dma_device *dev, size_t off1,
				     size_t off2, size_t len)
{
	return dmaengine_check_align(dev->pq_align, off1, off2, len);
}

static inline bool is_dma_fill_aligned(struct dma_device *dev, size_t off1,
				       size_t off2, size_t len)
{
	return dmaengine_check_align(dev->fill_align, off1, off2, len);
}

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
static inline void
dma_set_maxpq(struct dma_device *dma, int maxpq, int has_pq_continue)
{
	dma->max_pq = maxpq;
	if (has_pq_continue)
		dma->max_pq |= DMA_HAS_PQ_CONTINUE;
}

static inline bool dmaf_continue(enum dma_ctrl_flags flags)
{
	return (flags & DMA_PREP_CONTINUE) == DMA_PREP_CONTINUE;
}

static inline bool dmaf_p_disabled_continue(enum dma_ctrl_flags flags)
{
	enum dma_ctrl_flags mask = DMA_PREP_CONTINUE | DMA_PREP_PQ_DISABLE_P;

	return (flags & mask) == mask;
}

static inline bool dma_dev_has_pq_continue(struct dma_device *dma)
{
	return (dma->max_pq & DMA_HAS_PQ_CONTINUE) == DMA_HAS_PQ_CONTINUE;
}

763
static inline unsigned short dma_dev_to_maxpq(struct dma_device *dma)
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
{
	return dma->max_pq & ~DMA_HAS_PQ_CONTINUE;
}

/* dma_maxpq - reduce maxpq in the face of continued operations
 * @dma - dma device with PQ capability
 * @flags - to check if DMA_PREP_CONTINUE and DMA_PREP_PQ_DISABLE_P are set
 *
 * When an engine does not support native continuation we need 3 extra
 * source slots to reuse P and Q with the following coefficients:
 * 1/ {00} * P : remove P from Q', but use it as a source for P'
 * 2/ {01} * Q : use Q to continue Q' calculation
 * 3/ {00} * Q : subtract Q from P' to cancel (2)
 *
 * In the case where P is disabled we only need 1 extra source:
 * 1/ {01} * Q : use Q to continue Q' calculation
 */
static inline int dma_maxpq(struct dma_device *dma, enum dma_ctrl_flags flags)
{
	if (dma_dev_has_pq_continue(dma) || !dmaf_continue(flags))
		return dma_dev_to_maxpq(dma);
	else if (dmaf_p_disabled_continue(flags))
		return dma_dev_to_maxpq(dma) - 1;
	else if (dmaf_continue(flags))
		return dma_dev_to_maxpq(dma) - 3;
	BUG();
}

C
Chris Leech 已提交
792 793
/* --- public DMA engine API --- */

794
#ifdef CONFIG_DMA_ENGINE
795 796
void dmaengine_get(void);
void dmaengine_put(void);
797 798 799 800 801 802 803 804 805
#else
static inline void dmaengine_get(void)
{
}
static inline void dmaengine_put(void)
{
}
#endif

806 807 808 809 810 811 812 813 814 815 816 817
#ifdef CONFIG_NET_DMA
#define net_dmaengine_get()	dmaengine_get()
#define net_dmaengine_put()	dmaengine_put()
#else
static inline void net_dmaengine_get(void)
{
}
static inline void net_dmaengine_put(void)
{
}
#endif

818 819 820
#ifdef CONFIG_ASYNC_TX_DMA
#define async_dmaengine_get()	dmaengine_get()
#define async_dmaengine_put()	dmaengine_put()
821
#ifndef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
822 823
#define async_dma_find_channel(type) dma_find_channel(DMA_ASYNC_TX)
#else
824
#define async_dma_find_channel(type) dma_find_channel(type)
825
#endif /* CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH */
826 827 828 829 830 831 832 833 834 835 836 837
#else
static inline void async_dmaengine_get(void)
{
}
static inline void async_dmaengine_put(void)
{
}
static inline struct dma_chan *
async_dma_find_channel(enum dma_transaction_type type)
{
	return NULL;
}
838
#endif /* CONFIG_ASYNC_TX_DMA */
839

840 841 842 843 844 845 846 847 848
dma_cookie_t dma_async_memcpy_buf_to_buf(struct dma_chan *chan,
	void *dest, void *src, size_t len);
dma_cookie_t dma_async_memcpy_buf_to_pg(struct dma_chan *chan,
	struct page *page, unsigned int offset, void *kdata, size_t len);
dma_cookie_t dma_async_memcpy_pg_to_pg(struct dma_chan *chan,
	struct page *dest_pg, unsigned int dest_off, struct page *src_pg,
	unsigned int src_off, size_t len);
void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
	struct dma_chan *chan);
C
Chris Leech 已提交
849

850
static inline void async_tx_ack(struct dma_async_tx_descriptor *tx)
851
{
852 853 854
	tx->flags |= DMA_CTRL_ACK;
}

855 856 857 858 859
static inline void async_tx_clear_ack(struct dma_async_tx_descriptor *tx)
{
	tx->flags &= ~DMA_CTRL_ACK;
}

860
static inline bool async_tx_test_ack(struct dma_async_tx_descriptor *tx)
861
{
862
	return (tx->flags & DMA_CTRL_ACK) == DMA_CTRL_ACK;
C
Chris Leech 已提交
863 864
}

865 866 867
#define dma_cap_set(tx, mask) __dma_cap_set((tx), &(mask))
static inline void
__dma_cap_set(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
C
Chris Leech 已提交
868
{
869 870
	set_bit(tx_type, dstp->bits);
}
C
Chris Leech 已提交
871

872 873 874 875 876 877 878
#define dma_cap_clear(tx, mask) __dma_cap_clear((tx), &(mask))
static inline void
__dma_cap_clear(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
{
	clear_bit(tx_type, dstp->bits);
}

879 880 881 882 883 884
#define dma_cap_zero(mask) __dma_cap_zero(&(mask))
static inline void __dma_cap_zero(dma_cap_mask_t *dstp)
{
	bitmap_zero(dstp->bits, DMA_TX_TYPE_END);
}

885 886 887 888 889
#define dma_has_cap(tx, mask) __dma_has_cap((tx), &(mask))
static inline int
__dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
{
	return test_bit(tx_type, srcp->bits);
C
Chris Leech 已提交
890 891
}

892
#define for_each_dma_cap_mask(cap, mask) \
A
Akinobu Mita 已提交
893
	for_each_set_bit(cap, mask.bits, DMA_TX_TYPE_END)
894

C
Chris Leech 已提交
895
/**
896
 * dma_async_issue_pending - flush pending transactions to HW
897
 * @chan: target DMA channel
C
Chris Leech 已提交
898 899 900 901
 *
 * This allows drivers to push copies to HW in batches,
 * reducing MMIO writes where possible.
 */
902
static inline void dma_async_issue_pending(struct dma_chan *chan)
C
Chris Leech 已提交
903
{
D
Dan Williams 已提交
904
	chan->device->device_issue_pending(chan);
C
Chris Leech 已提交
905 906 907
}

/**
908
 * dma_async_is_tx_complete - poll for transaction completion
C
Chris Leech 已提交
909 910 911 912 913 914 915 916 917
 * @chan: DMA channel
 * @cookie: transaction identifier to check status of
 * @last: returns last completed cookie, can be NULL
 * @used: returns last issued cookie, can be NULL
 *
 * If @last and @used are passed in, upon return they reflect the driver
 * internal state and can be used with dma_async_is_complete() to check
 * the status of multiple cookies without re-checking hardware state.
 */
918
static inline enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
C
Chris Leech 已提交
919 920
	dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
{
921 922 923 924 925 926 927 928 929
	struct dma_tx_state state;
	enum dma_status status;

	status = chan->device->device_tx_status(chan, cookie, &state);
	if (last)
		*last = state.last;
	if (used)
		*used = state.used;
	return status;
C
Chris Leech 已提交
930 931 932 933 934 935 936 937
}

/**
 * dma_async_is_complete - test a cookie against chan state
 * @cookie: transaction identifier to test status of
 * @last_complete: last know completed transaction
 * @last_used: last cookie value handed out
 *
938
 * dma_async_is_complete() is used in dma_async_is_tx_complete()
S
Sebastian Siewior 已提交
939
 * the test logic is separated for lightweight testing of multiple cookies
C
Chris Leech 已提交
940 941 942 943 944 945 946 947 948 949 950 951 952 953
 */
static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
			dma_cookie_t last_complete, dma_cookie_t last_used)
{
	if (last_complete <= last_used) {
		if ((cookie <= last_complete) || (cookie > last_used))
			return DMA_SUCCESS;
	} else {
		if ((cookie <= last_complete) && (cookie > last_used))
			return DMA_SUCCESS;
	}
	return DMA_IN_PROGRESS;
}

954 955 956 957 958 959 960 961 962 963
static inline void
dma_set_tx_state(struct dma_tx_state *st, dma_cookie_t last, dma_cookie_t used, u32 residue)
{
	if (st) {
		st->last = last;
		st->used = used;
		st->residue = residue;
	}
}

964
enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie);
965 966
#ifdef CONFIG_DMA_ENGINE
enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
967
void dma_issue_pending_all(void);
968 969
struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
					dma_filter_fn fn, void *fn_param);
M
Markus Pargmann 已提交
970
struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name);
971
void dma_release_channel(struct dma_chan *chan);
972 973 974 975 976
#else
static inline enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
{
	return DMA_SUCCESS;
}
977 978
static inline void dma_issue_pending_all(void)
{
979
}
980
static inline struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
981 982 983 984
					      dma_filter_fn fn, void *fn_param)
{
	return NULL;
}
985
static inline struct dma_chan *dma_request_slave_channel(struct device *dev,
M
Markus Pargmann 已提交
986
							 const char *name)
987
{
988
	return NULL;
989
}
990 991
static inline void dma_release_channel(struct dma_chan *chan)
{
992
}
993
#endif
C
Chris Leech 已提交
994 995 996 997 998

/* --- DMA device --- */

int dma_async_device_register(struct dma_device *device);
void dma_async_device_unregister(struct dma_device *device);
999
void dma_run_dependencies(struct dma_async_tx_descriptor *tx);
1000
struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type);
1001
struct dma_chan *net_dma_find_channel(void);
1002
#define dma_request_channel(mask, x, y) __dma_request_channel(&(mask), x, y)
1003 1004 1005 1006
#define dma_request_slave_channel_compat(mask, x, y, dev, name) \
	__dma_request_slave_channel_compat(&(mask), x, y, dev, name)

static inline struct dma_chan
1007 1008 1009
*__dma_request_slave_channel_compat(const dma_cap_mask_t *mask,
				  dma_filter_fn fn, void *fn_param,
				  struct device *dev, char *name)
1010 1011 1012 1013 1014 1015 1016 1017 1018
{
	struct dma_chan *chan;

	chan = dma_request_slave_channel(dev, name);
	if (chan)
		return chan;

	return __dma_request_channel(mask, fn, fn_param);
}
C
Chris Leech 已提交
1019

1020 1021 1022
/* --- Helper iov-locking functions --- */

struct dma_page_list {
1023
	char __user *base_address;
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
	int nr_pages;
	struct page **pages;
};

struct dma_pinned_list {
	int nr_iovecs;
	struct dma_page_list page_list[0];
};

struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len);
void dma_unpin_iovec_pages(struct dma_pinned_list* pinned_list);

dma_cookie_t dma_memcpy_to_iovec(struct dma_chan *chan, struct iovec *iov,
	struct dma_pinned_list *pinned_list, unsigned char *kdata, size_t len);
dma_cookie_t dma_memcpy_pg_to_iovec(struct dma_chan *chan, struct iovec *iov,
	struct dma_pinned_list *pinned_list, struct page *page,
	unsigned int offset, size_t len);

C
Chris Leech 已提交
1042
#endif /* DMAENGINE_H */