4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
34 #include <sys/types.h>
37 * *** This interface is for private use by the IP stack only ***
40 /* Private dcopy/uioa interface for dcopy to enable/disable dcopy KAPI */
41 extern void uioa_dcopy_enable();
42 extern void uioa_dcopy_disable();
44 /* Function return status */
45 #define DCOPY_FAILURE (-1)
46 #define DCOPY_SUCCESS (0)
47 #define DCOPY_NORESOURCES (1) /* _alloc & _cmd_alloc, _cmd_post only */
48 #define DCOPY_PENDING (0x10) /* dcopy_poll(), dcopy_unregister() */
49 #define DCOPY_COMPLETED (0x20) /* dcopy_poll() only */
53 #define DCOPY_QUERY_V0 0
55 typedef struct dcopy_query_s
{
56 int dq_version
; /* DCOPY_QUERY_V0 */
57 uint_t dq_num_channels
; /* number of dma channels */
62 * query for the number of DMA engines usable in the system.
64 void dcopy_query(dcopy_query_t
*query
);
67 typedef struct dcopy_channel_s
*dcopy_handle_t
;
69 /* dcopy_alloc() and dcopy_cmd_alloc() common flags */
70 #define DCOPY_SLEEP (0)
71 #define DCOPY_NOSLEEP (1 << 0)
75 * Allocate a DMA channel which is used for posting DMA requests. Note: this
76 * does not give the caller exclusive access to the DMA engine. Commands
77 * posted to a channel will complete in order.
78 * flags - (DCOPY_SLEEP, DCOPY_NOSLEEP)
79 * returns => DCOPY_FAILURE, DCOPY_SUCCESS, DCOPY_NORESOURCES
81 int dcopy_alloc(int flags
, dcopy_handle_t
*handle
);
85 * Free the DMA channel. The client can no longer use the handle to post or
86 * poll for status on posts which were previously done on this channel.
88 void dcopy_free(dcopy_handle_t
*handle
);
91 #define DCOPY_QUERY_CHANNEL_V0 0
93 /* Per DMA channel info */
94 typedef struct dcopy_query_channel_s
{
95 int qc_version
; /* DCOPY_QUERY_CHANNEL_V0 */
97 /* Does DMA channel support DCA */
98 boolean_t qc_dca_supported
;
100 /* device id and device specific capabilities */
102 uint64_t qc_capabilities
;
105 * DMA channel size. This may not be the same as the number of posts
106 * that the DMA channel can handle since a post may consume 1 or more
109 uint64_t qc_channel_size
;
111 /* DMA channel number within the device. Not unique across devices */
112 uint64_t qc_chan_num
;
113 } dcopy_query_channel_t
;
116 * dcopy_query_channel()
117 * query DMA engines capabilities
119 void dcopy_query_channel(dcopy_handle_t handle
, dcopy_query_channel_t
*query
);
123 #define DCOPY_CMD_V0 0
126 #define DCOPY_CMD_COPY 0x1
131 * Hint to queue up the post but don't notify the DMA engine. This can be
132 * used as an optimization when multiple posts are going to be queued up and
133 * you only want notify the DMA engine after the last post. Note, this does
134 * not mean the DMA engine won't process the request since it could notice
137 * Don't generate a status. If this flag is used, You cannot poll for
138 * completion status on this command. This can be a useful performance
139 * optimization if your posting multiple commands and just want to poll on
142 * If DCA is supported, direct this and all future command data (until the
143 * next command with DCOPY_POST_DCA set) to the processor specified in
144 * dp_dca_id. This flag is ignored if DCA is not supported.
146 * Generate an interrupt when command completes. This flag is required if
147 * the caller is going to call dcopy_cmd_poll(() with DCOPY_POLL_BLOCK set
150 * Return error instead of busy waiting if resource is not available.
152 * Disable source cache snooping.
154 * Disable destination cache snooping.
156 * For CBv1, generate a loop descriptor list, used to support FIPE driver.
158 * Reserved for internal use.
160 #define DCOPY_CMD_NOFLAGS (0)
161 #define DCOPY_CMD_QUEUE (1 << 0)
162 #define DCOPY_CMD_NOSTAT (1 << 1)
163 #define DCOPY_CMD_DCA (1 << 2)
164 #define DCOPY_CMD_INTR (1 << 3)
165 #define DCOPY_CMD_NOWAIT (1 << 4)
166 #define DCOPY_CMD_NOSRCSNP (1 << 5)
167 #define DCOPY_CMD_NODSTSNP (1 << 6)
168 #define DCOPY_CMD_LOOP (1 << 7)
169 #define DCOPY_CMD_SYNC (1 << 30)
171 typedef struct dcopy_cmd_copy_s
{
172 uint64_t cc_source
; /* Source physical address */
173 uint64_t cc_dest
; /* Destination physical address */
177 typedef union dcopy_cmd_u
{
178 dcopy_cmd_copy_t copy
;
181 typedef struct dcopy_cmd_priv_s
*dcopy_cmd_priv_t
;
184 uint_t dp_version
; /* DCOPY_CMD_V0 */
189 dcopy_cmd_priv_t dp_private
;
191 typedef struct dcopy_cmd_s
*dcopy_cmd_t
;
195 * dcopy_cmd_alloc() specific flags
196 * DCOPY_ALLOC_LINK - when set, the caller passes in a previously alloced
197 * command in cmd. dcopy_cmd_alloc() will allocate a new command and
198 * link it to the old command. The caller can use this to build a
199 * chain of commands, keeping only the last cmd alloced. calling
200 * dcopy_cmd_free() with the last cmd alloced in the chain will free all of
201 * the commands in the chain. dcopy_cmd_post() and dcopy_cmd_poll() have
202 * no knowledge of a chain of commands. It's only used for alloc/free.
204 #define DCOPY_ALLOC_LINK (1 << 16)
208 * allocate a command. A command can be re-used after it completes.
209 * flags - (DCOPY_SLEEP || DCOPY_NOSLEEP), DCOPY_ALLOC_LINK
210 * returns => DCOPY_FAILURE, DCOPY_SUCCESS, DCOPY_NORESOURCES
212 int dcopy_cmd_alloc(dcopy_handle_t handle
, int flags
, dcopy_cmd_t
*cmd
);
216 * free the command. This call cannot be called after dcopy_free().
218 void dcopy_cmd_free(dcopy_cmd_t
*cmd
);
222 * post a command (allocated from dcopy_cmd_alloc()) to the DMA channel
223 * returns => DCOPY_FAILURE, DCOPY_SUCCESS, DCOPY_NORESOURCES
225 int dcopy_cmd_post(dcopy_cmd_t cmd
);
227 /* dcopy_cmd_poll() flags */
228 #define DCOPY_POLL_NOFLAGS (0)
229 #define DCOPY_POLL_BLOCK (1 << 0)
233 * poll on completion status of a previous post. This call cannot be called
234 * after dcopy_free().
236 * if flags == DCOPY_POLL_NOFLAGS, return status can be DCOPY_FAILURE,
237 * DCOPY_PENDING, or DCOPY_COMPLETED.
239 * if flags & DCOPY_POLL_BLOCK, return status can be DCOPY_FAILURE or
240 * DCOPY_COMPLETED. DCOPY_POLL_BLOCK can only be set in base context.
242 * The command cannot be re-used or freed until the command has completed
243 * (e.g. DCOPY_FAILURE or DCOPY_COMPLETED).
245 int dcopy_cmd_poll(dcopy_cmd_t cmd
, int flags
);
252 #endif /* _SYS_DCOPY_H */