LXR linux/drivers/bus/fsl-mc/dpcon.c

   1// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2/*
   3 * Copyright 2013-2016 Freescale Semiconductor Inc.
   4 *
   5 */
   6#include <linux/kernel.h>
   7#include <linux/fsl/mc.h>
   8
   9#include "fsl-mc-private.h"
  10
  11/**
  12 * dpcon_open() - Open a control session for the specified object
  13 * @mc_io:      Pointer to MC portal's I/O object
  14 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  15 * @dpcon_id:   DPCON unique ID
  16 * @token:      Returned token; use in subsequent API calls
  17 *
  18 * This function can be used to open a control session for an
  19 * already created object; an object may have been declared in
  20 * the DPL or by calling the dpcon_create() function.
  21 * This function returns a unique authentication token,
  22 * associated with the specific object ID and the specific MC
  23 * portal; this token must be used in all subsequent commands for
  24 * this specific object.
  25 *
  26 * Return:      '0' on Success; Error code otherwise.
  27 */
  28int dpcon_open(struct fsl_mc_io *mc_io,
  29               u32 cmd_flags,
  30               int dpcon_id,
  31               u16 *token)
  32{
  33        struct fsl_mc_command cmd = { 0 };
  34        struct dpcon_cmd_open *dpcon_cmd;
  35        int err;
  36
  37        /* prepare command */
  38        cmd.header = mc_encode_cmd_header(DPCON_CMDID_OPEN,
  39                                          cmd_flags,
  40                                          0);
  41        dpcon_cmd = (struct dpcon_cmd_open *)cmd.params;
  42        dpcon_cmd->dpcon_id = cpu_to_le32(dpcon_id);
  43
  44        /* send command to mc*/
  45        err = mc_send_command(mc_io, &cmd);
  46        if (err)
  47                return err;
  48
  49        /* retrieve response parameters */
  50        *token = mc_cmd_hdr_read_token(&cmd);
  51
  52        return 0;
  53}
  54EXPORT_SYMBOL_GPL(dpcon_open);
  55
  56/**
  57 * dpcon_close() - Close the control session of the object
  58 * @mc_io:      Pointer to MC portal's I/O object
  59 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  60 * @token:      Token of DPCON object
  61 *
  62 * After this function is called, no further operations are
  63 * allowed on the object without opening a new control session.
  64 *
  65 * Return:      '0' on Success; Error code otherwise.
  66 */
  67int dpcon_close(struct fsl_mc_io *mc_io,
  68                u32 cmd_flags,
  69                u16 token)
  70{
  71        struct fsl_mc_command cmd = { 0 };
  72
  73        /* prepare command */
  74        cmd.header = mc_encode_cmd_header(DPCON_CMDID_CLOSE,
  75                                          cmd_flags,
  76                                          token);
  77
  78        /* send command to mc*/
  79        return mc_send_command(mc_io, &cmd);
  80}
  81EXPORT_SYMBOL_GPL(dpcon_close);
  82
  83/**
  84 * dpcon_enable() - Enable the DPCON
  85 * @mc_io:      Pointer to MC portal's I/O object
  86 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
  87 * @token:      Token of DPCON object
  88 *
  89 * Return:      '0' on Success; Error code otherwise
  90 */
  91int dpcon_enable(struct fsl_mc_io *mc_io,
  92                 u32 cmd_flags,
  93                 u16 token)
  94{
  95        struct fsl_mc_command cmd = { 0 };
  96
  97        /* prepare command */
  98        cmd.header = mc_encode_cmd_header(DPCON_CMDID_ENABLE,
  99                                          cmd_flags,
 100                                          token);
 101
 102        /* send command to mc*/
 103        return mc_send_command(mc_io, &cmd);
 104}
 105EXPORT_SYMBOL_GPL(dpcon_enable);
 106
 107/**
 108 * dpcon_disable() - Disable the DPCON
 109 * @mc_io:      Pointer to MC portal's I/O object
 110 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 111 * @token:      Token of DPCON object
 112 *
 113 * Return:      '0' on Success; Error code otherwise
 114 */
 115int dpcon_disable(struct fsl_mc_io *mc_io,
 116                  u32 cmd_flags,
 117                  u16 token)
 118{
 119        struct fsl_mc_command cmd = { 0 };
 120
 121        /* prepare command */
 122        cmd.header = mc_encode_cmd_header(DPCON_CMDID_DISABLE,
 123                                          cmd_flags,
 124                                          token);
 125
 126        /* send command to mc*/
 127        return mc_send_command(mc_io, &cmd);
 128}
 129EXPORT_SYMBOL_GPL(dpcon_disable);
 130
 131/**
 132 * dpcon_reset() - Reset the DPCON, returns the object to initial state.
 133 * @mc_io:      Pointer to MC portal's I/O object
 134 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 135 * @token:      Token of DPCON object
 136 *
 137 * Return:      '0' on Success; Error code otherwise.
 138 */
 139int dpcon_reset(struct fsl_mc_io *mc_io,
 140                u32 cmd_flags,
 141                u16 token)
 142{
 143        struct fsl_mc_command cmd = { 0 };
 144
 145        /* prepare command */
 146        cmd.header = mc_encode_cmd_header(DPCON_CMDID_RESET,
 147                                          cmd_flags, token);
 148
 149        /* send command to mc*/
 150        return mc_send_command(mc_io, &cmd);
 151}
 152EXPORT_SYMBOL_GPL(dpcon_reset);
 153
 154/**
 155 * dpcon_get_attributes() - Retrieve DPCON attributes.
 156 * @mc_io:      Pointer to MC portal's I/O object
 157 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 158 * @token:      Token of DPCON object
 159 * @attr:       Object's attributes
 160 *
 161 * Return:      '0' on Success; Error code otherwise.
 162 */
 163int dpcon_get_attributes(struct fsl_mc_io *mc_io,
 164                         u32 cmd_flags,
 165                         u16 token,
 166                         struct dpcon_attr *attr)
 167{
 168        struct fsl_mc_command cmd = { 0 };
 169        struct dpcon_rsp_get_attr *dpcon_rsp;
 170        int err;
 171
 172        /* prepare command */
 173        cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_ATTR,
 174                                          cmd_flags,
 175                                          token);
 176
 177        /* send command to mc*/
 178        err = mc_send_command(mc_io, &cmd);
 179        if (err)
 180                return err;
 181
 182        /* retrieve response parameters */
 183        dpcon_rsp = (struct dpcon_rsp_get_attr *)cmd.params;
 184        attr->id = le32_to_cpu(dpcon_rsp->id);
 185        attr->qbman_ch_id = le16_to_cpu(dpcon_rsp->qbman_ch_id);
 186        attr->num_priorities = dpcon_rsp->num_priorities;
 187
 188        return 0;
 189}
 190EXPORT_SYMBOL_GPL(dpcon_get_attributes);
 191
 192/**
 193 * dpcon_set_notification() - Set DPCON notification destination
 194 * @mc_io:      Pointer to MC portal's I/O object
 195 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 196 * @token:      Token of DPCON object
 197 * @cfg:        Notification parameters
 198 *
 199 * Return:      '0' on Success; Error code otherwise
 200 */
 201int dpcon_set_notification(struct fsl_mc_io *mc_io,
 202                           u32 cmd_flags,
 203                           u16 token,
 204                           struct dpcon_notification_cfg *cfg)
 205{
 206        struct fsl_mc_command cmd = { 0 };
 207        struct dpcon_cmd_set_notification *dpcon_cmd;
 208
 209        /* prepare command */
 210        cmd.header = mc_encode_cmd_header(DPCON_CMDID_SET_NOTIFICATION,
 211                                          cmd_flags,
 212                                          token);
 213        dpcon_cmd = (struct dpcon_cmd_set_notification *)cmd.params;
 214        dpcon_cmd->dpio_id = cpu_to_le32(cfg->dpio_id);
 215        dpcon_cmd->priority = cfg->priority;
 216        dpcon_cmd->user_ctx = cpu_to_le64(cfg->user_ctx);
 217
 218        /* send command to mc*/
 219        return mc_send_command(mc_io, &cmd);
 220}
 221EXPORT_SYMBOL_GPL(dpcon_set_notification);
 222