colin/u-boot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

net: fsl-mc: sync DPNI MC APIs

Browse Source 
Sync the Data Path Network Interface APIs to their latest form, this
means the layout of each command is created based on structures which
clearly describe the endianness of each field rather than some macros.

The command version is kept in place, meaning that the minimum MC
version accepted is not changed in any way.

Signed-off-by: Ioana Ciornei <ioana.ciornei@nxp.com>
Signed-off-by: Peng Fan <peng.fan@nxp.com>
This commit is contained in:
Ioana Ciornei
2023-05-31 19:04:33 +03:00
committed by Peng Fan
parent 95f309a4f8
commit 207c815770
4 changed files with 1001 additions and 740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

634
drivers/net/fsl-mc/dpni.c
View File

@@ -1,36 +1,43 @@
// SPDX-License-Identifier: GPL-2.0+ // SPDX-License-Identifier: GPL-2.0+
/* /*
* Copyright 2013-2016 Freescale Semiconductor, Inc. * Copyright 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP * Copyright 2017, 2023 NXP
*/ */
#include <fsl-mc/fsl_mc_sys.h> #include <fsl-mc/fsl_mc_sys.h>
#include <fsl-mc/fsl_mc_cmd.h> #include <fsl-mc/fsl_mc_cmd.h>
#include <fsl-mc/fsl_dpni.h> #include <fsl-mc/fsl_dpni.h>
int dpni_prepare_cfg(const struct dpni_cfg *cfg, /**
uint8_t *cfg_buf) * dpni_open() - Open a control session for the specified object
{ * @mc_io: Pointer to MC portal's I/O object
uint64_t *params = (uint64_t *)cfg_buf; * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @dpni_id: DPNI unique ID
DPNI_PREP_CFG(params, cfg); * @token: Returned token; use in subsequent API calls
*
return 0; * This function can be used to open a control session for an
} * already created object; an object may have been declared in
* the DPL or by calling the dpni_create() function.
int dpni_open(struct fsl_mc_io *mc_io, * This function returns a unique authentication token,
uint32_t cmd_flags, * associated with the specific object ID and the specific MC
int dpni_id, * portal; this token must be used in all subsequent commands for
uint16_t *token) * this specific object.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_open(struct fsl_mc_io *mc_io, u32 cmd_flags, int dpni_id, u16 *token)
{ {
struct dpni_cmd_open *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
int err; int err;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN, cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
cmd_flags, cmd_flags,
0); 0);
DPNI_CMD_OPEN(cmd, dpni_id); cmd_params = (struct dpni_cmd_open *)cmd.params;
cmd_params->dpni_id = cpu_to_le32(dpni_id);
/* send command to mc*/ /* send command to mc*/
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
@@ -38,14 +45,23 @@ int dpni_open(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header); *token = mc_cmd_hdr_read_token(&cmd);
return 0; return 0;
} }
int dpni_close(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_close() - Close the control session of the object
uint16_t token) * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
*
* After this function is called, no further operations are
* allowed on the object without opening a new control session.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
@@ -58,12 +74,32 @@ int dpni_close(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_create(struct fsl_mc_io *mc_io, /**
uint16_t dprc_token, * dpni_create() - Create the DPNI object
uint32_t cmd_flags, * @mc_io: Pointer to MC portal's I/O object
const struct dpni_cfg *cfg, * @dprc_token: Parent container token; '0' for default container
uint32_t *obj_id) * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @obj_id: Returned object id
*
* Create the DPNI object, allocate required resources and
* perform required initialization.
*
* The object can be created either by declaring it in the
* DPL file, or by calling this function.
*
* The function accepts an authentication token of a parent
* container that this object should be assigned to. The token
* can be '0' so the object will be assigned to the default container.
* The newly created object can be opened with the returned
* object id and using the container's associated tokens and MC portals.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_create(struct fsl_mc_io *mc_io, u16 dprc_token, u32 cmd_flags,
const struct dpni_cfg *cfg, u32 *obj_id)
{ {
struct dpni_cmd_create *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
int err; int err;
@@ -71,7 +107,19 @@ int dpni_create(struct fsl_mc_io *mc_io,
cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE, cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
cmd_flags, cmd_flags,
dprc_token); dprc_token);
DPNI_CMD_CREATE(cmd, cfg); cmd_params = (struct dpni_cmd_create *)cmd.params;
cmd_params->options = cpu_to_le32(cfg->options);
cmd_params->num_queues = cfg->num_queues;
cmd_params->num_tcs = cfg->num_tcs;
cmd_params->mac_filter_entries = cfg->mac_filter_entries;
cmd_params->num_rx_tcs = cfg->num_rx_tcs;
cmd_params->vlan_filter_entries = cfg->vlan_filter_entries;
cmd_params->qos_entries = cfg->qos_entries;
cmd_params->fs_entries = cpu_to_le16(cfg->fs_entries);
cmd_params->num_cgs = cfg->num_cgs;
cmd_params->num_opr = cfg->num_opr;
cmd_params->dist_key_size = cfg->dist_key_size;
cmd_params->num_channels = cfg->num_channels;
/* send command to mc*/ /* send command to mc*/
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
@@ -79,50 +127,94 @@ int dpni_create(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
MC_CMD_READ_OBJ_ID(cmd, *obj_id); *obj_id = mc_cmd_read_object_id(&cmd);
return 0; return 0;
} }
int dpni_destroy(struct fsl_mc_io *mc_io, /**
uint16_t dprc_token, * dpni_destroy() - Destroy the DPNI object and release all its resources.
uint32_t cmd_flags, * @mc_io: Pointer to MC portal's I/O object
uint32_t obj_id) * @dprc_token: Parent container token; '0' for default container
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @object_id: The object id; it must be a valid id within the container that
* created this object;
*
* The function accepts the authentication token of the parent container that
* created the object (not the one that currently owns the object). The object
* is searched within parent using the provided 'object_id'.
* All tokens to the object must be closed before calling destroy.
*
* Return: '0' on Success; error code otherwise.
*/
int dpni_destroy(struct fsl_mc_io *mc_io, u16 dprc_token, u32 cmd_flags,
u32 object_id)
{ {
struct dpni_cmd_destroy *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY, cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
cmd_flags, cmd_flags,
dprc_token); dprc_token);
/* set object id to destroy */ /* set object id to destroy */
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id); cmd_params = (struct dpni_cmd_destroy *)cmd.params;
cmd_params->dpni_id = cpu_to_le32(object_id);
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_set_pools(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_set_pools() - Set buffer pools configuration
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @cfg: Buffer pools configuration
*
* mandatory for DPNI operation
* warning:Allowed only when DPNI is disabled
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_pools(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
const struct dpni_pools_cfg *cfg) const struct dpni_pools_cfg *cfg)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_cmd_set_pools *cmd_params;
int i;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS, cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
cmd_flags, cmd_flags,
token); token);
DPNI_CMD_SET_POOLS(cmd, cfg); cmd_params = (struct dpni_cmd_set_pools *)cmd.params;
cmd_params->num_dpbp = cfg->num_dpbp;
cmd_params->pool_options = cfg->pool_options;
for (i = 0; i < DPNI_MAX_DPBP; i++) {
cmd_params->pool[i].dpbp_id =
cpu_to_le16(cfg->pools[i].dpbp_id);
cmd_params->pool[i].priority_mask =
cfg->pools[i].priority_mask;
cmd_params->buffer_size[i] =
cpu_to_le16(cfg->pools[i].buffer_size);
cmd_params->backup_pool_mask |=
DPNI_BACKUP_POOL(cfg->pools[i].backup_pool, i);
}
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_enable(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
uint16_t token) * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
@@ -135,9 +227,15 @@ int dpni_enable(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_disable(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
uint16_t token) * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
@@ -150,9 +248,15 @@ int dpni_disable(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_reset(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_reset() - Reset the DPNI, returns the object to initial state.
uint16_t token) * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
@@ -165,59 +269,121 @@ int dpni_reset(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_get_attributes(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_get_attributes() - Retrieve DPNI attributes.
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @attr: Object's attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
struct dpni_attr *attr) struct dpni_attr *attr)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_rsp_get_attr *rsp_params;
int err; int err;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR, cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
cmd_flags, cmd_flags,
token); token);
/* send command to mc*/ /* send command to mc*/
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
if (err) if (err)
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
DPNI_RSP_GET_ATTR(cmd, attr); rsp_params = (struct dpni_rsp_get_attr *)cmd.params;
attr->options = le32_to_cpu(rsp_params->options);
attr->num_queues = rsp_params->num_queues;
attr->num_rx_tcs = rsp_params->num_rx_tcs;
attr->num_tx_tcs = rsp_params->num_tx_tcs;
attr->mac_filter_entries = rsp_params->mac_filter_entries;
attr->vlan_filter_entries = rsp_params->vlan_filter_entries;
attr->num_channels = rsp_params->num_channels;
attr->qos_entries = rsp_params->qos_entries;
attr->fs_entries = le16_to_cpu(rsp_params->fs_entries);
attr->num_opr = le16_to_cpu(rsp_params->num_opr);
attr->qos_key_size = rsp_params->qos_key_size;
attr->fs_key_size = rsp_params->fs_key_size;
attr->wriop_version = le16_to_cpu(rsp_params->wriop_version);
attr->num_cgs = rsp_params->num_cgs;
return 0; return 0;
} }
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_set_buffer_layout() - Set buffer layout configuration.
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
const struct dpni_buffer_layout *layout, * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
enum dpni_queue_type type) * @token: Token of DPNI object
* @qtype: Type of queue this configuration applies to
* @layout: Buffer layout configuration
*
* Return: '0' on Success; Error code otherwise.
*
* @warning Allowed only when DPNI is disabled
*/
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype,
const struct dpni_buffer_layout *layout)
{ {
struct dpni_cmd_set_buffer_layout *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT, cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
cmd_flags, cmd_flags,
token); token);
DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type); cmd_params = (struct dpni_cmd_set_buffer_layout *)cmd.params;
cmd_params->qtype = qtype;
cmd_params->options = cpu_to_le16((u16)layout->options);
dpni_set_field(cmd_params->flags, PASS_TS, layout->pass_timestamp);
dpni_set_field(cmd_params->flags, PASS_PR, layout->pass_parser_result);
dpni_set_field(cmd_params->flags, PASS_FS, layout->pass_frame_status);
dpni_set_field(cmd_params->flags, PASS_SWO, layout->pass_sw_opaque);
cmd_params->private_data_size = cpu_to_le16(layout->private_data_size);
cmd_params->data_align = cpu_to_le16(layout->data_align);
cmd_params->head_room = cpu_to_le16(layout->data_head_room);
cmd_params->tail_room = cpu_to_le16(layout->data_tail_room);
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_get_qdid(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
uint16_t token, * for enqueue operations
uint16_t *qdid) * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @qtype: Type of queue to receive QDID for
* @qdid: Returned virtual QDID value that should be used as an argument
* in all enqueue operations
*
* Return: '0' on Success; Error code otherwise.
*
* If dpni object is created using multiple Tc channels this function will return
* qdid value for the first channel
*/
int dpni_get_qdid(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 *qdid)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_cmd_get_qdid *cmd_params;
struct dpni_rsp_get_qdid *rsp_params;
int err; int err;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID, cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
cmd_flags, cmd_flags,
token); token);
cmd_params = (struct dpni_cmd_get_qdid *)cmd.params;
cmd_params->qtype = qtype;
/* send command to mc*/ /* send command to mc*/
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
@@ -225,17 +391,26 @@ int dpni_get_qdid(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
DPNI_RSP_GET_QDID(cmd, *qdid); rsp_params = (struct dpni_rsp_get_qdid *)cmd.params;
*qdid = le16_to_cpu(rsp_params->qdid);
return 0; return 0;
} }
int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
uint16_t *data_offset) * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @data_offset: Tx data offset (from start of buffer)
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
u16 *data_offset)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_rsp_get_tx_data_offset *rsp_params;
int err; int err;
/* prepare command */ /* prepare command */
@@ -249,34 +424,54 @@ int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset); rsp_params = (struct dpni_rsp_get_tx_data_offset *)cmd.params;
*data_offset = le16_to_cpu(rsp_params->data_offset);
return 0; return 0;
} }
int dpni_set_link_cfg(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_set_link_cfg() - set the link configuration.
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @cfg: Link configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_link_cfg(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
const struct dpni_link_cfg *cfg) const struct dpni_link_cfg *cfg)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_cmd_set_link_cfg *cmd_params;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG, cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
cmd_flags, cmd_flags,
token); token);
DPNI_CMD_SET_LINK_CFG(cmd, cfg); cmd_params = (struct dpni_cmd_set_link_cfg *)cmd.params;
cmd_params->rate = cpu_to_le32(cfg->rate);
cmd_params->options = cpu_to_le64(cfg->options);
cmd_params->advertising = cpu_to_le64(cfg->advertising);
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_get_link_state(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_get_link_state() - Return the link state (either up or down)
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @state: Returned link state;
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_link_state(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
struct dpni_link_state *state) struct dpni_link_state *state)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
struct dpni_rsp_get_link_state *rsp_params;
int err; int err;
/* prepare command */ /* prepare command */
@@ -290,39 +485,171 @@ int dpni_get_link_state(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
DPNI_RSP_GET_LINK_STATE(cmd, state); rsp_params = (struct dpni_rsp_get_link_state *)cmd.params;
state->up = dpni_get_field(rsp_params->flags, LINK_STATE);
state->state_valid = dpni_get_field(rsp_params->flags, STATE_VALID);
state->rate = le32_to_cpu(rsp_params->rate);
state->options = le64_to_cpu(rsp_params->options);
state->supported = le64_to_cpu(rsp_params->supported);
state->advertising = le64_to_cpu(rsp_params->advertising);
return 0; return 0;
} }
int dpni_add_mac_addr(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_add_mac_addr() - Add MAC address filter
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
const uint8_t mac_addr[6]) * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @mac_addr: MAC address to add
* @flags :0 - tc_id and flow_id will be ignored.
* Pkt with this mac_id will be passed to the next
* classification stages
* DPNI_MAC_SET_QUEUE_ACTION
* Pkt with this mac will be forward directly to
* queue defined by the tc_id and flow_id
* @tc_id : Traffic class selection (0-7)
* @flow_id : Selects the specific queue out of the set allocated for the
* same as tc_id. Value must be in range 0 to NUM_QUEUES - 1
* Return: '0' on Success; Error code otherwise.
*/
int dpni_add_mac_addr(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
const u8 mac_addr[6], u8 flags,
u8 tc_id, u8 flow_id)
{ {
struct dpni_cmd_add_mac_addr *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
int i;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR, cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
cmd_flags, cmd_flags,
token); token);
DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr); cmd_params = (struct dpni_cmd_add_mac_addr *)cmd.params;
cmd_params->flags = flags;
cmd_params->tc_id = tc_id;
cmd_params->fq_id = flow_id;
for (i = 0; i < 6; i++)
cmd_params->mac_addr[i] = mac_addr[5 - i];
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_get_api_version(struct fsl_mc_io *mc_io, /**
u32 cmd_flags, * dpni_get_api_version() - Get Data Path Network Interface API version
u16 *major_ver, * @mc_io: Pointer to MC portal's I/O object
u16 *minor_ver) * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @major_ver: Major version of data path network interface API
* @minor_ver: Minor version of data path network interface API
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_api_version(struct fsl_mc_io *mc_io, u32 cmd_flags,
u16 *major_ver, u16 *minor_ver)
{ {
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
int err; int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION, cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
cmd_flags, 0); cmd_flags,
0);
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}
/**
* dpni_set_queue() - Set queue parameters
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @qtype: Type of queue - all queue types are supported, although
* the command is ignored for Tx
* @tc: Traffic class, in range 0 to NUM_TCS - 1
* @index: Selects the specific queue out of the set allocated for the
* same TC. Value must be in range 0 to NUM_QUEUES - 1
* @options: A combination of DPNI_QUEUE_OPT_ values that control what
* configuration options are set on the queue
* @queue: Queue structure
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 param, u8 index,
u8 options, const struct dpni_queue *queue)
{
struct mc_command cmd = { 0 };
struct dpni_cmd_set_queue *cmd_params;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
cmd_flags,
token);
cmd_params = (struct dpni_cmd_set_queue *)cmd.params;
cmd_params->qtype = qtype;
cmd_params->tc = (u8)(param & 0xff);
cmd_params->channel_id = (u8)((param >> 8) & 0xff);
cmd_params->index = index;
cmd_params->options = options;
cmd_params->dest_id = cpu_to_le32(queue->destination.id);
cmd_params->dest_prio = queue->destination.priority;
dpni_set_field(cmd_params->flags, DEST_TYPE, queue->destination.type);
dpni_set_field(cmd_params->flags, STASH_CTRL, queue->flc.stash_control);
dpni_set_field(cmd_params->flags, HOLD_ACTIVE,
queue->destination.hold_active);
cmd_params->flc = cpu_to_le64(queue->flc.value);
cmd_params->user_context = cpu_to_le64(queue->user_context);
cmd_params->cgid = queue->cgid;
/* send command to mc */
return mc_send_command(mc_io, &cmd);
}
/**
* dpni_get_queue() - Get queue parameters
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPNI object
* @qtype: Type of queue - all queue types are supported
* @param: Traffic class and channel ID.
* MSB - channel id; used only for DPNI_QUEUE_TX and
* DPNI_QUEUE_TX_CONFIRM, ignored for the rest
* LSB - traffic class
* Use macro DPNI_BUILD_PARAM() to build correct value.
* If dpni uses a single channel (uses only channel zero)
* the parameter can receive traffic class directly.
* @index: Selects the specific queue out of the set allocated for the
* same TC. Value must be in range 0 to NUM_QUEUES - 1
* @queue: Queue configuration structure
* @qid: Queue identification
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 param, u8 index,
struct dpni_queue *queue, struct dpni_queue_id *qid)
{
struct mc_command cmd = { 0 };
struct dpni_cmd_get_queue *cmd_params;
struct dpni_rsp_get_queue *rsp_params;
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
cmd_flags,
token);
cmd_params = (struct dpni_cmd_get_queue *)cmd.params;
cmd_params->qtype = qtype;
cmd_params->tc = (u8)(param & 0xff);
cmd_params->index = index;
cmd_params->channel_id = (u8)((param >> 8) & 0xff);
/* send command to mc */ /* send command to mc */
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
@@ -330,98 +657,107 @@ int dpni_get_api_version(struct fsl_mc_io *mc_io,
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
mc_cmd_read_api_version(&cmd, major_ver, minor_ver); rsp_params = (struct dpni_rsp_get_queue *)cmd.params;
queue->destination.id = le32_to_cpu(rsp_params->dest_id);
queue->destination.priority = rsp_params->dest_prio;
queue->destination.type = dpni_get_field(rsp_params->flags, DEST_TYPE);
queue->flc.stash_control = dpni_get_field(rsp_params->flags, STASH_CTRL);
queue->destination.hold_active = dpni_get_field(rsp_params->flags, HOLD_ACTIVE);
queue->flc.value = le64_to_cpu(rsp_params->flc);
queue->user_context = le64_to_cpu(rsp_params->user_context);
qid->fqid = le32_to_cpu(rsp_params->fqid);
qid->qdbin = le16_to_cpu(rsp_params->qdbin);
if (dpni_get_field(rsp_params->flags, CGID_VALID))
queue->cgid = rsp_params->cgid;
else
queue->cgid = -1;
return 0; return 0;
} }
int dpni_set_queue(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_set_tx_confirmation_mode() - Tx confirmation mode
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
enum dpni_queue_type type, * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
uint8_t tc, * @token: Token of DPNI object
uint8_t index, * @ceetm_ch_idx: ceetm channel index
const struct dpni_queue *queue) * @mode: Tx confirmation mode
{ *
struct mc_command cmd = { 0 }; * This function is useful only when 'DPNI_OPT_TX_CONF_DISABLED' is not
/* prepare command */ * selected at DPNI creation.
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE, * Calling this function with 'mode' set to DPNI_CONF_DISABLE disables all
cmd_flags, * transmit confirmation (including the private confirmation queues), regardless
token); * of previous settings; Note that in this case, Tx error frames are still
DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue); * enqueued to the general transmit errors queue.
* Calling this function with 'mode' set to DPNI_CONF_SINGLE switches all
/* send command to mc*/ * Tx confirmations to a shared Tx conf queue. 'index' field in dpni_get_queue
return mc_send_command(mc_io, &cmd); * command will be ignored.
} *
* Return: '0' on Success; Error code otherwise.
int dpni_get_queue(struct fsl_mc_io *mc_io, */
uint32_t cmd_flags, int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
uint16_t token, u8 ceetm_ch_idx, enum dpni_confirmation_mode mode)
enum dpni_queue_type type,
uint8_t tc,
uint8_t index,
struct dpni_queue *queue)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
cmd_flags,
token);
DPNI_CMD_GET_QUEUE(cmd, type, tc, index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_GET_QUEUE(cmd, queue);
return 0;
}
int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_confirmation_mode mode)
{ {
struct dpni_tx_confirmation_mode *cmd_params; struct dpni_tx_confirmation_mode *cmd_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE, cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
cmd_flags, cmd_flags, token);
token);
cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params; cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
cmd_params->ceetm_ch_idx = ceetm_ch_idx;
cmd_params->confirmation_mode = mode; cmd_params->confirmation_mode = mode;
/* send command to mc*/ /* send command to mc*/
return mc_send_command(mc_io, &cmd); return mc_send_command(mc_io, &cmd);
} }
int dpni_get_statistics(struct fsl_mc_io *mc_io, /**
uint32_t cmd_flags, * dpni_get_statistics() - Get DPNI statistics
uint16_t token, * @mc_io: Pointer to MC portal's I/O object
uint8_t page, * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
union dpni_statistics *stat) * @token: Token of DPNI object
* @page: Selects the statistics page to retrieve, see
* DPNI_GET_STATISTICS output. Pages are numbered 0 to 6.
* @param: Custom parameter for some pages used to select
* a certain statistic source, for example the TC.
* - page_0: not used
* - page_1: not used
* - page_2: not used
* - page_3: high_byte - channel_id, low_byte - traffic class
* - page_4: high_byte - queue_index have meaning only if dpni is
* created using option DPNI_OPT_CUSTOM_CG, low_byte - traffic class
* - page_5: not used
* - page_6: not used
* @stat: Structure containing the statistics
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_statistics(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
u8 page, u16 param, union dpni_statistics *stat)
{ {
struct dpni_cmd_get_statistics *cmd_params;
struct dpni_rsp_get_statistics *rsp_params;
struct mc_command cmd = { 0 }; struct mc_command cmd = { 0 };
int err; int i, err;
/* prepare command */ /* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS, cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
cmd_flags, token); cmd_flags,
DPNI_CMD_GET_STATISTICS(cmd, page); token);
cmd_params = (struct dpni_cmd_get_statistics *)cmd.params;
cmd_params->page_number = page;
cmd_params->param = param;
/* send command to mc*/ /* send command to mc */
err = mc_send_command(mc_io, &cmd); err = mc_send_command(mc_io, &cmd);
if (err) if (err)
return err; return err;
/* retrieve response parameters */ /* retrieve response parameters */
DPNI_RSP_GET_STATISTICS(cmd, stat); rsp_params = (struct dpni_rsp_get_statistics *)cmd.params;
for (i = 0; i < DPNI_STATISTICS_CNT; i++)
stat->raw.counter[i] = le64_to_cpu(rsp_params->counter[i]);
return 0; return 0;
} }

14
drivers/net/fsl-mc/mc.c
View File

@@ -1353,10 +1353,9 @@ err:
static int dpni_init(void) static int dpni_init(void)
{ {
int err; struct dpni_cfg dpni_cfg = {0};
uint8_t cfg_buf[256] = {0};
struct dpni_cfg dpni_cfg;
uint16_t major_ver, minor_ver; uint16_t major_ver, minor_ver;
int err;
dflt_dpni = calloc(sizeof(struct fsl_dpni_obj), 1); dflt_dpni = calloc(sizeof(struct fsl_dpni_obj), 1);
if (!dflt_dpni) { if (!dflt_dpni) {
@@ -1365,14 +1364,6 @@ static int dpni_init(void)
goto err_calloc; goto err_calloc;
} }
memset(&dpni_cfg, 0, sizeof(dpni_cfg));
err = dpni_prepare_cfg(&dpni_cfg, &cfg_buf[0]);
if (err < 0) {
err = -ENODEV;
printf("dpni_prepare_cfg() failed: %d\n", err);
goto err_prepare_cfg;
}
err = dpni_create(dflt_mc_io, err = dpni_create(dflt_mc_io,
dflt_dprc_handle, dflt_dprc_handle,
MC_CMD_NO_FLAGS, MC_CMD_NO_FLAGS,
@@ -1429,7 +1420,6 @@ err_get_version:
MC_CMD_NO_FLAGS, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_id); dflt_dpni->dpni_id);
err_create: err_create:
err_prepare_cfg:
free(dflt_dpni); free(dflt_dpni);
err_calloc: err_calloc:
return err; return err;

22
drivers/net/ldpaa_eth/ldpaa_eth.c
View File

@@ -58,7 +58,7 @@ static void ldpaa_eth_collect_dpni_stats(struct udevice *dev, u64 *data)
continue; continue;
err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
j, &dpni_stats); j, 0, &dpni_stats);
if (err) { if (err) {
memset(&dpni_stats, 0, sizeof(dpni_stats)); memset(&dpni_stats, 0, sizeof(dpni_stats));
printf("dpni_get_stats(%d) failed\n", j); printf("dpni_get_stats(%d) failed\n", j);
@@ -378,7 +378,8 @@ static int ldpaa_eth_open(struct udevice *dev)
struct dpni_link_state link_state; struct dpni_link_state link_state;
#endif #endif
int err = 0; int err = 0;
struct dpni_queue d_queue; struct dpni_queue d_queue_cfg = { 0 };
struct dpni_queue_id d_queue;
if (eth_is_active(dev)) if (eth_is_active(dev))
return 0; return 0;
@@ -422,7 +423,7 @@ static int ldpaa_eth_open(struct udevice *dev)
goto err_dpni_bind; goto err_dpni_bind;
err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, plat->enetaddr); dflt_dpni->dpni_handle, plat->enetaddr, 0, 0, 0);
if (err) { if (err) {
printf("dpni_add_mac_addr() failed\n"); printf("dpni_add_mac_addr() failed\n");
return err; return err;
@@ -461,7 +462,7 @@ static int ldpaa_eth_open(struct udevice *dev)
memset(&d_queue, 0, sizeof(struct dpni_queue)); memset(&d_queue, 0, sizeof(struct dpni_queue));
err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, DPNI_QUEUE_RX, dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
0, 0, &d_queue); 0, 0, &d_queue_cfg, &d_queue);
if (err) { if (err) {
printf("dpni_get_queue failed\n"); printf("dpni_get_queue failed\n");
goto err_get_queue; goto err_get_queue;
@@ -470,7 +471,7 @@ static int ldpaa_eth_open(struct udevice *dev)
priv->rx_dflt_fqid = d_queue.fqid; priv->rx_dflt_fqid = d_queue.fqid;
err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle, err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
&priv->tx_qdid); DPNI_QUEUE_TX, &priv->tx_qdid);
if (err) { if (err) {
printf("dpni_get_qdid() failed\n"); printf("dpni_get_qdid() failed\n");
goto err_qdid; goto err_qdid;
@@ -845,7 +846,7 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
/* ...rx, ... */ /* ...rx, ... */
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout, DPNI_QUEUE_RX); DPNI_QUEUE_RX, &dflt_dpni->buf_layout);
if (err) { if (err) {
printf("dpni_set_buffer_layout() failed"); printf("dpni_set_buffer_layout() failed");
goto err_buf_layout; goto err_buf_layout;
@@ -857,7 +858,7 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
DPNI_BUF_LAYOUT_OPT_PARSER_RESULT); DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout, DPNI_QUEUE_TX); DPNI_QUEUE_TX, &dflt_dpni->buf_layout);
if (err) { if (err) {
printf("dpni_set_buffer_layout() failed"); printf("dpni_set_buffer_layout() failed");
goto err_buf_layout; goto err_buf_layout;
@@ -867,8 +868,7 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE; dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout, DPNI_QUEUE_TX_CONFIRM, &dflt_dpni->buf_layout);
DPNI_QUEUE_TX_CONFIRM);
if (err) { if (err) {
printf("dpni_set_buffer_layout() failed"); printf("dpni_set_buffer_layout() failed");
goto err_buf_layout; goto err_buf_layout;
@@ -923,7 +923,7 @@ static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
DPNI_QUEUE_TX, 0, 0, &tx_queue); DPNI_QUEUE_TX, 0, 0, 0, &tx_queue);
if (err) { if (err) {
printf("dpni_set_queue() failed\n"); printf("dpni_set_queue() failed\n");
@@ -932,7 +932,7 @@ static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS, err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, dflt_dpni->dpni_handle,
DPNI_CONF_DISABLE); 0, DPNI_CONF_DISABLE);
if (err) { if (err) {
printf("dpni_set_tx_confirmation_mode() failed\n"); printf("dpni_set_tx_confirmation_mode() failed\n");
return err; return err;

1071
include/fsl-mc/fsl_dpni.h
View File

File diff suppressed because it is too large Load Diff