[net-next-2.6.git] / arch / powerpc / include / asm / fsldma.h

/*
 * Freescale MPC83XX / MPC85XX DMA Controller
 *
 * Copyright (c) 2009 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */

#ifndef __ARCH_POWERPC_ASM_FSLDMA_H__
#define __ARCH_POWERPC_ASM_FSLDMA_H__

#include <linux/slab.h>
#include <linux/dmaengine.h>

/*
 * Definitions for the Freescale DMA controller's DMA_SLAVE implemention
 *
 * The Freescale DMA_SLAVE implementation was designed to handle many-to-many
 * transfers. An example usage would be an accelerated copy between two
 * scatterlists. Another example use would be an accelerated copy from
 * multiple non-contiguous device buffers into a single scatterlist.
 *
 * A DMA_SLAVE transaction is defined by a struct fsl_dma_slave. This
 * structure contains a list of hardware addresses that should be copied
 * to/from the scatterlist passed into device_prep_slave_sg(). The structure
 * also has some fields to enable hardware-specific features.
 */

/**
 * struct fsl_dma_hw_addr
 * @entry: linked list entry
 * @address: the hardware address
 * @length: length to transfer
 *
 * Holds a single physical hardware address / length pair for use
 * with the DMAEngine DMA_SLAVE API.
 */
struct fsl_dma_hw_addr {
	struct list_head entry;

	dma_addr_t address;
	size_t length;
};

/**
 * struct fsl_dma_slave
 * @addresses: a linked list of struct fsl_dma_hw_addr structures
 * @request_count: value for DMA request count
 * @src_loop_size: setup and enable constant source-address DMA transfers
 * @dst_loop_size: setup and enable constant destination address DMA transfers
 * @external_start: enable externally started DMA transfers
 * @external_pause: enable externally paused DMA transfers
 *
 * Holds a list of address / length pairs for use with the DMAEngine
 * DMA_SLAVE API implementation for the Freescale DMA controller.
 */
struct fsl_dma_slave {

	/* List of hardware address/length pairs */
	struct list_head addresses;

	/* Support for extra controller features */
	unsigned int request_count;
	unsigned int src_loop_size;
	unsigned int dst_loop_size;
	bool external_start;
	bool external_pause;
};

/**
 * fsl_dma_slave_append - add an address/length pair to a struct fsl_dma_slave
 * @slave: the &struct fsl_dma_slave to add to
 * @address: the hardware address to add
 * @length: the length of bytes to transfer from @address
 *
 * Add a hardware address/length pair to a struct fsl_dma_slave. Returns 0 on
 * success, -ERRNO otherwise.
 */
static inline int fsl_dma_slave_append(struct fsl_dma_slave *slave,
				       dma_addr_t address, size_t length)
{
	struct fsl_dma_hw_addr *addr;

	addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
	if (!addr)
		return -ENOMEM;

	INIT_LIST_HEAD(&addr->entry);
	addr->address = address;
	addr->length = length;

	list_add_tail(&addr->entry, &slave->addresses);
	return 0;
}

/**
 * fsl_dma_slave_free - free a struct fsl_dma_slave
 * @slave: the struct fsl_dma_slave to free
 *
 * Free a struct fsl_dma_slave and all associated address/length pairs
 */
static inline void fsl_dma_slave_free(struct fsl_dma_slave *slave)
{
	struct fsl_dma_hw_addr *addr, *tmp;

	if (slave) {
		list_for_each_entry_safe(addr, tmp, &slave->addresses, entry) {
			list_del(&addr->entry);
			kfree(addr);
		}

		kfree(slave);
	}
}

/**
 * fsl_dma_slave_alloc - allocate a struct fsl_dma_slave
 * @gfp: the flags to pass to kmalloc when allocating this structure
 *
 * Allocate a struct fsl_dma_slave for use by the DMA_SLAVE API. Returns a new
 * struct fsl_dma_slave on success, or NULL on failure.
 */
static inline struct fsl_dma_slave *fsl_dma_slave_alloc(gfp_t gfp)
{
	struct fsl_dma_slave *slave;

	slave = kzalloc(sizeof(*slave), gfp);
	if (!slave)
		return NULL;

	INIT_LIST_HEAD(&slave->addresses);
	return slave;
}

#endif /* __ARCH_POWERPC_ASM_FSLDMA_H__ */
Commit	Line	Data
bbea0b6e IS	1	/*
	2	* Freescale MPC83XX / MPC85XX DMA Controller
	3	*
	4	* Copyright (c) 2009 Ira W. Snyder <iws@ovro.caltech.edu>
	5	*
	6	* This file is licensed under the terms of the GNU General Public License
	7	* version 2. This program is licensed "as is" without any warranty of any
	8	* kind, whether express or implied.
	9	*/
	10
	11	#ifndef __ARCH_POWERPC_ASM_FSLDMA_H__
	12	#define __ARCH_POWERPC_ASM_FSLDMA_H__
	13
94131e17	14	#include <linux/slab.h>
bbea0b6e IS	15	#include <linux/dmaengine.h>
	16
	17	/*
	18	* Definitions for the Freescale DMA controller's DMA_SLAVE implemention
	19	*
	20	* The Freescale DMA_SLAVE implementation was designed to handle many-to-many
	21	* transfers. An example usage would be an accelerated copy between two
	22	* scatterlists. Another example use would be an accelerated copy from
	23	* multiple non-contiguous device buffers into a single scatterlist.
	24	*
	25	* A DMA_SLAVE transaction is defined by a struct fsl_dma_slave. This
	26	* structure contains a list of hardware addresses that should be copied
	27	* to/from the scatterlist passed into device_prep_slave_sg(). The structure
	28	* also has some fields to enable hardware-specific features.
	29	*/
	30
	31	/**
	32	* struct fsl_dma_hw_addr
	33	* @entry: linked list entry
	34	* @address: the hardware address
	35	* @length: length to transfer
	36	*
	37	* Holds a single physical hardware address / length pair for use
	38	* with the DMAEngine DMA_SLAVE API.
	39	*/
	40	struct fsl_dma_hw_addr {
	41	struct list_head entry;
	42
	43	dma_addr_t address;
	44	size_t length;
	45	};
	46
	47	/**
	48	* struct fsl_dma_slave
	49	* @addresses: a linked list of struct fsl_dma_hw_addr structures
	50	* @request_count: value for DMA request count
	51	* @src_loop_size: setup and enable constant source-address DMA transfers
	52	* @dst_loop_size: setup and enable constant destination address DMA transfers
	53	* @external_start: enable externally started DMA transfers
	54	* @external_pause: enable externally paused DMA transfers
	55	*
	56	* Holds a list of address / length pairs for use with the DMAEngine
	57	* DMA_SLAVE API implementation for the Freescale DMA controller.
	58	*/
	59	struct fsl_dma_slave {
	60
	61	/* List of hardware address/length pairs */
	62	struct list_head addresses;
	63
	64	/* Support for extra controller features */
	65	unsigned int request_count;
	66	unsigned int src_loop_size;
	67	unsigned int dst_loop_size;
	68	bool external_start;
	69	bool external_pause;
	70	};
	71
	72	/**
	73	* fsl_dma_slave_append - add an address/length pair to a struct fsl_dma_slave
	74	* @slave: the &struct fsl_dma_slave to add to
	75	* @address: the hardware address to add
	76	* @length: the length of bytes to transfer from @address
	77	*
	78	* Add a hardware address/length pair to a struct fsl_dma_slave. Returns 0 on
79	* success, -ERRNO otherwise.
80	*/
81	static inline int fsl_dma_slave_append(struct fsl_dma_slave *slave,
82	dma_addr_t address, size_t length)
83	{
84	struct fsl_dma_hw_addr *addr;
85
86	addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
87	if (!addr)
88	return -ENOMEM;
89
90	INIT_LIST_HEAD(&addr->entry);
91	addr->address = address;
92	addr->length = length;
93
94	list_add_tail(&addr->entry, &slave->addresses);
95	return 0;
96	}
97
98	/**
99	* fsl_dma_slave_free - free a struct fsl_dma_slave
100	* @slave: the struct fsl_dma_slave to free
101	*
102	* Free a struct fsl_dma_slave and all associated address/length pairs
103	*/
104	static inline void fsl_dma_slave_free(struct fsl_dma_slave *slave)
105	{
106	struct fsl_dma_hw_addr addr, tmp;
107
108	if (slave) {
109	list_for_each_entry_safe(addr, tmp, &slave->addresses, entry) {
110	list_del(&addr->entry);
111	kfree(addr);
112	}
113
114	kfree(slave);
115	}
116	}
117
118	/**
119	* fsl_dma_slave_alloc - allocate a struct fsl_dma_slave
120	* @gfp: the flags to pass to kmalloc when allocating this structure
121	*
122	* Allocate a struct fsl_dma_slave for use by the DMA_SLAVE API. Returns a new
123	* struct fsl_dma_slave on success, or NULL on failure.
124	*/
125	static inline struct fsl_dma_slave *fsl_dma_slave_alloc(gfp_t gfp)
126	{
127	struct fsl_dma_slave *slave;
128
129	slave = kzalloc(sizeof(*slave), gfp);
130	if (!slave)
131	return NULL;
132
133	INIT_LIST_HEAD(&slave->addresses);
134	return slave;
135	}
136
137	#endif /* __ARCH_POWERPC_ASM_FSLDMA_H__ */