1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /*
3 * Copyright 2013-2016 Freescale Semiconductor Inc.
4 * Copyright 2016 NXP
5 *
6 */
7 #include <linux/kernel.h>
8 #include <linux/fsl/mc.h>
9
10 #include "dpio.h"
11 #include "dpio-cmd.h"
12
13 /*
14 * Data Path I/O Portal API
15 * Contains initialization APIs and runtime control APIs for DPIO
16 */
17
18 /**
19 * dpio_open() - Open a control session for the specified object
20 * @mc_io: Pointer to MC portal's I/O object
21 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
22 * @dpio_id: DPIO unique ID
23 * @token: Returned token; use in subsequent API calls
24 *
25 * This function can be used to open a control session for an
26 * already created object; an object may have been declared in
27 * the DPL or by calling the dpio_create() function.
28 * This function returns a unique authentication token,
29 * associated with the specific object ID and the specific MC
30 * portal; this token must be used in all subsequent commands for
31 * this specific object.
32 *
33 * Return: '0' on Success; Error code otherwise.
34 */
dpio_open(struct fsl_mc_io * mc_io,u32 cmd_flags,int dpio_id,u16 * token)35 int dpio_open(struct fsl_mc_io *mc_io,
36 u32 cmd_flags,
37 int dpio_id,
38 u16 *token)
39 {
40 struct fsl_mc_command cmd = { 0 };
41 struct dpio_cmd_open *dpio_cmd;
42 int err;
43
44 /* prepare command */
45 cmd.header = mc_encode_cmd_header(DPIO_CMDID_OPEN,
46 cmd_flags,
47 0);
48 dpio_cmd = (struct dpio_cmd_open *)cmd.params;
49 dpio_cmd->dpio_id = cpu_to_le32(dpio_id);
50
51 err = mc_send_command(mc_io, &cmd);
52 if (err)
53 return err;
54
55 /* retrieve response parameters */
56 *token = mc_cmd_hdr_read_token(&cmd);
57
58 return 0;
59 }
60
61 /**
62 * dpio_close() - Close the control session of the object
63 * @mc_io: Pointer to MC portal's I/O object
64 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
65 * @token: Token of DPIO object
66 *
67 * Return: '0' on Success; Error code otherwise.
68 */
dpio_close(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token)69 int dpio_close(struct fsl_mc_io *mc_io,
70 u32 cmd_flags,
71 u16 token)
72 {
73 struct fsl_mc_command cmd = { 0 };
74
75 /* prepare command */
76 cmd.header = mc_encode_cmd_header(DPIO_CMDID_CLOSE,
77 cmd_flags,
78 token);
79
80 return mc_send_command(mc_io, &cmd);
81 }
82
83 /**
84 * dpio_enable() - Enable the DPIO, allow I/O portal operations.
85 * @mc_io: Pointer to MC portal's I/O object
86 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
87 * @token: Token of DPIO object
88 *
89 * Return: '0' on Success; Error code otherwise
90 */
dpio_enable(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token)91 int dpio_enable(struct fsl_mc_io *mc_io,
92 u32 cmd_flags,
93 u16 token)
94 {
95 struct fsl_mc_command cmd = { 0 };
96
97 /* prepare command */
98 cmd.header = mc_encode_cmd_header(DPIO_CMDID_ENABLE,
99 cmd_flags,
100 token);
101
102 return mc_send_command(mc_io, &cmd);
103 }
104
105 /**
106 * dpio_disable() - Disable the DPIO, stop any I/O portal operation.
107 * @mc_io: Pointer to MC portal's I/O object
108 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
109 * @token: Token of DPIO object
110 *
111 * Return: '0' on Success; Error code otherwise
112 */
dpio_disable(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token)113 int dpio_disable(struct fsl_mc_io *mc_io,
114 u32 cmd_flags,
115 u16 token)
116 {
117 struct fsl_mc_command cmd = { 0 };
118
119 /* prepare command */
120 cmd.header = mc_encode_cmd_header(DPIO_CMDID_DISABLE,
121 cmd_flags,
122 token);
123
124 return mc_send_command(mc_io, &cmd);
125 }
126
127 /**
128 * dpio_get_attributes() - Retrieve DPIO attributes
129 * @mc_io: Pointer to MC portal's I/O object
130 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
131 * @token: Token of DPIO object
132 * @attr: Returned object's attributes
133 *
134 * Return: '0' on Success; Error code otherwise
135 */
dpio_get_attributes(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,struct dpio_attr * attr)136 int dpio_get_attributes(struct fsl_mc_io *mc_io,
137 u32 cmd_flags,
138 u16 token,
139 struct dpio_attr *attr)
140 {
141 struct fsl_mc_command cmd = { 0 };
142 struct dpio_rsp_get_attr *dpio_rsp;
143 int err;
144
145 /* prepare command */
146 cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_ATTR,
147 cmd_flags,
148 token);
149
150 err = mc_send_command(mc_io, &cmd);
151 if (err)
152 return err;
153
154 /* retrieve response parameters */
155 dpio_rsp = (struct dpio_rsp_get_attr *)cmd.params;
156 attr->id = le32_to_cpu(dpio_rsp->id);
157 attr->qbman_portal_id = le16_to_cpu(dpio_rsp->qbman_portal_id);
158 attr->num_priorities = dpio_rsp->num_priorities;
159 attr->channel_mode = dpio_rsp->channel_mode & DPIO_CHANNEL_MODE_MASK;
160 attr->qbman_portal_ce_offset =
161 le64_to_cpu(dpio_rsp->qbman_portal_ce_addr);
162 attr->qbman_portal_ci_offset =
163 le64_to_cpu(dpio_rsp->qbman_portal_ci_addr);
164 attr->qbman_version = le32_to_cpu(dpio_rsp->qbman_version);
165 attr->clk = le32_to_cpu(dpio_rsp->clk);
166
167 return 0;
168 }
169
dpio_set_stashing_destination(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token,u8 sdest)170 int dpio_set_stashing_destination(struct fsl_mc_io *mc_io,
171 u32 cmd_flags,
172 u16 token,
173 u8 sdest)
174 {
175 struct fsl_mc_command cmd = { 0 };
176 struct dpio_stashing_dest *dpio_cmd;
177
178 cmd.header = mc_encode_cmd_header(DPIO_CMDID_SET_STASHING_DEST,
179 cmd_flags, token);
180 dpio_cmd = (struct dpio_stashing_dest *)cmd.params;
181 dpio_cmd->sdest = sdest;
182
183 return mc_send_command(mc_io, &cmd);
184 }
185
186 /**
187 * dpio_get_api_version - Get Data Path I/O API version
188 * @mc_io: Pointer to MC portal's DPIO object
189 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
190 * @major_ver: Major version of DPIO API
191 * @minor_ver: Minor version of DPIO API
192 *
193 * Return: '0' on Success; Error code otherwise
194 */
dpio_get_api_version(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 * major_ver,u16 * minor_ver)195 int dpio_get_api_version(struct fsl_mc_io *mc_io,
196 u32 cmd_flags,
197 u16 *major_ver,
198 u16 *minor_ver)
199 {
200 struct fsl_mc_command cmd = { 0 };
201 int err;
202
203 /* prepare command */
204 cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
205 cmd_flags, 0);
206
207 err = mc_send_command(mc_io, &cmd);
208 if (err)
209 return err;
210
211 /* retrieve response parameters */
212 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
213
214 return 0;
215 }
216
217 /**
218 * dpio_reset() - Reset the DPIO, returns the object to initial state.
219 * @mc_io: Pointer to MC portal's I/O object
220 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
221 * @token: Token of DPIO object
222 *
223 * Return: '0' on Success; Error code otherwise.
224 */
dpio_reset(struct fsl_mc_io * mc_io,u32 cmd_flags,u16 token)225 int dpio_reset(struct fsl_mc_io *mc_io,
226 u32 cmd_flags,
227 u16 token)
228 {
229 struct fsl_mc_command cmd = { 0 };
230
231 /* prepare command */
232 cmd.header = mc_encode_cmd_header(DPIO_CMDID_RESET,
233 cmd_flags,
234 token);
235
236 /* send command to mc*/
237 return mc_send_command(mc_io, &cmd);
238 }
239