mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-02 00:03:45 +09:00
83d290c56f
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
529 lines
11 KiB
C
529 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2013-2016 Freescale Semiconductor
|
|
* Copyright 2017 NXP
|
|
*/
|
|
|
|
#include <fsl-mc/fsl_mc_sys.h>
|
|
#include <fsl-mc/fsl_mc_cmd.h>
|
|
#include <fsl-mc/fsl_dpni.h>
|
|
|
|
int dpni_prepare_cfg(const struct dpni_cfg *cfg,
|
|
uint8_t *cfg_buf)
|
|
{
|
|
uint64_t *params = (uint64_t *)cfg_buf;
|
|
|
|
DPNI_PREP_CFG(params, cfg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_extract_cfg(struct dpni_cfg *cfg,
|
|
const uint8_t *cfg_buf)
|
|
{
|
|
uint64_t *params = (uint64_t *)cfg_buf;
|
|
|
|
DPNI_EXT_CFG(params, cfg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_open(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
int dpni_id,
|
|
uint16_t *token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
|
|
cmd_flags,
|
|
0);
|
|
DPNI_CMD_OPEN(cmd, dpni_id);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_close(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_create(struct fsl_mc_io *mc_io,
|
|
uint16_t dprc_token,
|
|
uint32_t cmd_flags,
|
|
const struct dpni_cfg *cfg,
|
|
uint32_t *obj_id)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
|
|
cmd_flags,
|
|
dprc_token);
|
|
DPNI_CMD_CREATE(cmd, cfg);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
MC_CMD_READ_OBJ_ID(cmd, *obj_id);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_destroy(struct fsl_mc_io *mc_io,
|
|
uint16_t dprc_token,
|
|
uint32_t cmd_flags,
|
|
uint32_t obj_id)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
|
|
cmd_flags,
|
|
dprc_token);
|
|
|
|
/* set object id to destroy */
|
|
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_set_pools(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const struct dpni_pools_cfg *cfg)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_POOLS(cmd, cfg);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_enable(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_disable(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_reset(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_attributes(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
struct dpni_attr *attr)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
|
|
cmd_flags,
|
|
token);
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_ATTR(cmd, attr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
struct dpni_error_cfg *cfg)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const struct dpni_buffer_layout *layout,
|
|
enum dpni_queue_type type)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_qdid(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
uint16_t *qdid)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_QDID(cmd, *qdid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
uint16_t *data_offset)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const struct dpni_link_cfg *cfg)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_LINK_CFG(cmd, cfg);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_link_state(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
struct dpni_link_state *state)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_LINK_STATE(cmd, state);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const uint8_t mac_addr[6])
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
uint8_t mac_addr[6])
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
|
|
cmd_flags,
|
|
token);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const uint8_t mac_addr[6])
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
const uint8_t mac_addr[6])
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
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 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
|
|
cmd_flags, 0);
|
|
|
|
/* send command to mc */
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_set_queue(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
enum dpni_queue_type type,
|
|
uint8_t tc,
|
|
uint8_t index,
|
|
const struct dpni_queue *queue)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
|
|
cmd_flags,
|
|
token);
|
|
DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_queue(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
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 mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
|
|
cmd_flags,
|
|
token);
|
|
|
|
cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
|
|
cmd_params->confirmation_mode = mode;
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|
|
int dpni_get_statistics(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token,
|
|
uint8_t page,
|
|
struct dpni_statistics *stat)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
int err;
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
|
|
cmd_flags, token);
|
|
DPNI_CMD_GET_STATISTICS(cmd, page);
|
|
|
|
/* send command to mc*/
|
|
err = mc_send_command(mc_io, &cmd);
|
|
if (err)
|
|
return err;
|
|
|
|
/* retrieve response parameters */
|
|
DPNI_RSP_GET_STATISTICS(cmd, stat);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dpni_reset_statistics(struct fsl_mc_io *mc_io,
|
|
uint32_t cmd_flags,
|
|
uint16_t token)
|
|
{
|
|
struct mc_command cmd = { 0 };
|
|
|
|
/* prepare command */
|
|
cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
|
|
cmd_flags, token);
|
|
|
|
/* send command to mc*/
|
|
return mc_send_command(mc_io, &cmd);
|
|
}
|
|
|