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