drivers/net/fsl-mc/dpni.c

   1 /*
   2  * Copyright (C) 2013-2015 Freescale Semiconductor
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   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_open(struct fsl_mc_io *mc_io,
  12               uint32_t cmd_flags,
  13               int dpni_id,
  14               uint16_t *token)
  15 {
  16         struct mc_command cmd = { 0 };
  17         int err;
  18
  19         /* prepare command */
  20         cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
  21                                           cmd_flags,
  22                                           0);
  23         DPNI_CMD_OPEN(cmd, dpni_id);
  24
  25         /* send command to mc*/
  26         err = mc_send_command(mc_io, &cmd);
  27         if (err)
  28                 return err;
  29
  30         /* retrieve response parameters */
  31         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  32
  33         return 0;
  34 }
  35
  36 int dpni_close(struct fsl_mc_io *mc_io,
  37                uint32_t cmd_flags,
  38                uint16_t token)
  39 {
  40         struct mc_command cmd = { 0 };
  41
  42         /* prepare command */
  43         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
  44                                           cmd_flags,
  45                                           token);
  46
  47         /* send command to mc*/
  48         return mc_send_command(mc_io, &cmd);
  49 }
  50
  51 int dpni_create(struct fsl_mc_io *mc_io,
  52                 uint32_t cmd_flags,
  53                 const struct dpni_cfg *cfg,
  54                 uint16_t *token)
  55 {
  56         struct mc_command cmd = { 0 };
  57         int err;
  58
  59         /* prepare command */
  60         cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
  61                                           cmd_flags,
  62                                           0);
  63         DPNI_CMD_CREATE(cmd, cfg);
  64
  65         /* send command to mc*/
  66         err = mc_send_command(mc_io, &cmd);
  67         if (err)
  68                 return err;
  69
  70         /* retrieve response parameters */
  71         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  72
  73         return 0;
  74 }
  75
  76 int dpni_destroy(struct fsl_mc_io *mc_io,
  77                  uint32_t cmd_flags,
  78                  uint16_t token)
  79 {
  80         struct mc_command cmd = { 0 };
  81
  82         /* prepare command */
  83         cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
  84                                           cmd_flags,
  85                                           token);
  86
  87         /* send command to mc*/
  88         return mc_send_command(mc_io, &cmd);
  89 }
  90
  91 int dpni_set_pools(struct fsl_mc_io *mc_io,
  92                    uint32_t cmd_flags,
  93                    uint16_t token,
  94                    const struct dpni_pools_cfg *cfg)
  95 {
  96         struct mc_command cmd = { 0 };
  97
  98         /* prepare command */
  99         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
 100                                           cmd_flags,
 101                                           token);
 102         DPNI_CMD_SET_POOLS(cmd, cfg);
 103
 104         /* send command to mc*/
 105         return mc_send_command(mc_io, &cmd);
 106 }
 107
 108 int dpni_enable(struct fsl_mc_io *mc_io,
 109                 uint32_t cmd_flags,
 110                 uint16_t token)
 111 {
 112         struct mc_command cmd = { 0 };
 113
 114         /* prepare command */
 115         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
 116                                           cmd_flags,
 117                                           token);
 118
 119         /* send command to mc*/
 120         return mc_send_command(mc_io, &cmd);
 121 }
 122
 123 int dpni_disable(struct fsl_mc_io *mc_io,
 124                  uint32_t cmd_flags,
 125                  uint16_t token)
 126 {
 127         struct mc_command cmd = { 0 };
 128
 129         /* prepare command */
 130         cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
 131                                           cmd_flags,
 132                                           token);
 133
 134         /* send command to mc*/
 135         return mc_send_command(mc_io, &cmd);
 136 }
 137
 138 int dpni_reset(struct fsl_mc_io *mc_io,
 139                uint32_t cmd_flags,
 140                uint16_t token)
 141 {
 142         struct mc_command cmd = { 0 };
 143
 144         /* prepare command */
 145         cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
 146                                           cmd_flags,
 147                                           token);
 148
 149         /* send command to mc*/
 150         return mc_send_command(mc_io, &cmd);
 151 }
 152
 153 int dpni_get_attributes(struct fsl_mc_io *mc_io,
 154                         uint32_t cmd_flags,
 155                         uint16_t token,
 156                         struct dpni_attr *attr)
 157 {
 158         struct mc_command cmd = { 0 };
 159         int err;
 160
 161         /* prepare command */
 162         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
 163                                           cmd_flags,
 164                                           token);
 165
 166         /* send command to mc*/
 167         err = mc_send_command(mc_io, &cmd);
 168         if (err)
 169                 return err;
 170
 171         /* retrieve response parameters */
 172         DPNI_RSP_GET_ATTR(cmd, attr);
 173
 174         return 0;
 175 }
 176
 177 int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io,
 178                               uint32_t cmd_flags,
 179                               uint16_t token,
 180                               struct dpni_buffer_layout *layout)
 181 {
 182         struct mc_command cmd = { 0 };
 183         int err;
 184
 185         /* prepare command */
 186         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_BUFFER_LAYOUT,
 187                                           cmd_flags,
 188                                           token);
 189
 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_RX_BUFFER_LAYOUT(cmd, layout);
 197
 198         return 0;
 199 }
 200
 201 int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io,
 202                               uint32_t cmd_flags,
 203                               uint16_t token,
 204                               const struct dpni_buffer_layout *layout)
 205 {
 206         struct mc_command cmd = { 0 };
 207
 208         /* prepare command */
 209         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_BUFFER_LAYOUT,
 210                                           cmd_flags,
 211                                           token);
 212         DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout);
 213
 214         /* send command to mc*/
 215         return mc_send_command(mc_io, &cmd);
 216 }
 217
 218 int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io,
 219                               uint32_t cmd_flags,
 220                               uint16_t token,
 221                               struct dpni_buffer_layout *layout)
 222 {
 223         struct mc_command cmd = { 0 };
 224         int err;
 225
 226         /* prepare command */
 227         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_BUFFER_LAYOUT,
 228                                           cmd_flags,
 229                                           token);
 230
 231         /* send command to mc*/
 232         err = mc_send_command(mc_io, &cmd);
 233         if (err)
 234                 return err;
 235
 236         /* retrieve response parameters */
 237         DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout);
 238
 239         return 0;
 240 }
 241
 242 int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io,
 243                               uint32_t cmd_flags,
 244                               uint16_t token,
 245                               const struct dpni_buffer_layout *layout)
 246 {
 247         struct mc_command cmd = { 0 };
 248
 249         /* prepare command */
 250         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_BUFFER_LAYOUT,
 251                                           cmd_flags,
 252                                           token);
 253         DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout);
 254
 255         /* send command to mc*/
 256         return mc_send_command(mc_io, &cmd);
 257 }
 258
 259 int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
 260                                    uint32_t cmd_flags,
 261                                    uint16_t token,
 262                                    struct dpni_buffer_layout *layout)
 263 {
 264         struct mc_command cmd = { 0 };
 265         int err;
 266
 267         /* prepare command */
 268         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT,
 269                                           cmd_flags,
 270                                           token);
 271
 272         /* send command to mc*/
 273         err = mc_send_command(mc_io, &cmd);
 274         if (err)
 275                 return err;
 276
 277         /* retrieve response parameters */
 278         DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
 279
 280         return 0;
 281 }
 282
 283 int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
 284                                    uint32_t cmd_flags,
 285                                    uint16_t token,
 286                                    const struct dpni_buffer_layout *layout)
 287 {
 288         struct mc_command cmd = { 0 };
 289
 290         /* prepare command */
 291         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT,
 292                                           cmd_flags,
 293                                           token);
 294         DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
 295
 296         /* send command to mc*/
 297         return mc_send_command(mc_io, &cmd);
 298 }
 299
 300 int dpni_get_qdid(struct fsl_mc_io *mc_io,
 301                   uint32_t cmd_flags,
 302                   uint16_t token,
 303                   uint16_t *qdid)
 304 {
 305         struct mc_command cmd = { 0 };
 306         int err;
 307
 308         /* prepare command */
 309         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
 310                                           cmd_flags,
 311                                           token);
 312
 313         /* send command to mc*/
 314         err = mc_send_command(mc_io, &cmd);
 315         if (err)
 316                 return err;
 317
 318         /* retrieve response parameters */
 319         DPNI_RSP_GET_QDID(cmd, *qdid);
 320
 321         return 0;
 322 }
 323
 324 int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
 325                             uint32_t cmd_flags,
 326                             uint16_t token,
 327                             uint16_t *data_offset)
 328 {
 329         struct mc_command cmd = { 0 };
 330         int err;
 331
 332         /* prepare command */
 333         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
 334                                           cmd_flags,
 335                                           token);
 336
 337         /* send command to mc*/
 338         err = mc_send_command(mc_io, &cmd);
 339         if (err)
 340                 return err;
 341
 342         /* retrieve response parameters */
 343         DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset);
 344
 345         return 0;
 346 }
 347
 348 int dpni_get_counter(struct fsl_mc_io *mc_io,
 349                      uint32_t cmd_flags,
 350                      uint16_t token,
 351                      enum dpni_counter counter,
 352                      uint64_t *value)
 353 {
 354         struct mc_command cmd = { 0 };
 355         int err;
 356
 357         /* prepare command */
 358         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_COUNTER,
 359                                           cmd_flags,
 360                                           token);
 361         DPNI_CMD_GET_COUNTER(cmd, counter);
 362
 363         /* send command to mc*/
 364         err = mc_send_command(mc_io, &cmd);
 365         if (err)
 366                 return err;
 367
 368         /* retrieve response parameters */
 369         DPNI_RSP_GET_COUNTER(cmd, *value);
 370
 371         return 0;
 372 }
 373
 374 int dpni_set_counter(struct fsl_mc_io *mc_io,
 375                      uint32_t cmd_flags,
 376                      uint16_t token,
 377                      enum dpni_counter counter,
 378                      uint64_t value)
 379 {
 380         struct mc_command cmd = { 0 };
 381
 382         /* prepare command */
 383         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_COUNTER,
 384                                           cmd_flags,
 385                                           token);
 386         DPNI_CMD_SET_COUNTER(cmd, counter, value);
 387
 388         /* send command to mc*/
 389         return mc_send_command(mc_io, &cmd);
 390 }
 391
 392 int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
 393                       uint32_t cmd_flags,
 394                       uint16_t token,
 395                       const struct dpni_link_cfg *cfg)
 396 {
 397         struct mc_command cmd = { 0 };
 398
 399         /* prepare command */
 400         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
 401                                           cmd_flags,
 402                                           token);
 403         DPNI_CMD_SET_LINK_CFG(cmd, cfg);
 404
 405         /* send command to mc*/
 406         return mc_send_command(mc_io, &cmd);
 407 }
 408
 409 int dpni_get_link_state(struct fsl_mc_io *mc_io,
 410                         uint32_t cmd_flags,
 411                         uint16_t token,
 412                         struct dpni_link_state *state)
 413 {
 414         struct mc_command cmd = { 0 };
 415         int err;
 416
 417         /* prepare command */
 418         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
 419                                           cmd_flags,
 420                                           token);
 421
 422         /* send command to mc*/
 423         err = mc_send_command(mc_io, &cmd);
 424         if (err)
 425                 return err;
 426
 427         /* retrieve response parameters */
 428         DPNI_RSP_GET_LINK_STATE(cmd, state);
 429
 430         return 0;
 431 }
 432
 433
 434 int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
 435                               uint32_t cmd_flags,
 436                               uint16_t token,
 437                               const uint8_t mac_addr[6])
 438 {
 439         struct mc_command cmd = { 0 };
 440
 441         /* prepare command */
 442         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
 443                                           cmd_flags,
 444                                           token);
 445         DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 446
 447         /* send command to mc*/
 448         return mc_send_command(mc_io, &cmd);
 449 }
 450
 451 int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
 452                               uint32_t cmd_flags,
 453                               uint16_t token,
 454                               uint8_t mac_addr[6])
 455 {
 456         struct mc_command cmd = { 0 };
 457         int err;
 458
 459         /* prepare command */
 460         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
 461                                           cmd_flags,
 462                                           token);
 463
 464         /* send command to mc*/
 465         err = mc_send_command(mc_io, &cmd);
 466         if (err)
 467                 return err;
 468
 469         /* retrieve response parameters */
 470         DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
 471
 472         return 0;
 473 }
 474
 475 int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
 476                       uint32_t cmd_flags,
 477                       uint16_t token,
 478                       const uint8_t mac_addr[6])
 479 {
 480         struct mc_command cmd = { 0 };
 481
 482         /* prepare command */
 483         cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
 484                                           cmd_flags,
 485                                           token);
 486         DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
 487
 488         /* send command to mc*/
 489         return mc_send_command(mc_io, &cmd);
 490 }
 491
 492 int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
 493                          uint32_t cmd_flags,
 494                          uint16_t token,
 495                          const uint8_t mac_addr[6])
 496 {
 497         struct mc_command cmd = { 0 };
 498
 499         /* prepare command */
 500         cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
 501                                           cmd_flags,
 502                                           token);
 503         DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
 504
 505         /* send command to mc*/
 506         return mc_send_command(mc_io, &cmd);
 507 }
 508
 509 int dpni_set_tx_flow(struct fsl_mc_io *mc_io,
 510                      uint32_t cmd_flags,
 511                      uint16_t token,
 512                      uint16_t *flow_id,
 513                      const struct dpni_tx_flow_cfg *cfg)
 514 {
 515         struct mc_command cmd = { 0 };
 516         int err;
 517
 518         /* prepare command */
 519         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_FLOW,
 520                                           cmd_flags,
 521                                           token);
 522         DPNI_CMD_SET_TX_FLOW(cmd, *flow_id, cfg);
 523
 524         /* send command to mc*/
 525         err = mc_send_command(mc_io, &cmd);
 526         if (err)
 527                 return err;
 528
 529         /* retrieve response parameters */
 530         DPNI_RSP_SET_TX_FLOW(cmd, *flow_id);
 531
 532         return 0;
 533 }
 534
 535 int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
 536                      uint32_t cmd_flags,
 537                      uint16_t token,
 538                      uint16_t flow_id,
 539                      struct dpni_tx_flow_attr *attr)
 540 {
 541         struct mc_command cmd = { 0 };
 542         int err;
 543
 544         /* prepare command */
 545         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_FLOW,
 546                                           cmd_flags,
 547                                           token);
 548         DPNI_CMD_GET_TX_FLOW(cmd, flow_id);
 549
 550         /* send command to mc*/
 551         err = mc_send_command(mc_io, &cmd);
 552         if (err)
 553                 return err;
 554
 555         /* retrieve response parameters */
 556         DPNI_RSP_GET_TX_FLOW(cmd, attr);
 557
 558         return 0;
 559 }
 560
 561 int dpni_set_rx_flow(struct fsl_mc_io *mc_io,
 562                      uint32_t cmd_flags,
 563                      uint16_t token,
 564                      uint8_t tc_id,
 565                      uint16_t flow_id,
 566                      const struct dpni_queue_cfg *cfg)
 567 {
 568         struct mc_command cmd = { 0 };
 569
 570         /* prepare command */
 571         cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FLOW,
 572                                           cmd_flags,
 573                                           token);
 574         DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg);
 575
 576         /* send command to mc*/
 577         return mc_send_command(mc_io, &cmd);
 578 }
 579
 580 int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
 581                      uint32_t cmd_flags,
 582                      uint16_t token,
 583                      uint8_t tc_id,
 584                      uint16_t flow_id,
 585                      struct dpni_queue_attr *attr)
 586 {
 587         struct mc_command cmd = { 0 };
 588         int err;
 589         /* prepare command */
 590         cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_FLOW,
 591                                           cmd_flags,
 592                                           token);
 593         DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id);
 594
 595         /* send command to mc*/
 596         err = mc_send_command(mc_io, &cmd);
 597         if (err)
 598                 return err;
 599
 600         /* retrieve response parameters */
 601         DPNI_RSP_GET_RX_FLOW(cmd, attr);
 602
 603         return 0;
 604 }