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  */
  29 int 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  */
  64 int 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  */
  91 int 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  */
 120 int 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  */
 163 int 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  */
 195 int 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  */
 235 int 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  */
 276 int 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 }