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

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright 2013-2016 Freescale Semiconductor Inc.
   4 * Copyright 2016-2018 NXP
   5 */
   6
   7#include <linux/fsl/mc.h>
   8
   9#include "dprtc.h"
  10#include "dprtc-cmd.h"
  11
  12/**
  13 * dprtc_open() - Open a control session for the specified object.
  14 * @mc_io:      Pointer to MC portal's I/O object
  15 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  16 * @dprtc_id:   DPRTC unique ID
  17 * @token:      Returned token; use in subsequent API calls
  18 *
  19 * This function can be used to open a control session for an
  20 * already created object; an object may have been declared in
  21 * the DPL or by calling the dprtc_create function.
  22 * This function returns a unique authentication token,
  23 * associated with the specific object ID and the specific MC
  24 * portal; this token must be used in all subsequent commands for
  25 * this specific object
  26 *
  27 * Return:      '0' on Success; Error code otherwise.
  28 */
  29int dprtc_open(struct fsl_mc_io *mc_io,
  30               u32 cmd_flags,
  31               int dprtc_id,
  32               u16 *token)
  33{
  34        struct dprtc_cmd_open *cmd_params;
  35        struct fsl_mc_command cmd = { 0 };
  36        int err;
  37
  38        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_OPEN,
  39                                          cmd_flags,
  40                                          0);
  41        cmd_params = (struct dprtc_cmd_open *)cmd.params;
  42        cmd_params->dprtc_id = cpu_to_le32(dprtc_id);
  43
  44        err = mc_send_command(mc_io, &cmd);
  45        if (err)
  46                return err;
  47
  48        *token = mc_cmd_hdr_read_token(&cmd);
  49
  50        return 0;
  51}
  52
  53/**
  54 * dprtc_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 DPRTC 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 dprtc_close(struct fsl_mc_io *mc_io,
  65                u32 cmd_flags,
  66                u16 token)
  67{
  68        struct fsl_mc_command cmd = { 0 };
  69
  70        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_CLOSE, cmd_flags,
  71                                          token);
  72
  73        return mc_send_command(mc_io, &cmd);
  74}
  75
  76/**
  77 * dprtc_set_irq_enable() - Set overall interrupt state.
  78 * @mc_io:      Pointer to MC portal's I/O object
  79 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  80 * @token:      Token of DPRTC object
  81 * @irq_index:  The interrupt index to configure
  82 * @en:         Interrupt state - enable = 1, disable = 0
  83 *
  84 * Allows GPP software to control when interrupts are generated.
  85 * Each interrupt can have up to 32 causes.  The enable/disable control's the
  86 * overall interrupt state. if the interrupt is disabled no causes will cause
  87 * an interrupt.
  88 *
  89 * Return:      '0' on Success; Error code otherwise.
  90 */
  91int dprtc_set_irq_enable(struct fsl_mc_io *mc_io,
  92                         u32 cmd_flags,
  93                         u16 token,
  94                         u8 irq_index,
  95                         u8 en)
  96{
  97        struct dprtc_cmd_set_irq_enable *cmd_params;
  98        struct fsl_mc_command cmd = { 0 };
  99
 100        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_SET_IRQ_ENABLE,
 101                                          cmd_flags,
 102                                          token);
 103        cmd_params = (struct dprtc_cmd_set_irq_enable *)cmd.params;
 104        cmd_params->irq_index = irq_index;
 105        cmd_params->en = en;
 106
 107        return mc_send_command(mc_io, &cmd);
 108}
 109
 110/**
 111 * dprtc_get_irq_enable() - Get overall interrupt state
 112 * @mc_io:      Pointer to MC portal's I/O object
 113 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 114 * @token:      Token of DPRTC object
 115 * @irq_index:  The interrupt index to configure
 116 * @en:         Returned interrupt state - enable = 1, disable = 0
 117 *
 118 * Return:      '0' on Success; Error code otherwise.
 119 */
 120int dprtc_get_irq_enable(struct fsl_mc_io *mc_io,
 121                         u32 cmd_flags,
 122                         u16 token,
 123                         u8 irq_index,
 124                         u8 *en)
 125{
 126        struct dprtc_rsp_get_irq_enable *rsp_params;
 127        struct dprtc_cmd_get_irq *cmd_params;
 128        struct fsl_mc_command cmd = { 0 };
 129        int err;
 130
 131        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_ENABLE,
 132                                          cmd_flags,
 133                                          token);
 134        cmd_params = (struct dprtc_cmd_get_irq *)cmd.params;
 135        cmd_params->irq_index = irq_index;
 136
 137        err = mc_send_command(mc_io, &cmd);
 138        if (err)
 139                return err;
 140
 141        rsp_params = (struct dprtc_rsp_get_irq_enable *)cmd.params;
 142        *en = rsp_params->en;
 143
 144        return 0;
 145}
 146
 147/**
 148 * dprtc_set_irq_mask() - Set interrupt mask.
 149 * @mc_io:      Pointer to MC portal's I/O object
 150 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 151 * @token:      Token of DPRTC object
 152 * @irq_index:  The interrupt index to configure
 153 * @mask:       Event mask to trigger interrupt;
 154 *              each bit:
 155 *                      0 = ignore event
 156 *                      1 = consider event for asserting IRQ
 157 *
 158 * Every interrupt can have up to 32 causes and the interrupt model supports
 159 * masking/unmasking each cause independently
 160 *
 161 * Return:      '0' on Success; Error code otherwise.
 162 */
 163int dprtc_set_irq_mask(struct fsl_mc_io *mc_io,
 164                       u32 cmd_flags,
 165                       u16 token,
 166                       u8 irq_index,
 167                       u32 mask)
 168{
 169        struct dprtc_cmd_set_irq_mask *cmd_params;
 170        struct fsl_mc_command cmd = { 0 };
 171
 172        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_SET_IRQ_MASK,
 173                                          cmd_flags,
 174                                          token);
 175        cmd_params = (struct dprtc_cmd_set_irq_mask *)cmd.params;
 176        cmd_params->mask = cpu_to_le32(mask);
 177        cmd_params->irq_index = irq_index;
 178
 179        return mc_send_command(mc_io, &cmd);
 180}
 181
 182/**
 183 * dprtc_get_irq_mask() - Get interrupt mask.
 184 * @mc_io:      Pointer to MC portal's I/O object
 185 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 186 * @token:      Token of DPRTC object
 187 * @irq_index:  The interrupt index to configure
 188 * @mask:       Returned event mask to trigger interrupt
 189 *
 190 * Every interrupt can have up to 32 causes and the interrupt model supports
 191 * masking/unmasking each cause independently
 192 *
 193 * Return:      '0' on Success; Error code otherwise.
 194 */
 195int dprtc_get_irq_mask(struct fsl_mc_io *mc_io,
 196                       u32 cmd_flags,
 197                       u16 token,
 198                       u8 irq_index,
 199                       u32 *mask)
 200{
 201        struct dprtc_rsp_get_irq_mask *rsp_params;
 202        struct dprtc_cmd_get_irq *cmd_params;
 203        struct fsl_mc_command cmd = { 0 };
 204        int err;
 205
 206        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_MASK,
 207                                          cmd_flags,
 208                                          token);
 209        cmd_params = (struct dprtc_cmd_get_irq *)cmd.params;
 210        cmd_params->irq_index = irq_index;
 211
 212        err = mc_send_command(mc_io, &cmd);
 213        if (err)
 214                return err;
 215
 216        rsp_params = (struct dprtc_rsp_get_irq_mask *)cmd.params;
 217        *mask = le32_to_cpu(rsp_params->mask);
 218
 219        return 0;
 220}
 221
 222/**
 223 * dprtc_get_irq_status() - Get the current status of any pending interrupts.
 224 *
 225 * @mc_io:      Pointer to MC portal's I/O object
 226 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 227 * @token:      Token of DPRTC object
 228 * @irq_index:  The interrupt index to configure
 229 * @status:     Returned interrupts status - one bit per cause:
 230 *                      0 = no interrupt pending
 231 *                      1 = interrupt pending
 232 *
 233 * Return:      '0' on Success; Error code otherwise.
 234 */
 235int dprtc_get_irq_status(struct fsl_mc_io *mc_io,
 236                         u32 cmd_flags,
 237                         u16 token,
 238                         u8 irq_index,
 239                         u32 *status)
 240{
 241        struct dprtc_cmd_get_irq_status *cmd_params;
 242        struct dprtc_rsp_get_irq_status *rsp_params;
 243        struct fsl_mc_command cmd = { 0 };
 244        int err;
 245
 246        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_STATUS,
 247                                          cmd_flags,
 248                                          token);
 249        cmd_params = (struct dprtc_cmd_get_irq_status *)cmd.params;
 250        cmd_params->status = cpu_to_le32(*status);
 251        cmd_params->irq_index = irq_index;
 252
 253        err = mc_send_command(mc_io, &cmd);
 254        if (err)
 255                return err;
 256
 257        rsp_params = (struct dprtc_rsp_get_irq_status *)cmd.params;
 258        *status = le32_to_cpu(rsp_params->status);
 259
 260        return 0;
 261}
 262
 263/**
 264 * dprtc_clear_irq_status() - Clear a pending interrupt's status
 265 *
 266 * @mc_io:      Pointer to MC portal's I/O object
 267 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 268 * @token:      Token of DPRTC object
 269 * @irq_index:  The interrupt index to configure
 270 * @status:     Bits to clear (W1C) - one bit per cause:
 271 *                      0 = don't change
 272 *                      1 = clear status bit
 273 *
 274 * Return:      '0' on Success; Error code otherwise.
 275 */
 276int dprtc_clear_irq_status(struct fsl_mc_io *mc_io,
 277                           u32 cmd_flags,
 278                           u16 token,
 279                           u8 irq_index,
 280                           u32 status)
 281{
 282        struct dprtc_cmd_clear_irq_status *cmd_params;
 283        struct fsl_mc_command cmd = { 0 };
 284
 285        cmd.header = mc_encode_cmd_header(DPRTC_CMDID_CLEAR_IRQ_STATUS,
 286                                          cmd_flags,
 287                                          token);
 288        cmd_params = (struct dprtc_cmd_clear_irq_status *)cmd.params;
 289        cmd_params->irq_index = irq_index;
 290        cmd_params->status = cpu_to_le32(status);
 291
 292        return mc_send_command(mc_io, &cmd);
 293}
 294