1 /* Copyright 2013-2016 Freescale Semiconductor Inc. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are met: 5 * * Redistributions of source code must retain the above copyright 6 * notice, this list of conditions and the following disclaimer. 7 * * Redistributions in binary form must reproduce the above copyright 8 * notice, this list of conditions and the following disclaimer in the 9 * documentation and/or other materials provided with the distribution. 10 * * Neither the name of the above-listed copyright holders nor the 11 * names of any contributors may be used to endorse or promote products 12 * derived from this software without specific prior written permission. 13 * 14 * 15 * ALTERNATIVELY, this software may be distributed under the terms of the 16 * GNU General Public License ("GPL") as published by the Free Software 17 * Foundation, either version 2 of that License or (at your option) any 18 * later version. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 #include <fsl_mc_sys.h> 33 #include <fsl_mc_cmd.h> 34 #include <fsl_dpcon.h> 35 #include <fsl_dpcon_cmd.h> 36 37 /** 38 * dpcon_open() - Open a control session for the specified object 39 * @mc_io: Pointer to MC portal's I/O object 40 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 41 * @dpcon_id: DPCON unique ID 42 * @token: Returned token; use in subsequent API calls 43 * 44 * This function can be used to open a control session for an 45 * already created object; an object may have been declared in 46 * the DPL or by calling the dpcon_create() function. 47 * This function returns a unique authentication token, 48 * associated with the specific object ID and the specific MC 49 * portal; this token must be used in all subsequent commands for 50 * this specific object. 51 * 52 * Return: '0' on Success; Error code otherwise. 53 */ 54 int dpcon_open(struct fsl_mc_io *mc_io, 55 uint32_t cmd_flags, 56 int dpcon_id, 57 uint16_t *token) 58 { 59 struct mc_command cmd = { 0 }; 60 struct dpcon_cmd_open *dpcon_cmd; 61 int err; 62 63 /* prepare command */ 64 cmd.header = mc_encode_cmd_header(DPCON_CMDID_OPEN, 65 cmd_flags, 66 0); 67 dpcon_cmd = (struct dpcon_cmd_open *)cmd.params; 68 dpcon_cmd->dpcon_id = cpu_to_le32(dpcon_id); 69 70 /* send command to mc*/ 71 err = mc_send_command(mc_io, &cmd); 72 if (err) 73 return err; 74 75 /* retrieve response parameters */ 76 *token = mc_cmd_hdr_read_token(&cmd); 77 78 return 0; 79 } 80 81 /** 82 * dpcon_close() - Close the control session of the object 83 * @mc_io: Pointer to MC portal's I/O object 84 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 85 * @token: Token of DPCON object 86 * 87 * After this function is called, no further operations are 88 * allowed on the object without opening a new control session. 89 * 90 * Return: '0' on Success; Error code otherwise. 91 */ 92 int dpcon_close(struct fsl_mc_io *mc_io, 93 uint32_t cmd_flags, 94 uint16_t token) 95 { 96 struct mc_command cmd = { 0 }; 97 98 /* prepare command */ 99 cmd.header = mc_encode_cmd_header(DPCON_CMDID_CLOSE, 100 cmd_flags, 101 token); 102 103 /* send command to mc*/ 104 return mc_send_command(mc_io, &cmd); 105 } 106 107 /** 108 * dpcon_create() - Create the DPCON object. 109 * @mc_io: Pointer to MC portal's I/O object 110 * @dprc_token: Parent container token; '0' for default container 111 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 112 * @cfg: Configuration structure 113 * @obj_id: Returned object id; use in subsequent API calls 114 * 115 * Create the DPCON object, allocate required resources and 116 * perform required initialization. 117 * 118 * The object can be created either by declaring it in the 119 * DPL file, or by calling this function. 120 * 121 * This function accepts an authentication token of a parent 122 * container that this object should be assigned to and returns 123 * an object id. This object_id will be used in all subsequent calls to 124 * this specific object. 125 * 126 * Return: '0' on Success; Error code otherwise. 127 */ 128 int dpcon_create(struct fsl_mc_io *mc_io, 129 uint16_t dprc_token, 130 uint32_t cmd_flags, 131 const struct dpcon_cfg *cfg, 132 uint32_t *obj_id) 133 { 134 struct dpcon_cmd_create *dpcon_cmd; 135 struct mc_command cmd = { 0 }; 136 int err; 137 138 /* prepare command */ 139 cmd.header = mc_encode_cmd_header(DPCON_CMDID_CREATE, 140 cmd_flags, 141 dprc_token); 142 dpcon_cmd = (struct dpcon_cmd_create *)cmd.params; 143 dpcon_cmd->num_priorities = cfg->num_priorities; 144 145 /* send command to mc*/ 146 err = mc_send_command(mc_io, &cmd); 147 if (err) 148 return err; 149 150 /* retrieve response parameters */ 151 *obj_id = mc_cmd_read_object_id(&cmd); 152 153 return 0; 154 } 155 156 /** 157 * dpcon_destroy() - Destroy the DPCON object and release all its resources. 158 * @mc_io: Pointer to MC portal's I/O object 159 * @dprc_token: Parent container token; '0' for default container 160 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 161 * @obj_id: ID of DPCON object 162 * 163 * Return: '0' on Success; error code otherwise. 164 */ 165 int dpcon_destroy(struct fsl_mc_io *mc_io, 166 uint16_t dprc_token, 167 uint32_t cmd_flags, 168 uint32_t obj_id) 169 { 170 struct dpcon_cmd_destroy *cmd_params; 171 struct mc_command cmd = { 0 }; 172 173 /* prepare command */ 174 cmd.header = mc_encode_cmd_header(DPCON_CMDID_DESTROY, 175 cmd_flags, 176 dprc_token); 177 cmd_params = (struct dpcon_cmd_destroy *)cmd.params; 178 cmd_params->object_id = cpu_to_le32(obj_id); 179 180 /* send command to mc*/ 181 return mc_send_command(mc_io, &cmd); 182 } 183 184 /** 185 * dpcon_enable() - Enable the DPCON 186 * @mc_io: Pointer to MC portal's I/O object 187 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 188 * @token: Token of DPCON object 189 * 190 * Return: '0' on Success; Error code otherwise 191 */ 192 int dpcon_enable(struct fsl_mc_io *mc_io, 193 uint32_t cmd_flags, 194 uint16_t token) 195 { 196 struct mc_command cmd = { 0 }; 197 198 /* prepare command */ 199 cmd.header = mc_encode_cmd_header(DPCON_CMDID_ENABLE, 200 cmd_flags, 201 token); 202 203 /* send command to mc*/ 204 return mc_send_command(mc_io, &cmd); 205 } 206 207 /** 208 * dpcon_disable() - Disable the DPCON 209 * @mc_io: Pointer to MC portal's I/O object 210 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 211 * @token: Token of DPCON object 212 * 213 * Return: '0' on Success; Error code otherwise 214 */ 215 int dpcon_disable(struct fsl_mc_io *mc_io, 216 uint32_t cmd_flags, 217 uint16_t token) 218 { 219 struct mc_command cmd = { 0 }; 220 221 /* prepare command */ 222 cmd.header = mc_encode_cmd_header(DPCON_CMDID_DISABLE, 223 cmd_flags, 224 token); 225 226 /* send command to mc*/ 227 return mc_send_command(mc_io, &cmd); 228 } 229 230 /** 231 * dpcon_is_enabled() - Check if the DPCON is enabled. 232 * @mc_io: Pointer to MC portal's I/O object 233 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 234 * @token: Token of DPCON object 235 * @en: Returns '1' if object is enabled; '0' otherwise 236 * 237 * Return: '0' on Success; Error code otherwise. 238 */ 239 int dpcon_is_enabled(struct fsl_mc_io *mc_io, 240 uint32_t cmd_flags, 241 uint16_t token, 242 int *en) 243 { 244 struct dpcon_rsp_is_enabled *dpcon_rsp; 245 struct mc_command cmd = { 0 }; 246 int err; 247 248 /* prepare command */ 249 cmd.header = mc_encode_cmd_header(DPCON_CMDID_IS_ENABLED, 250 cmd_flags, 251 token); 252 253 /* send command to mc*/ 254 err = mc_send_command(mc_io, &cmd); 255 if (err) 256 return err; 257 258 /* retrieve response parameters */ 259 dpcon_rsp = (struct dpcon_rsp_is_enabled *)cmd.params; 260 *en = dpcon_rsp->enabled & DPCON_ENABLE; 261 262 return 0; 263 } 264 265 /** 266 * dpcon_reset() - Reset the DPCON, returns the object to initial state. 267 * @mc_io: Pointer to MC portal's I/O object 268 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 269 * @token: Token of DPCON object 270 * 271 * Return: '0' on Success; Error code otherwise. 272 */ 273 int dpcon_reset(struct fsl_mc_io *mc_io, 274 uint32_t cmd_flags, 275 uint16_t token) 276 { 277 struct mc_command cmd = { 0 }; 278 279 /* prepare command */ 280 cmd.header = mc_encode_cmd_header(DPCON_CMDID_RESET, 281 cmd_flags, token); 282 283 /* send command to mc*/ 284 return mc_send_command(mc_io, &cmd); 285 } 286 287 /** 288 * dpcon_get_attributes() - Retrieve DPCON attributes. 289 * @mc_io: Pointer to MC portal's I/O object 290 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 291 * @token: Token of DPCON object 292 * @attr: Object's attributes 293 * 294 * Return: '0' on Success; Error code otherwise. 295 */ 296 int dpcon_get_attributes(struct fsl_mc_io *mc_io, 297 uint32_t cmd_flags, 298 uint16_t token, 299 struct dpcon_attr *attr) 300 { 301 struct dpcon_rsp_get_attr *dpcon_rsp; 302 struct mc_command cmd = { 0 }; 303 int err; 304 305 /* prepare command */ 306 cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_ATTR, 307 cmd_flags, 308 token); 309 310 /* send command to mc*/ 311 err = mc_send_command(mc_io, &cmd); 312 if (err) 313 return err; 314 315 /* retrieve response parameters */ 316 dpcon_rsp = (struct dpcon_rsp_get_attr *)cmd.params; 317 attr->id = le32_to_cpu(dpcon_rsp->id); 318 attr->qbman_ch_id = le16_to_cpu(dpcon_rsp->qbman_ch_id); 319 attr->num_priorities = dpcon_rsp->num_priorities; 320 321 return 0; 322 } 323 324 /** 325 * dpcon_get_api_version - Get Data Path Concentrator API version 326 * @mc_io: Pointer to MC portal's DPCON object 327 * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' 328 * @major_ver: Major version of DPCON API 329 * @minor_ver: Minor version of DPCON API 330 * 331 * Return: '0' on Success; Error code otherwise 332 */ 333 int dpcon_get_api_version(struct fsl_mc_io *mc_io, 334 uint32_t cmd_flags, 335 uint16_t *major_ver, 336 uint16_t *minor_ver) 337 { 338 struct dpcon_rsp_get_api_version *rsp_params; 339 struct mc_command cmd = { 0 }; 340 int err; 341 342 /* prepare command */ 343 cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_API_VERSION, 344 cmd_flags, 0); 345 346 /* send command to mc */ 347 err = mc_send_command(mc_io, &cmd); 348 if (err) 349 return err; 350 351 /* retrieve response parameters */ 352 rsp_params = (struct dpcon_rsp_get_api_version *)cmd.params; 353 *major_ver = le16_to_cpu(rsp_params->major); 354 *minor_ver = le16_to_cpu(rsp_params->minor); 355 356 return 0; 357 } 358