1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2013-2016 Freescale Semiconductor, Inc. 4 * Copyright 2017 NXP 5 */ 6 7 #include <fsl-mc/fsl_mc_sys.h> 8 #include <fsl-mc/fsl_mc_cmd.h> 9 #include <fsl-mc/fsl_dpni.h> 10 11 int dpni_prepare_cfg(const struct dpni_cfg *cfg, 12 uint8_t *cfg_buf) 13 { 14 uint64_t *params = (uint64_t *)cfg_buf; 15 16 DPNI_PREP_CFG(params, cfg); 17 18 return 0; 19 } 20 21 int dpni_extract_cfg(struct dpni_cfg *cfg, 22 const uint8_t *cfg_buf) 23 { 24 uint64_t *params = (uint64_t *)cfg_buf; 25 26 DPNI_EXT_CFG(params, cfg); 27 28 return 0; 29 } 30 31 int dpni_open(struct fsl_mc_io *mc_io, 32 uint32_t cmd_flags, 33 int dpni_id, 34 uint16_t *token) 35 { 36 struct mc_command cmd = { 0 }; 37 int err; 38 39 /* prepare command */ 40 cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN, 41 cmd_flags, 42 0); 43 DPNI_CMD_OPEN(cmd, dpni_id); 44 45 /* send command to mc*/ 46 err = mc_send_command(mc_io, &cmd); 47 if (err) 48 return err; 49 50 /* retrieve response parameters */ 51 *token = MC_CMD_HDR_READ_TOKEN(cmd.header); 52 53 return 0; 54 } 55 56 int dpni_close(struct fsl_mc_io *mc_io, 57 uint32_t cmd_flags, 58 uint16_t token) 59 { 60 struct mc_command cmd = { 0 }; 61 62 /* prepare command */ 63 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE, 64 cmd_flags, 65 token); 66 67 /* send command to mc*/ 68 return mc_send_command(mc_io, &cmd); 69 } 70 71 int dpni_create(struct fsl_mc_io *mc_io, 72 uint16_t dprc_token, 73 uint32_t cmd_flags, 74 const struct dpni_cfg *cfg, 75 uint32_t *obj_id) 76 { 77 struct mc_command cmd = { 0 }; 78 int err; 79 80 /* prepare command */ 81 cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE, 82 cmd_flags, 83 dprc_token); 84 DPNI_CMD_CREATE(cmd, cfg); 85 86 /* send command to mc*/ 87 err = mc_send_command(mc_io, &cmd); 88 if (err) 89 return err; 90 91 /* retrieve response parameters */ 92 MC_CMD_READ_OBJ_ID(cmd, *obj_id); 93 94 return 0; 95 } 96 97 int dpni_destroy(struct fsl_mc_io *mc_io, 98 uint16_t dprc_token, 99 uint32_t cmd_flags, 100 uint32_t obj_id) 101 { 102 struct mc_command cmd = { 0 }; 103 104 /* prepare command */ 105 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY, 106 cmd_flags, 107 dprc_token); 108 109 /* set object id to destroy */ 110 CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id); 111 112 /* send command to mc*/ 113 return mc_send_command(mc_io, &cmd); 114 } 115 116 int dpni_set_pools(struct fsl_mc_io *mc_io, 117 uint32_t cmd_flags, 118 uint16_t token, 119 const struct dpni_pools_cfg *cfg) 120 { 121 struct mc_command cmd = { 0 }; 122 123 /* prepare command */ 124 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS, 125 cmd_flags, 126 token); 127 DPNI_CMD_SET_POOLS(cmd, cfg); 128 129 /* send command to mc*/ 130 return mc_send_command(mc_io, &cmd); 131 } 132 133 int dpni_enable(struct fsl_mc_io *mc_io, 134 uint32_t cmd_flags, 135 uint16_t token) 136 { 137 struct mc_command cmd = { 0 }; 138 139 /* prepare command */ 140 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE, 141 cmd_flags, 142 token); 143 144 /* send command to mc*/ 145 return mc_send_command(mc_io, &cmd); 146 } 147 148 int dpni_disable(struct fsl_mc_io *mc_io, 149 uint32_t cmd_flags, 150 uint16_t token) 151 { 152 struct mc_command cmd = { 0 }; 153 154 /* prepare command */ 155 cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE, 156 cmd_flags, 157 token); 158 159 /* send command to mc*/ 160 return mc_send_command(mc_io, &cmd); 161 } 162 163 int dpni_reset(struct fsl_mc_io *mc_io, 164 uint32_t cmd_flags, 165 uint16_t token) 166 { 167 struct mc_command cmd = { 0 }; 168 169 /* prepare command */ 170 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET, 171 cmd_flags, 172 token); 173 174 /* send command to mc*/ 175 return mc_send_command(mc_io, &cmd); 176 } 177 178 int dpni_get_attributes(struct fsl_mc_io *mc_io, 179 uint32_t cmd_flags, 180 uint16_t token, 181 struct dpni_attr *attr) 182 { 183 struct mc_command cmd = { 0 }; 184 int err; 185 186 /* prepare command */ 187 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR, 188 cmd_flags, 189 token); 190 /* send command to mc*/ 191 err = mc_send_command(mc_io, &cmd); 192 if (err) 193 return err; 194 195 /* retrieve response parameters */ 196 DPNI_RSP_GET_ATTR(cmd, attr); 197 198 return 0; 199 } 200 201 int dpni_set_errors_behavior(struct fsl_mc_io *mc_io, 202 uint32_t cmd_flags, 203 uint16_t token, 204 struct dpni_error_cfg *cfg) 205 { 206 struct mc_command cmd = { 0 }; 207 208 /* prepare command */ 209 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR, 210 cmd_flags, 211 token); 212 DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg); 213 214 /* send command to mc*/ 215 return mc_send_command(mc_io, &cmd); 216 } 217 218 int dpni_set_buffer_layout(struct fsl_mc_io *mc_io, 219 uint32_t cmd_flags, 220 uint16_t token, 221 const struct dpni_buffer_layout *layout, 222 enum dpni_queue_type type) 223 { 224 struct mc_command cmd = { 0 }; 225 226 /* prepare command */ 227 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT, 228 cmd_flags, 229 token); 230 DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type); 231 232 /* send command to mc*/ 233 return mc_send_command(mc_io, &cmd); 234 } 235 236 int dpni_get_qdid(struct fsl_mc_io *mc_io, 237 uint32_t cmd_flags, 238 uint16_t token, 239 uint16_t *qdid) 240 { 241 struct mc_command cmd = { 0 }; 242 int err; 243 244 /* prepare command */ 245 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID, 246 cmd_flags, 247 token); 248 249 /* send command to mc*/ 250 err = mc_send_command(mc_io, &cmd); 251 if (err) 252 return err; 253 254 /* retrieve response parameters */ 255 DPNI_RSP_GET_QDID(cmd, *qdid); 256 257 return 0; 258 } 259 260 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, 261 uint32_t cmd_flags, 262 uint16_t token, 263 uint16_t *data_offset) 264 { 265 struct mc_command cmd = { 0 }; 266 int err; 267 268 /* prepare command */ 269 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET, 270 cmd_flags, 271 token); 272 273 /* send command to mc*/ 274 err = mc_send_command(mc_io, &cmd); 275 if (err) 276 return err; 277 278 /* retrieve response parameters */ 279 DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset); 280 281 return 0; 282 } 283 284 int dpni_set_link_cfg(struct fsl_mc_io *mc_io, 285 uint32_t cmd_flags, 286 uint16_t token, 287 const struct dpni_link_cfg *cfg) 288 { 289 struct mc_command cmd = { 0 }; 290 291 /* prepare command */ 292 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG, 293 cmd_flags, 294 token); 295 DPNI_CMD_SET_LINK_CFG(cmd, cfg); 296 297 /* send command to mc*/ 298 return mc_send_command(mc_io, &cmd); 299 } 300 301 int dpni_get_link_state(struct fsl_mc_io *mc_io, 302 uint32_t cmd_flags, 303 uint16_t token, 304 struct dpni_link_state *state) 305 { 306 struct mc_command cmd = { 0 }; 307 int err; 308 309 /* prepare command */ 310 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE, 311 cmd_flags, 312 token); 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 DPNI_RSP_GET_LINK_STATE(cmd, state); 321 322 return 0; 323 } 324 325 326 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io, 327 uint32_t cmd_flags, 328 uint16_t token, 329 const uint8_t mac_addr[6]) 330 { 331 struct mc_command cmd = { 0 }; 332 333 /* prepare command */ 334 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC, 335 cmd_flags, 336 token); 337 DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr); 338 339 /* send command to mc*/ 340 return mc_send_command(mc_io, &cmd); 341 } 342 343 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io, 344 uint32_t cmd_flags, 345 uint16_t token, 346 uint8_t mac_addr[6]) 347 { 348 struct mc_command cmd = { 0 }; 349 int err; 350 351 /* prepare command */ 352 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC, 353 cmd_flags, 354 token); 355 356 /* send command to mc*/ 357 err = mc_send_command(mc_io, &cmd); 358 if (err) 359 return err; 360 361 /* retrieve response parameters */ 362 DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr); 363 364 return 0; 365 } 366 367 int dpni_add_mac_addr(struct fsl_mc_io *mc_io, 368 uint32_t cmd_flags, 369 uint16_t token, 370 const uint8_t mac_addr[6]) 371 { 372 struct mc_command cmd = { 0 }; 373 374 /* prepare command */ 375 cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR, 376 cmd_flags, 377 token); 378 DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr); 379 380 /* send command to mc*/ 381 return mc_send_command(mc_io, &cmd); 382 } 383 384 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io, 385 uint32_t cmd_flags, 386 uint16_t token, 387 const uint8_t mac_addr[6]) 388 { 389 struct mc_command cmd = { 0 }; 390 391 /* prepare command */ 392 cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR, 393 cmd_flags, 394 token); 395 DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr); 396 397 /* send command to mc*/ 398 return mc_send_command(mc_io, &cmd); 399 } 400 401 int dpni_get_api_version(struct fsl_mc_io *mc_io, 402 u32 cmd_flags, 403 u16 *major_ver, 404 u16 *minor_ver) 405 { 406 struct mc_command cmd = { 0 }; 407 int err; 408 409 /* prepare command */ 410 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION, 411 cmd_flags, 0); 412 413 /* send command to mc */ 414 err = mc_send_command(mc_io, &cmd); 415 if (err) 416 return err; 417 418 /* retrieve response parameters */ 419 mc_cmd_read_api_version(&cmd, major_ver, minor_ver); 420 421 return 0; 422 } 423 424 int dpni_set_queue(struct fsl_mc_io *mc_io, 425 uint32_t cmd_flags, 426 uint16_t token, 427 enum dpni_queue_type type, 428 uint8_t tc, 429 uint8_t index, 430 const struct dpni_queue *queue) 431 { 432 struct mc_command cmd = { 0 }; 433 /* prepare command */ 434 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE, 435 cmd_flags, 436 token); 437 DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue); 438 439 /* send command to mc*/ 440 return mc_send_command(mc_io, &cmd); 441 } 442 443 int dpni_get_queue(struct fsl_mc_io *mc_io, 444 uint32_t cmd_flags, 445 uint16_t token, 446 enum dpni_queue_type type, 447 uint8_t tc, 448 uint8_t index, 449 struct dpni_queue *queue) 450 { 451 struct mc_command cmd = { 0 }; 452 int err; 453 454 /* prepare command */ 455 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE, 456 cmd_flags, 457 token); 458 DPNI_CMD_GET_QUEUE(cmd, type, tc, index); 459 460 /* send command to mc*/ 461 err = mc_send_command(mc_io, &cmd); 462 if (err) 463 return err; 464 465 /* retrieve response parameters */ 466 DPNI_RSP_GET_QUEUE(cmd, queue); 467 return 0; 468 } 469 470 int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io, 471 uint32_t cmd_flags, 472 uint16_t token, 473 enum dpni_confirmation_mode mode) 474 { 475 struct dpni_tx_confirmation_mode *cmd_params; 476 struct mc_command cmd = { 0 }; 477 478 /* prepare command */ 479 cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE, 480 cmd_flags, 481 token); 482 483 cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params; 484 cmd_params->confirmation_mode = mode; 485 486 /* send command to mc*/ 487 return mc_send_command(mc_io, &cmd); 488 } 489 490 int dpni_get_statistics(struct fsl_mc_io *mc_io, 491 uint32_t cmd_flags, 492 uint16_t token, 493 uint8_t page, 494 struct dpni_statistics *stat) 495 { 496 struct mc_command cmd = { 0 }; 497 int err; 498 499 /* prepare command */ 500 cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS, 501 cmd_flags, token); 502 DPNI_CMD_GET_STATISTICS(cmd, page); 503 504 /* send command to mc*/ 505 err = mc_send_command(mc_io, &cmd); 506 if (err) 507 return err; 508 509 /* retrieve response parameters */ 510 DPNI_RSP_GET_STATISTICS(cmd, stat); 511 512 return 0; 513 } 514 515 int dpni_reset_statistics(struct fsl_mc_io *mc_io, 516 uint32_t cmd_flags, 517 uint16_t token) 518 { 519 struct mc_command cmd = { 0 }; 520 521 /* prepare command */ 522 cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS, 523 cmd_flags, token); 524 525 /* send command to mc*/ 526 return mc_send_command(mc_io, &cmd); 527 } 528 529