1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright 2019 NXP
3 
4 #include <linux/module.h>
5 #include <linux/types.h>
6 #include <linux/io.h>
7 #include <linux/fsl/mc.h>
8 #include "dpdmai.h"
9 
10 struct dpdmai_rsp_get_attributes {
11 	__le32 id;
12 	u8 num_of_priorities;
13 	u8 pad0[3];
14 	__le16 major;
15 	__le16 minor;
16 };
17 
18 struct dpdmai_cmd_queue {
19 	__le32 dest_id;
20 	u8 priority;
21 	u8 queue;
22 	u8 dest_type;
23 	u8 pad;
24 	__le64 user_ctx;
25 	union {
26 		__le32 options;
27 		__le32 fqid;
28 	};
29 };
30 
31 struct dpdmai_rsp_get_tx_queue {
32 	__le64 pad;
33 	__le32 fqid;
34 };
35 
36 #define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \
37 	((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg))
38 
39 /* cmd, param, offset, width, type, arg_name */
40 #define DPDMAI_CMD_CREATE(cmd, cfg) \
41 do { \
42 	MC_CMD_OP(cmd, 0, 8,  8,  u8,  (cfg)->priorities[0]);\
43 	MC_CMD_OP(cmd, 0, 16, 8,  u8,  (cfg)->priorities[1]);\
44 } while (0)
45 
46 static inline u64 mc_enc(int lsoffset, int width, u64 val)
47 {
48 	return (val & MAKE_UMASK64(width)) << lsoffset;
49 }
50 
51 /**
52  * dpdmai_open() - Open a control session for the specified object
53  * @mc_io:	Pointer to MC portal's I/O object
54  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
55  * @dpdmai_id:	DPDMAI unique ID
56  * @token:	Returned token; use in subsequent API calls
57  *
58  * This function can be used to open a control session for an
59  * already created object; an object may have been declared in
60  * the DPL or by calling the dpdmai_create() function.
61  * This function returns a unique authentication token,
62  * associated with the specific object ID and the specific MC
63  * portal; this token must be used in all subsequent commands for
64  * this specific object.
65  *
66  * Return:	'0' on Success; Error code otherwise.
67  */
68 int dpdmai_open(struct fsl_mc_io *mc_io, u32 cmd_flags,
69 		int dpdmai_id, u16 *token)
70 {
71 	struct fsl_mc_command cmd = { 0 };
72 	__le64 *cmd_dpdmai_id;
73 	int err;
74 
75 	/* prepare command */
76 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_OPEN,
77 					  cmd_flags, 0);
78 
79 	cmd_dpdmai_id = cmd.params;
80 	*cmd_dpdmai_id = cpu_to_le32(dpdmai_id);
81 
82 	/* send command to mc*/
83 	err = mc_send_command(mc_io, &cmd);
84 	if (err)
85 		return err;
86 
87 	/* retrieve response parameters */
88 	*token = mc_cmd_hdr_read_token(&cmd);
89 
90 	return 0;
91 }
92 EXPORT_SYMBOL_GPL(dpdmai_open);
93 
94 /**
95  * dpdmai_close() - Close the control session of the object
96  * @mc_io:	Pointer to MC portal's I/O object
97  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
98  * @token:	Token of DPDMAI object
99  *
100  * After this function is called, no further operations are
101  * allowed on the object without opening a new control session.
102  *
103  * Return:	'0' on Success; Error code otherwise.
104  */
105 int dpdmai_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
106 {
107 	struct fsl_mc_command cmd = { 0 };
108 
109 	/* prepare command */
110 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CLOSE,
111 					  cmd_flags, token);
112 
113 	/* send command to mc*/
114 	return mc_send_command(mc_io, &cmd);
115 }
116 EXPORT_SYMBOL_GPL(dpdmai_close);
117 
118 /**
119  * dpdmai_create() - Create the DPDMAI object
120  * @mc_io:	Pointer to MC portal's I/O object
121  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
122  * @cfg:	Configuration structure
123  * @token:	Returned token; use in subsequent API calls
124  *
125  * Create the DPDMAI object, allocate required resources and
126  * perform required initialization.
127  *
128  * The object can be created either by declaring it in the
129  * DPL file, or by calling this function.
130  *
131  * This function returns a unique authentication token,
132  * associated with the specific object ID and the specific MC
133  * portal; this token must be used in all subsequent calls to
134  * this specific object. For objects that are created using the
135  * DPL file, call dpdmai_open() function to get an authentication
136  * token first.
137  *
138  * Return:	'0' on Success; Error code otherwise.
139  */
140 int dpdmai_create(struct fsl_mc_io *mc_io, u32 cmd_flags,
141 		  const struct dpdmai_cfg *cfg, u16 *token)
142 {
143 	struct fsl_mc_command cmd = { 0 };
144 	int err;
145 
146 	/* prepare command */
147 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CREATE,
148 					  cmd_flags, 0);
149 	DPDMAI_CMD_CREATE(cmd, cfg);
150 
151 	/* send command to mc*/
152 	err = mc_send_command(mc_io, &cmd);
153 	if (err)
154 		return err;
155 
156 	/* retrieve response parameters */
157 	*token = mc_cmd_hdr_read_token(&cmd);
158 
159 	return 0;
160 }
161 
162 /**
163  * dpdmai_destroy() - Destroy the DPDMAI object and release all its resources.
164  * @mc_io:      Pointer to MC portal's I/O object
165  * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
166  * @token:      Token of DPDMAI object
167  *
168  * Return:      '0' on Success; error code otherwise.
169  */
170 int dpdmai_destroy(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
171 {
172 	struct fsl_mc_command cmd = { 0 };
173 
174 	/* prepare command */
175 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DESTROY,
176 					  cmd_flags, token);
177 
178 	/* send command to mc*/
179 	return mc_send_command(mc_io, &cmd);
180 }
181 EXPORT_SYMBOL_GPL(dpdmai_destroy);
182 
183 /**
184  * dpdmai_enable() - Enable the DPDMAI, allow sending and receiving frames.
185  * @mc_io:	Pointer to MC portal's I/O object
186  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
187  * @token:	Token of DPDMAI object
188  *
189  * Return:	'0' on Success; Error code otherwise.
190  */
191 int dpdmai_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
192 {
193 	struct fsl_mc_command cmd = { 0 };
194 
195 	/* prepare command */
196 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_ENABLE,
197 					  cmd_flags, token);
198 
199 	/* send command to mc*/
200 	return mc_send_command(mc_io, &cmd);
201 }
202 EXPORT_SYMBOL_GPL(dpdmai_enable);
203 
204 /**
205  * dpdmai_disable() - Disable the DPDMAI, stop sending and receiving frames.
206  * @mc_io:	Pointer to MC portal's I/O object
207  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
208  * @token:	Token of DPDMAI object
209  *
210  * Return:	'0' on Success; Error code otherwise.
211  */
212 int dpdmai_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
213 {
214 	struct fsl_mc_command cmd = { 0 };
215 
216 	/* prepare command */
217 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DISABLE,
218 					  cmd_flags, token);
219 
220 	/* send command to mc*/
221 	return mc_send_command(mc_io, &cmd);
222 }
223 EXPORT_SYMBOL_GPL(dpdmai_disable);
224 
225 /**
226  * dpdmai_reset() - Reset the DPDMAI, returns the object to initial state.
227  * @mc_io:	Pointer to MC portal's I/O object
228  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
229  * @token:	Token of DPDMAI object
230  *
231  * Return:	'0' on Success; Error code otherwise.
232  */
233 int dpdmai_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
234 {
235 	struct fsl_mc_command cmd = { 0 };
236 
237 	/* prepare command */
238 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_RESET,
239 					  cmd_flags, token);
240 
241 	/* send command to mc*/
242 	return mc_send_command(mc_io, &cmd);
243 }
244 EXPORT_SYMBOL_GPL(dpdmai_reset);
245 
246 /**
247  * dpdmai_get_attributes() - Retrieve DPDMAI attributes.
248  * @mc_io:	Pointer to MC portal's I/O object
249  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
250  * @token:	Token of DPDMAI object
251  * @attr:	Returned object's attributes
252  *
253  * Return:	'0' on Success; Error code otherwise.
254  */
255 int dpdmai_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags,
256 			  u16 token, struct dpdmai_attr *attr)
257 {
258 	struct dpdmai_rsp_get_attributes *rsp_params;
259 	struct fsl_mc_command cmd = { 0 };
260 	int err;
261 
262 	/* prepare command */
263 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_ATTR,
264 					  cmd_flags, token);
265 
266 	/* send command to mc*/
267 	err = mc_send_command(mc_io, &cmd);
268 	if (err)
269 		return err;
270 
271 	/* retrieve response parameters */
272 	rsp_params = (struct dpdmai_rsp_get_attributes *)cmd.params;
273 	attr->id = le32_to_cpu(rsp_params->id);
274 	attr->version.major = le16_to_cpu(rsp_params->major);
275 	attr->version.minor = le16_to_cpu(rsp_params->minor);
276 	attr->num_of_priorities = rsp_params->num_of_priorities;
277 
278 	return 0;
279 }
280 EXPORT_SYMBOL_GPL(dpdmai_get_attributes);
281 
282 /**
283  * dpdmai_set_rx_queue() - Set Rx queue configuration
284  * @mc_io:	Pointer to MC portal's I/O object
285  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
286  * @token:	Token of DPDMAI object
287  * @priority:	Select the queue relative to number of
288  *		priorities configured at DPDMAI creation
289  * @cfg:	Rx queue configuration
290  *
291  * Return:	'0' on Success; Error code otherwise.
292  */
293 int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
294 			u8 priority, const struct dpdmai_rx_queue_cfg *cfg)
295 {
296 	struct dpdmai_cmd_queue *cmd_params;
297 	struct fsl_mc_command cmd = { 0 };
298 
299 	/* prepare command */
300 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_RX_QUEUE,
301 					  cmd_flags, token);
302 
303 	cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
304 	cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id);
305 	cmd_params->priority = cfg->dest_cfg.priority;
306 	cmd_params->queue = priority;
307 	cmd_params->dest_type = cfg->dest_cfg.dest_type;
308 	cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx);
309 	cmd_params->options = cpu_to_le32(cfg->options);
310 
311 	/* send command to mc*/
312 	return mc_send_command(mc_io, &cmd);
313 }
314 EXPORT_SYMBOL_GPL(dpdmai_set_rx_queue);
315 
316 /**
317  * dpdmai_get_rx_queue() - Retrieve Rx queue attributes.
318  * @mc_io:	Pointer to MC portal's I/O object
319  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
320  * @token:	Token of DPDMAI object
321  * @priority:	Select the queue relative to number of
322  *				priorities configured at DPDMAI creation
323  * @attr:	Returned Rx queue attributes
324  *
325  * Return:	'0' on Success; Error code otherwise.
326  */
327 int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
328 			u8 priority, struct dpdmai_rx_queue_attr *attr)
329 {
330 	struct dpdmai_cmd_queue *cmd_params;
331 	struct fsl_mc_command cmd = { 0 };
332 	int err;
333 
334 	/* prepare command */
335 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_RX_QUEUE,
336 					  cmd_flags, token);
337 
338 	cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
339 	cmd_params->queue = priority;
340 
341 	/* send command to mc*/
342 	err = mc_send_command(mc_io, &cmd);
343 	if (err)
344 		return err;
345 
346 	/* retrieve response parameters */
347 	attr->dest_cfg.dest_id = le32_to_cpu(cmd_params->dest_id);
348 	attr->dest_cfg.priority = cmd_params->priority;
349 	attr->dest_cfg.dest_type = cmd_params->dest_type;
350 	attr->user_ctx = le64_to_cpu(cmd_params->user_ctx);
351 	attr->fqid = le32_to_cpu(cmd_params->fqid);
352 
353 	return 0;
354 }
355 EXPORT_SYMBOL_GPL(dpdmai_get_rx_queue);
356 
357 /**
358  * dpdmai_get_tx_queue() - Retrieve Tx queue attributes.
359  * @mc_io:	Pointer to MC portal's I/O object
360  * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
361  * @token:	Token of DPDMAI object
362  * @priority:	Select the queue relative to number of
363  *			priorities configured at DPDMAI creation
364  * @fqid:	Returned Tx queue
365  *
366  * Return:	'0' on Success; Error code otherwise.
367  */
368 int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, u32 cmd_flags,
369 			u16 token, u8 priority, u32 *fqid)
370 {
371 	struct dpdmai_rsp_get_tx_queue *rsp_params;
372 	struct dpdmai_cmd_queue *cmd_params;
373 	struct fsl_mc_command cmd = { 0 };
374 	int err;
375 
376 	/* prepare command */
377 	cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_TX_QUEUE,
378 					  cmd_flags, token);
379 
380 	cmd_params = (struct dpdmai_cmd_queue *)cmd.params;
381 	cmd_params->queue = priority;
382 
383 	/* send command to mc*/
384 	err = mc_send_command(mc_io, &cmd);
385 	if (err)
386 		return err;
387 
388 	/* retrieve response parameters */
389 
390 	rsp_params = (struct dpdmai_rsp_get_tx_queue *)cmd.params;
391 	*fqid = le32_to_cpu(rsp_params->fqid);
392 
393 	return 0;
394 }
395 EXPORT_SYMBOL_GPL(dpdmai_get_tx_queue);
396 
397 MODULE_LICENSE("GPL v2");
398