1 /*- 2 * This file is provided under a dual BSD/GPLv2 license. When using or 3 * redistributing this file, you may do so under either license. 4 * 5 * BSD LICENSE 6 * 7 * Copyright 2013-2016 Freescale Semiconductor Inc. 8 * Copyright (c) 2016 NXP. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions are met: 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * * Neither the name of the above-listed copyright holders nor the 18 * names of any contributors may be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * GPL LICENSE SUMMARY 22 * 23 * ALTERNATIVELY, this software may be distributed under the terms of the 24 * GNU General Public License ("GPL") as published by the Free Software 25 * Foundation, either version 2 of that License or (at your option) any 26 * later version. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 29 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE 32 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 33 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 34 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 37 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 * POSSIBILITY OF SUCH DAMAGE. 39 */ 40 41 #include <fsl_mc_sys.h> 42 #include <fsl_mc_cmd.h> 43 #include <fsl_dpseci.h> 44 #include <fsl_dpseci_cmd.h> 45 46 int 47 dpseci_open(struct fsl_mc_io *mc_io, 48 uint32_t cmd_flags, 49 int dpseci_id, 50 uint16_t *token) 51 { 52 struct mc_command cmd = { 0 }; 53 int err; 54 55 /* prepare command */ 56 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_OPEN, 57 cmd_flags, 58 0); 59 DPSECI_CMD_OPEN(cmd, dpseci_id); 60 61 /* send command to mc */ 62 err = mc_send_command(mc_io, &cmd); 63 if (err) 64 return err; 65 66 /* retrieve response parameters */ 67 *token = MC_CMD_HDR_READ_TOKEN(cmd.header); 68 69 return 0; 70 } 71 72 int 73 dpseci_close(struct fsl_mc_io *mc_io, 74 uint32_t cmd_flags, 75 uint16_t token) 76 { 77 struct mc_command cmd = { 0 }; 78 79 /* prepare command */ 80 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_CLOSE, 81 cmd_flags, 82 token); 83 84 /* send command to mc */ 85 return mc_send_command(mc_io, &cmd); 86 } 87 88 int 89 dpseci_create(struct fsl_mc_io *mc_io, 90 uint16_t dprc_token, 91 uint32_t cmd_flags, 92 const struct dpseci_cfg *cfg, 93 uint32_t *obj_id) 94 { 95 struct mc_command cmd = { 0 }; 96 int err; 97 98 /* prepare command */ 99 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_CREATE, 100 cmd_flags, 101 dprc_token); 102 DPSECI_CMD_CREATE(cmd, cfg); 103 104 /* send command to mc */ 105 err = mc_send_command(mc_io, &cmd); 106 if (err) 107 return err; 108 109 /* retrieve response parameters */ 110 CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, *obj_id); 111 112 return 0; 113 } 114 115 int 116 dpseci_destroy(struct fsl_mc_io *mc_io, 117 uint16_t dprc_token, 118 uint32_t cmd_flags, 119 uint32_t object_id) 120 { 121 struct mc_command cmd = { 0 }; 122 123 /* prepare command */ 124 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_DESTROY, 125 cmd_flags, 126 dprc_token); 127 /* set object id to destroy */ 128 CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id); 129 /* send command to mc */ 130 return mc_send_command(mc_io, &cmd); 131 } 132 133 int 134 dpseci_enable(struct fsl_mc_io *mc_io, 135 uint32_t cmd_flags, 136 uint16_t token) 137 { 138 struct mc_command cmd = { 0 }; 139 140 /* prepare command */ 141 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_ENABLE, 142 cmd_flags, 143 token); 144 145 /* send command to mc */ 146 return mc_send_command(mc_io, &cmd); 147 } 148 149 int 150 dpseci_disable(struct fsl_mc_io *mc_io, 151 uint32_t cmd_flags, 152 uint16_t token) 153 { 154 struct mc_command cmd = { 0 }; 155 156 /* prepare command */ 157 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_DISABLE, 158 cmd_flags, 159 token); 160 161 /* send command to mc */ 162 return mc_send_command(mc_io, &cmd); 163 } 164 165 int 166 dpseci_is_enabled(struct fsl_mc_io *mc_io, 167 uint32_t cmd_flags, 168 uint16_t token, 169 int *en) 170 { 171 struct mc_command cmd = { 0 }; 172 int err; 173 /* prepare command */ 174 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_IS_ENABLED, 175 cmd_flags, 176 token); 177 178 /* send command to mc */ 179 err = mc_send_command(mc_io, &cmd); 180 if (err) 181 return err; 182 183 /* retrieve response parameters */ 184 DPSECI_RSP_IS_ENABLED(cmd, *en); 185 186 return 0; 187 } 188 189 int 190 dpseci_reset(struct fsl_mc_io *mc_io, 191 uint32_t cmd_flags, 192 uint16_t token) 193 { 194 struct mc_command cmd = { 0 }; 195 196 /* prepare command */ 197 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_RESET, 198 cmd_flags, 199 token); 200 201 /* send command to mc */ 202 return mc_send_command(mc_io, &cmd); 203 } 204 205 int 206 dpseci_get_irq(struct fsl_mc_io *mc_io, 207 uint32_t cmd_flags, 208 uint16_t token, 209 uint8_t irq_index, 210 int *type, 211 struct dpseci_irq_cfg *irq_cfg) 212 { 213 struct mc_command cmd = { 0 }; 214 int err; 215 216 /* prepare command */ 217 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_IRQ, 218 cmd_flags, 219 token); 220 DPSECI_CMD_GET_IRQ(cmd, irq_index); 221 222 /* send command to mc */ 223 err = mc_send_command(mc_io, &cmd); 224 if (err) 225 return err; 226 227 /* retrieve response parameters */ 228 DPSECI_RSP_GET_IRQ(cmd, *type, irq_cfg); 229 230 return 0; 231 } 232 233 int 234 dpseci_set_irq(struct fsl_mc_io *mc_io, 235 uint32_t cmd_flags, 236 uint16_t token, 237 uint8_t irq_index, 238 struct dpseci_irq_cfg *irq_cfg) 239 { 240 struct mc_command cmd = { 0 }; 241 242 /* prepare command */ 243 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_SET_IRQ, 244 cmd_flags, 245 token); 246 DPSECI_CMD_SET_IRQ(cmd, irq_index, irq_cfg); 247 248 /* send command to mc */ 249 return mc_send_command(mc_io, &cmd); 250 } 251 252 int 253 dpseci_get_irq_enable(struct fsl_mc_io *mc_io, 254 uint32_t cmd_flags, 255 uint16_t token, 256 uint8_t irq_index, 257 uint8_t *en) 258 { 259 struct mc_command cmd = { 0 }; 260 int err; 261 262 /* prepare command */ 263 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_IRQ_ENABLE, 264 cmd_flags, 265 token); 266 DPSECI_CMD_GET_IRQ_ENABLE(cmd, irq_index); 267 268 /* send command to mc */ 269 err = mc_send_command(mc_io, &cmd); 270 if (err) 271 return err; 272 273 /* retrieve response parameters */ 274 DPSECI_RSP_GET_IRQ_ENABLE(cmd, *en); 275 276 return 0; 277 } 278 279 int 280 dpseci_set_irq_enable(struct fsl_mc_io *mc_io, 281 uint32_t cmd_flags, 282 uint16_t token, 283 uint8_t irq_index, 284 uint8_t en) 285 { 286 struct mc_command cmd = { 0 }; 287 288 /* prepare command */ 289 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_SET_IRQ_ENABLE, 290 cmd_flags, 291 token); 292 DPSECI_CMD_SET_IRQ_ENABLE(cmd, irq_index, en); 293 294 /* send command to mc */ 295 return mc_send_command(mc_io, &cmd); 296 } 297 298 int 299 dpseci_get_irq_mask(struct fsl_mc_io *mc_io, 300 uint32_t cmd_flags, 301 uint16_t token, 302 uint8_t irq_index, 303 uint32_t *mask) 304 { 305 struct mc_command cmd = { 0 }; 306 int err; 307 308 /* prepare command */ 309 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_IRQ_MASK, 310 cmd_flags, 311 token); 312 DPSECI_CMD_GET_IRQ_MASK(cmd, irq_index); 313 314 /* send command to mc */ 315 err = mc_send_command(mc_io, &cmd); 316 if (err) 317 return err; 318 319 /* retrieve response parameters */ 320 DPSECI_RSP_GET_IRQ_MASK(cmd, *mask); 321 322 return 0; 323 } 324 325 int 326 dpseci_set_irq_mask(struct fsl_mc_io *mc_io, 327 uint32_t cmd_flags, 328 uint16_t token, 329 uint8_t irq_index, 330 uint32_t mask) 331 { 332 struct mc_command cmd = { 0 }; 333 334 /* prepare command */ 335 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_SET_IRQ_MASK, 336 cmd_flags, 337 token); 338 DPSECI_CMD_SET_IRQ_MASK(cmd, irq_index, mask); 339 340 /* send command to mc */ 341 return mc_send_command(mc_io, &cmd); 342 } 343 344 int 345 dpseci_get_irq_status(struct fsl_mc_io *mc_io, 346 uint32_t cmd_flags, 347 uint16_t token, 348 uint8_t irq_index, 349 uint32_t *status) 350 { 351 struct mc_command cmd = { 0 }; 352 int err; 353 354 /* prepare command */ 355 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_IRQ_STATUS, 356 cmd_flags, 357 token); 358 DPSECI_CMD_GET_IRQ_STATUS(cmd, irq_index, *status); 359 360 /* send command to mc */ 361 err = mc_send_command(mc_io, &cmd); 362 if (err) 363 return err; 364 365 /* retrieve response parameters */ 366 DPSECI_RSP_GET_IRQ_STATUS(cmd, *status); 367 368 return 0; 369 } 370 371 int 372 dpseci_clear_irq_status(struct fsl_mc_io *mc_io, 373 uint32_t cmd_flags, 374 uint16_t token, 375 uint8_t irq_index, 376 uint32_t status) 377 { 378 struct mc_command cmd = { 0 }; 379 380 /* prepare command */ 381 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_CLEAR_IRQ_STATUS, 382 cmd_flags, 383 token); 384 DPSECI_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status); 385 386 /* send command to mc */ 387 return mc_send_command(mc_io, &cmd); 388 } 389 390 int 391 dpseci_get_attributes(struct fsl_mc_io *mc_io, 392 uint32_t cmd_flags, 393 uint16_t token, 394 struct dpseci_attr *attr) 395 { 396 struct mc_command cmd = { 0 }; 397 int err; 398 399 /* prepare command */ 400 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_ATTR, 401 cmd_flags, 402 token); 403 404 /* send command to mc */ 405 err = mc_send_command(mc_io, &cmd); 406 if (err) 407 return err; 408 409 /* retrieve response parameters */ 410 DPSECI_RSP_GET_ATTR(cmd, attr); 411 412 return 0; 413 } 414 415 int 416 dpseci_set_rx_queue(struct fsl_mc_io *mc_io, 417 uint32_t cmd_flags, 418 uint16_t token, 419 uint8_t queue, 420 const struct dpseci_rx_queue_cfg *cfg) 421 { 422 struct mc_command cmd = { 0 }; 423 424 /* prepare command */ 425 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_SET_RX_QUEUE, 426 cmd_flags, 427 token); 428 DPSECI_CMD_SET_RX_QUEUE(cmd, queue, cfg); 429 430 /* send command to mc */ 431 return mc_send_command(mc_io, &cmd); 432 } 433 434 int 435 dpseci_get_rx_queue(struct fsl_mc_io *mc_io, 436 uint32_t cmd_flags, 437 uint16_t token, 438 uint8_t queue, 439 struct dpseci_rx_queue_attr *attr) 440 { 441 struct mc_command cmd = { 0 }; 442 int err; 443 444 /* prepare command */ 445 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_RX_QUEUE, 446 cmd_flags, 447 token); 448 DPSECI_CMD_GET_RX_QUEUE(cmd, queue); 449 450 /* send command to mc */ 451 err = mc_send_command(mc_io, &cmd); 452 if (err) 453 return err; 454 455 /* retrieve response parameters */ 456 DPSECI_RSP_GET_RX_QUEUE(cmd, attr); 457 458 return 0; 459 } 460 461 int 462 dpseci_get_tx_queue(struct fsl_mc_io *mc_io, 463 uint32_t cmd_flags, 464 uint16_t token, 465 uint8_t queue, 466 struct dpseci_tx_queue_attr *attr) 467 { 468 struct mc_command cmd = { 0 }; 469 int err; 470 471 /* prepare command */ 472 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_TX_QUEUE, 473 cmd_flags, 474 token); 475 DPSECI_CMD_GET_TX_QUEUE(cmd, queue); 476 477 /* send command to mc */ 478 err = mc_send_command(mc_io, &cmd); 479 if (err) 480 return err; 481 482 /* retrieve response parameters */ 483 DPSECI_RSP_GET_TX_QUEUE(cmd, attr); 484 485 return 0; 486 } 487 488 int 489 dpseci_get_sec_attr(struct fsl_mc_io *mc_io, 490 uint32_t cmd_flags, 491 uint16_t token, 492 struct dpseci_sec_attr *attr) 493 { 494 struct mc_command cmd = { 0 }; 495 int err; 496 497 /* prepare command */ 498 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_SEC_ATTR, 499 cmd_flags, 500 token); 501 502 /* send command to mc */ 503 err = mc_send_command(mc_io, &cmd); 504 if (err) 505 return err; 506 507 /* retrieve response parameters */ 508 DPSECI_RSP_GET_SEC_ATTR(cmd, attr); 509 510 return 0; 511 } 512 513 int 514 dpseci_get_sec_counters(struct fsl_mc_io *mc_io, 515 uint32_t cmd_flags, 516 uint16_t token, 517 struct dpseci_sec_counters *counters) 518 { 519 struct mc_command cmd = { 0 }; 520 int err; 521 522 /* prepare command */ 523 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_SEC_COUNTERS, 524 cmd_flags, 525 token); 526 527 /* send command to mc */ 528 err = mc_send_command(mc_io, &cmd); 529 if (err) 530 return err; 531 532 /* retrieve response parameters */ 533 DPSECI_RSP_GET_SEC_COUNTERS(cmd, counters); 534 535 return 0; 536 } 537 538 int 539 dpseci_get_api_version(struct fsl_mc_io *mc_io, 540 uint32_t cmd_flags, 541 uint16_t *major_ver, 542 uint16_t *minor_ver) 543 { 544 struct mc_command cmd = { 0 }; 545 int err; 546 547 cmd.header = mc_encode_cmd_header(DPSECI_CMDID_GET_API_VERSION, 548 cmd_flags, 549 0); 550 551 err = mc_send_command(mc_io, &cmd); 552 if (err) 553 return err; 554 555 DPSECI_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver); 556 557 return 0; 558 } 559