1 /* 2 * Freescale Layerscape MC I/O wrapper 3 * 4 * Copyright (C) 2013-2015 Freescale Semiconductor, Inc. 5 * Author: German Rivera <German.Rivera@freescale.com> 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <fsl-mc/fsl_mc_sys.h> 11 #include <fsl-mc/fsl_mc_cmd.h> 12 #include <fsl-mc/fsl_dprc.h> 13 14 int dprc_get_container_id(struct fsl_mc_io *mc_io, 15 uint32_t cmd_flags, 16 int *container_id) 17 { 18 struct mc_command cmd = { 0 }; 19 int err; 20 21 /* prepare command */ 22 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID, 23 cmd_flags, 24 0); 25 26 /* send command to mc*/ 27 err = mc_send_command(mc_io, &cmd); 28 if (err) 29 return err; 30 31 /* retrieve response parameters */ 32 DPRC_RSP_GET_CONTAINER_ID(cmd, *container_id); 33 34 return 0; 35 } 36 37 int dprc_open(struct fsl_mc_io *mc_io, 38 uint32_t cmd_flags, 39 int container_id, 40 uint16_t *token) 41 { 42 struct mc_command cmd = { 0 }; 43 int err; 44 45 /* prepare command */ 46 cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags, 47 0); 48 DPRC_CMD_OPEN(cmd, container_id); 49 50 /* send command to mc*/ 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.header); 57 58 return 0; 59 } 60 61 int dprc_close(struct fsl_mc_io *mc_io, 62 uint32_t cmd_flags, 63 uint16_t token) 64 { 65 struct mc_command cmd = { 0 }; 66 67 /* prepare command */ 68 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags, 69 token); 70 71 /* send command to mc*/ 72 return mc_send_command(mc_io, &cmd); 73 } 74 75 int dprc_create_container(struct fsl_mc_io *mc_io, 76 uint32_t cmd_flags, 77 uint16_t token, 78 struct dprc_cfg *cfg, 79 int *child_container_id, 80 uint64_t *child_portal_paddr) 81 { 82 struct mc_command cmd = { 0 }; 83 int err; 84 85 /* prepare command */ 86 DPRC_CMD_CREATE_CONTAINER(cmd, cfg); 87 88 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT, 89 cmd_flags, 90 token); 91 92 /* send command to mc*/ 93 err = mc_send_command(mc_io, &cmd); 94 if (err) 95 return err; 96 97 /* retrieve response parameters */ 98 DPRC_RSP_CREATE_CONTAINER(cmd, *child_container_id, 99 *child_portal_paddr); 100 101 return 0; 102 } 103 104 int dprc_destroy_container(struct fsl_mc_io *mc_io, 105 uint32_t cmd_flags, 106 uint16_t token, 107 int child_container_id) 108 { 109 struct mc_command cmd = { 0 }; 110 111 /* prepare command */ 112 cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT, 113 cmd_flags, 114 token); 115 DPRC_CMD_DESTROY_CONTAINER(cmd, child_container_id); 116 117 /* send command to mc*/ 118 return mc_send_command(mc_io, &cmd); 119 } 120 121 int dprc_reset_container(struct fsl_mc_io *mc_io, 122 uint32_t cmd_flags, 123 uint16_t token, 124 int child_container_id) 125 { 126 struct mc_command cmd = { 0 }; 127 128 /* prepare command */ 129 cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT, 130 cmd_flags, 131 token); 132 DPRC_CMD_RESET_CONTAINER(cmd, child_container_id); 133 134 /* send command to mc*/ 135 return mc_send_command(mc_io, &cmd); 136 } 137 138 int dprc_get_attributes(struct fsl_mc_io *mc_io, 139 uint32_t cmd_flags, 140 uint16_t token, 141 struct dprc_attributes *attr) 142 { 143 struct mc_command cmd = { 0 }; 144 int err; 145 146 /* prepare command */ 147 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR, 148 cmd_flags, 149 token); 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 DPRC_RSP_GET_ATTRIBUTES(cmd, attr); 158 159 return 0; 160 } 161 162 int dprc_get_obj_count(struct fsl_mc_io *mc_io, 163 uint32_t cmd_flags, 164 uint16_t token, 165 int *obj_count) 166 { 167 struct mc_command cmd = { 0 }; 168 int err; 169 170 /* prepare command */ 171 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT, 172 cmd_flags, 173 token); 174 175 /* send command to mc*/ 176 err = mc_send_command(mc_io, &cmd); 177 if (err) 178 return err; 179 180 /* retrieve response parameters */ 181 DPRC_RSP_GET_OBJ_COUNT(cmd, *obj_count); 182 183 return 0; 184 } 185 186 int dprc_get_obj(struct fsl_mc_io *mc_io, 187 uint32_t cmd_flags, 188 uint16_t token, 189 int obj_index, 190 struct dprc_obj_desc *obj_desc) 191 { 192 struct mc_command cmd = { 0 }; 193 int err; 194 195 /* prepare command */ 196 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ, 197 cmd_flags, 198 token); 199 DPRC_CMD_GET_OBJ(cmd, obj_index); 200 201 /* send command to mc*/ 202 err = mc_send_command(mc_io, &cmd); 203 if (err) 204 return err; 205 206 /* retrieve response parameters */ 207 DPRC_RSP_GET_OBJ(cmd, obj_desc); 208 209 return 0; 210 } 211 212 int dprc_get_res_count(struct fsl_mc_io *mc_io, 213 uint32_t cmd_flags, 214 uint16_t token, 215 char *type, 216 int *res_count) 217 { 218 struct mc_command cmd = { 0 }; 219 int err; 220 221 *res_count = 0; 222 223 /* prepare command */ 224 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT, 225 cmd_flags, 226 token); 227 DPRC_CMD_GET_RES_COUNT(cmd, type); 228 229 /* send command to mc*/ 230 err = mc_send_command(mc_io, &cmd); 231 if (err) 232 return err; 233 234 /* retrieve response parameters */ 235 DPRC_RSP_GET_RES_COUNT(cmd, *res_count); 236 237 return 0; 238 } 239 240 int dprc_get_res_ids(struct fsl_mc_io *mc_io, 241 uint32_t cmd_flags, 242 uint16_t token, 243 char *type, 244 struct dprc_res_ids_range_desc *range_desc) 245 { 246 struct mc_command cmd = { 0 }; 247 int err; 248 249 /* prepare command */ 250 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS, 251 cmd_flags, 252 token); 253 DPRC_CMD_GET_RES_IDS(cmd, range_desc, type); 254 255 /* send command to mc*/ 256 err = mc_send_command(mc_io, &cmd); 257 if (err) 258 return err; 259 260 /* retrieve response parameters */ 261 DPRC_RSP_GET_RES_IDS(cmd, range_desc); 262 263 return 0; 264 } 265 266 int dprc_get_obj_region(struct fsl_mc_io *mc_io, 267 uint32_t cmd_flags, 268 uint16_t token, 269 char *obj_type, 270 int obj_id, 271 uint8_t region_index, 272 struct dprc_region_desc *region_desc) 273 { 274 struct mc_command cmd = { 0 }; 275 int err; 276 277 /* prepare command */ 278 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG, 279 cmd_flags, 280 token); 281 DPRC_CMD_GET_OBJ_REGION(cmd, obj_type, obj_id, region_index); 282 283 /* send command to mc*/ 284 err = mc_send_command(mc_io, &cmd); 285 if (err) 286 return err; 287 288 /* retrieve response parameters */ 289 DPRC_RSP_GET_OBJ_REGION(cmd, region_desc); 290 291 return 0; 292 } 293 294 int dprc_connect(struct fsl_mc_io *mc_io, 295 uint32_t cmd_flags, 296 uint16_t token, 297 const struct dprc_endpoint *endpoint1, 298 const struct dprc_endpoint *endpoint2, 299 const struct dprc_connection_cfg *cfg) 300 { 301 struct mc_command cmd = { 0 }; 302 303 /* prepare command */ 304 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT, 305 cmd_flags, 306 token); 307 DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2, cfg); 308 309 /* send command to mc*/ 310 return mc_send_command(mc_io, &cmd); 311 } 312 313 int dprc_disconnect(struct fsl_mc_io *mc_io, 314 uint32_t cmd_flags, 315 uint16_t token, 316 const struct dprc_endpoint *endpoint) 317 { 318 struct mc_command cmd = { 0 }; 319 320 /* prepare command */ 321 cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT, 322 cmd_flags, 323 token); 324 DPRC_CMD_DISCONNECT(cmd, endpoint); 325 326 /* send command to mc*/ 327 return mc_send_command(mc_io, &cmd); 328 } 329 330 int dprc_get_connection(struct fsl_mc_io *mc_io, 331 uint32_t cmd_flags, 332 uint16_t token, 333 const struct dprc_endpoint *endpoint1, 334 struct dprc_endpoint *endpoint2, 335 int *state) 336 { 337 struct mc_command cmd = { 0 }; 338 int err; 339 340 /* prepare command */ 341 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION, 342 cmd_flags, 343 token); 344 DPRC_CMD_GET_CONNECTION(cmd, endpoint1); 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 DPRC_RSP_GET_CONNECTION(cmd, endpoint2, *state); 353 354 return 0; 355 } 356