LXR linux/drivers/net/ethernet/freescale/dpaa2/dpmac.c

   1// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2/* Copyright 2013-2016 Freescale Semiconductor Inc.
   3 * Copyright 2019 NXP
   4 */
   5#include <linux/fsl/mc.h>
   6#include "dpmac.h"
   7#include "dpmac-cmd.h"
   8
   9/**
  10 * dpmac_open() - Open a control session for the specified object.
  11 * @mc_io:      Pointer to MC portal's I/O object
  12 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  13 * @dpmac_id:   DPMAC unique ID
  14 * @token:      Returned token; use in subsequent API calls
  15 *
  16 * This function can be used to open a control session for an
  17 * already created object; an object may have been declared in
  18 * the DPL or by calling the dpmac_create function.
  19 * This function returns a unique authentication token,
  20 * associated with the specific object ID and the specific MC
  21 * portal; this token must be used in all subsequent commands for
  22 * this specific object
  23 *
  24 * Return:      '0' on Success; Error code otherwise.
  25 */
  26int dpmac_open(struct fsl_mc_io *mc_io,
  27               u32 cmd_flags,
  28               int dpmac_id,
  29               u16 *token)
  30{
  31        struct dpmac_cmd_open *cmd_params;
  32        struct fsl_mc_command cmd = { 0 };
  33        int err;
  34
  35        /* prepare command */
  36        cmd.header = mc_encode_cmd_header(DPMAC_CMDID_OPEN,
  37                                          cmd_flags,
  38                                          0);
  39        cmd_params = (struct dpmac_cmd_open *)cmd.params;
  40        cmd_params->dpmac_id = cpu_to_le32(dpmac_id);
  41
  42        /* send command to mc*/
  43        err = mc_send_command(mc_io, &cmd);
  44        if (err)
  45                return err;
  46
  47        /* retrieve response parameters */
  48        *token = mc_cmd_hdr_read_token(&cmd);
  49
  50        return err;
  51}
  52
  53/**
  54 * dpmac_close() - Close the control session of the object
  55 * @mc_io:      Pointer to MC portal's I/O object
  56 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  57 * @token:      Token of DPMAC object
  58 *
  59 * After this function is called, no further operations are
  60 * allowed on the object without opening a new control session.
  61 *
  62 * Return:      '0' on Success; Error code otherwise.
  63 */
  64int dpmac_close(struct fsl_mc_io *mc_io,
  65                u32 cmd_flags,
  66                u16 token)
  67{
  68        struct fsl_mc_command cmd = { 0 };
  69
  70        /* prepare command */
  71        cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CLOSE, cmd_flags,
  72                                          token);
  73
  74        /* send command to mc*/
  75        return mc_send_command(mc_io, &cmd);
  76}
  77
  78/**
  79 * dpmac_get_attributes - Retrieve DPMAC attributes.
  80 *
  81 * @mc_io:      Pointer to MC portal's I/O object
  82 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  83 * @token:      Token of DPMAC object
  84 * @attr:       Returned object's attributes
  85 *
  86 * Return:      '0' on Success; Error code otherwise.
  87 */
  88int dpmac_get_attributes(struct fsl_mc_io *mc_io,
  89                         u32 cmd_flags,
  90                         u16 token,
  91                         struct dpmac_attr *attr)
  92{
  93        struct dpmac_rsp_get_attributes *rsp_params;
  94        struct fsl_mc_command cmd = { 0 };
  95        int err;
  96
  97        /* prepare command */
  98        cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_ATTR,
  99                                          cmd_flags,
 100                                          token);
 101
 102        /* send command to mc*/
 103        err = mc_send_command(mc_io, &cmd);
 104        if (err)
 105                return err;
 106
 107        /* retrieve response parameters */
 108        rsp_params = (struct dpmac_rsp_get_attributes *)cmd.params;
 109        attr->eth_if = rsp_params->eth_if;
 110        attr->link_type = rsp_params->link_type;
 111        attr->id = le16_to_cpu(rsp_params->id);
 112        attr->max_rate = le32_to_cpu(rsp_params->max_rate);
 113
 114        return 0;
 115}
 116
 117/**
 118 * dpmac_set_link_state() - Set the Ethernet link status
 119 * @mc_io:      Pointer to opaque I/O object
 120 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 121 * @token:      Token of DPMAC object
 122 * @link_state: Link state configuration
 123 *
 124 * Return:      '0' on Success; Error code otherwise.
 125 */
 126int dpmac_set_link_state(struct fsl_mc_io *mc_io,
 127                         u32 cmd_flags,
 128                         u16 token,
 129                         struct dpmac_link_state *link_state)
 130{
 131        struct dpmac_cmd_set_link_state *cmd_params;
 132        struct fsl_mc_command cmd = { 0 };
 133
 134        /* prepare command */
 135        cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_LINK_STATE,
 136                                          cmd_flags,
 137                                          token);
 138        cmd_params = (struct dpmac_cmd_set_link_state *)cmd.params;
 139        cmd_params->options = cpu_to_le64(link_state->options);
 140        cmd_params->rate = cpu_to_le32(link_state->rate);
 141        dpmac_set_field(cmd_params->state, STATE, link_state->up);
 142        dpmac_set_field(cmd_params->state, STATE_VALID,
 143                        link_state->state_valid);
 144        cmd_params->supported = cpu_to_le64(link_state->supported);
 145        cmd_params->advertising = cpu_to_le64(link_state->advertising);
 146
 147        /* send command to mc*/
 148        return mc_send_command(mc_io, &cmd);
 149}
 150
 151/**
 152 * dpmac_get_counter() - Read a specific DPMAC counter
 153 * @mc_io:      Pointer to opaque I/O object
 154 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 155 * @token:      Token of DPMAC object
 156 * @id:         The requested counter ID
 157 * @value:      Returned counter value
 158 *
 159 * Return:      The requested counter; '0' otherwise.
 160 */
 161int dpmac_get_counter(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
 162                      enum dpmac_counter_id id, u64 *value)
 163{
 164        struct dpmac_cmd_get_counter *dpmac_cmd;
 165        struct dpmac_rsp_get_counter *dpmac_rsp;
 166        struct fsl_mc_command cmd = { 0 };
 167        int err = 0;
 168
 169        cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_COUNTER,
 170                                          cmd_flags,
 171                                          token);
 172        dpmac_cmd = (struct dpmac_cmd_get_counter *)cmd.params;
 173        dpmac_cmd->id = id;
 174
 175        err = mc_send_command(mc_io, &cmd);
 176        if (err)
 177                return err;
 178
 179        dpmac_rsp = (struct dpmac_rsp_get_counter *)cmd.params;
 180        *value = le64_to_cpu(dpmac_rsp->counter);
 181
 182        return 0;
 183}
 184