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 */
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 */
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 */
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 */
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 */
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
166 return 0;
167 }
168
169 int dpio_set_stashing_destination(struct fsl_mc_io *mc_io,
170 u32 cmd_flags,
171 u16 token,
172 u8 sdest)
173 {
174 struct fsl_mc_command cmd = { 0 };
175 struct dpio_stashing_dest *dpio_cmd;
176
177 cmd.header = mc_encode_cmd_header(DPIO_CMDID_SET_STASHING_DEST,
178 cmd_flags, token);
179 dpio_cmd = (struct dpio_stashing_dest *)cmd.params;
180 dpio_cmd->sdest = sdest;
181
182 return mc_send_command(mc_io, &cmd);
183 }
184
185 /**
186 * dpio_get_api_version - Get Data Path I/O API version
187 * @mc_io: Pointer to MC portal's DPIO object
188 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
189 * @major_ver: Major version of DPIO API
190 * @minor_ver: Minor version of DPIO API
191 *
192 * Return: '0' on Success; Error code otherwise
193 */
194 int dpio_get_api_version(struct fsl_mc_io *mc_io,
195 u32 cmd_flags,
196 u16 *major_ver,
197 u16 *minor_ver)
198 {
199 struct fsl_mc_command cmd = { 0 };
200 int err;
201
202 /* prepare command */
203 cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
204 cmd_flags, 0);
205
206 err = mc_send_command(mc_io, &cmd);
207 if (err)
208 return err;
209
210 /* retrieve response parameters */
211 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
212
213 return 0;
214 }
215
216 /**
217 * dpio_reset() - Reset the DPIO, returns the object to initial state.
218 * @mc_io: Pointer to MC portal's I/O object
219 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
220 * @token: Token of DPIO object
221 *
222 * Return: '0' on Success; Error code otherwise.
223 */
224 int dpio_reset(struct fsl_mc_io *mc_io,
225 u32 cmd_flags,
226 u16 token)
227 {
228 struct fsl_mc_command cmd = { 0 };
229
230 /* prepare command */
231 cmd.header = mc_encode_cmd_header(DPIO_CMDID_RESET,
232 cmd_flags,
233 token);
234
235 /* send command to mc*/
236 return mc_send_command(mc_io, &cmd);
237 }