drivers/bus/fslmc/mc/dpbp.c

   1 /*-
   2  * This file is provided under a dual BSD/GPLv2 license. When using or
   3  * redistributing this file, you may do so under either license.
   4  *
   5  *   BSD LICENSE
   6  *
   7  * Copyright 2013-2016 Freescale Semiconductor Inc.
   8  * Copyright (c) 2016 NXP.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  * * Redistributions of source code must retain the above copyright
  13  * notice, this list of conditions and the following disclaimer.
  14  * * Redistributions in binary form must reproduce the above copyright
  15  * notice, this list of conditions and the following disclaimer in the
  16  * documentation and/or other materials provided with the distribution.
  17  * * Neither the name of the above-listed copyright holders nor the
  18  * names of any contributors may be used to endorse or promote products
  19  * derived from this software without specific prior written permission.
  20  *
  21  *   GPL LICENSE SUMMARY
  22  *
  23  * ALTERNATIVELY, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") as published by the Free Software
  25  * Foundation, either version 2 of that License or (at your option) any
  26  * later version.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  29  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  32  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40 #include <fsl_mc_sys.h>
  41 #include <fsl_mc_cmd.h>
  42 #include <fsl_dpbp.h>
  43 #include <fsl_dpbp_cmd.h>
  44
  45 int dpbp_open(struct fsl_mc_io *mc_io,
  46               uint32_t cmd_flags,
  47               int dpbp_id,
  48               uint16_t *token)
  49 {
  50         struct mc_command cmd = { 0 };
  51         int err;
  52
  53         /* prepare command */
  54         cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
  55                                           cmd_flags,
  56                                           0);
  57         DPBP_CMD_OPEN(cmd, dpbp_id);
  58
  59         /* send command to mc*/
  60         err = mc_send_command(mc_io, &cmd);
  61         if (err)
  62                 return err;
  63
  64         /* retrieve response parameters */
  65         *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  66
  67         return err;
  68 }
  69
  70 int dpbp_close(struct fsl_mc_io *mc_io,
  71                uint32_t cmd_flags,
  72                uint16_t token)
  73 {
  74         struct mc_command cmd = { 0 };
  75
  76         /* prepare command */
  77         cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags,
  78                                           token);
  79
  80         /* send command to mc*/
  81         return mc_send_command(mc_io, &cmd);
  82 }
  83
  84 int dpbp_create(struct fsl_mc_io *mc_io,
  85                 uint16_t dprc_token,
  86                 uint32_t cmd_flags,
  87                 const struct dpbp_cfg *cfg,
  88                 uint32_t *obj_id)
  89 {
  90         struct mc_command cmd = { 0 };
  91         int err;
  92
  93         (void)(cfg); /* unused */
  94
  95         /* prepare command */
  96         cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
  97                                           cmd_flags,
  98                                           dprc_token);
  99
 100         /* send command to mc*/
 101         err = mc_send_command(mc_io, &cmd);
 102         if (err)
 103                 return err;
 104
 105         /* retrieve response parameters */
 106         CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, *obj_id);
 107
 108         return 0;
 109 }
 110
 111 int dpbp_destroy(struct fsl_mc_io *mc_io,
 112                  uint16_t dprc_token,
 113                 uint32_t cmd_flags,
 114                 uint32_t object_id)
 115 {
 116         struct mc_command cmd = { 0 };
 117
 118         /* prepare command */
 119         cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
 120                                           cmd_flags,
 121                                           dprc_token);
 122         /* set object id to destroy */
 123         CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id);
 124         /* send command to mc*/
 125         return mc_send_command(mc_io, &cmd);
 126 }
 127
 128 int dpbp_enable(struct fsl_mc_io *mc_io,
 129                 uint32_t cmd_flags,
 130                 uint16_t token)
 131 {
 132         struct mc_command cmd = { 0 };
 133
 134         /* prepare command */
 135         cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags,
 136                                           token);
 137
 138         /* send command to mc*/
 139         return mc_send_command(mc_io, &cmd);
 140 }
 141
 142 int dpbp_disable(struct fsl_mc_io *mc_io,
 143                  uint32_t cmd_flags,
 144                  uint16_t token)
 145 {
 146         struct mc_command cmd = { 0 };
 147
 148         /* prepare command */
 149         cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE,
 150                                           cmd_flags,
 151                                           token);
 152
 153         /* send command to mc*/
 154         return mc_send_command(mc_io, &cmd);
 155 }
 156
 157 int dpbp_is_enabled(struct fsl_mc_io *mc_io,
 158                     uint32_t cmd_flags,
 159                     uint16_t token,
 160                     int *en)
 161 {
 162         struct mc_command cmd = { 0 };
 163         int err;
 164         /* prepare command */
 165         cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, cmd_flags,
 166                                           token);
 167
 168         /* send command to mc*/
 169         err = mc_send_command(mc_io, &cmd);
 170         if (err)
 171                 return err;
 172
 173         /* retrieve response parameters */
 174         DPBP_RSP_IS_ENABLED(cmd, *en);
 175
 176         return 0;
 177 }
 178
 179 int dpbp_reset(struct fsl_mc_io *mc_io,
 180                uint32_t cmd_flags,
 181                uint16_t token)
 182 {
 183         struct mc_command cmd = { 0 };
 184
 185         /* prepare command */
 186         cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET,
 187                                           cmd_flags,
 188                                           token);
 189
 190         /* send command to mc*/
 191         return mc_send_command(mc_io, &cmd);
 192 }
 193 int dpbp_get_attributes(struct fsl_mc_io *mc_io,
 194                         uint32_t cmd_flags,
 195                         uint16_t token,
 196                         struct dpbp_attr *attr)
 197 {
 198         struct mc_command cmd = { 0 };
 199         int err;
 200
 201         /* prepare command */
 202         cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR,
 203                                           cmd_flags,
 204                                           token);
 205
 206         /* send command to mc*/
 207         err = mc_send_command(mc_io, &cmd);
 208         if (err)
 209                 return err;
 210
 211         /* retrieve response parameters */
 212         DPBP_RSP_GET_ATTRIBUTES(cmd, attr);
 213
 214         return 0;
 215 }
 216
 217
 218 int dpbp_get_api_version(struct fsl_mc_io *mc_io,
 219                          uint32_t cmd_flags,
 220                            uint16_t *major_ver,
 221                            uint16_t *minor_ver)
 222 {
 223         struct mc_command cmd = { 0 };
 224         int err;
 225
 226         cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_API_VERSION,
 227                                         cmd_flags,
 228                                         0);
 229
 230         err = mc_send_command(mc_io, &cmd);
 231         if (err)
 232                 return err;
 233
 234         DPBP_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver);
 235
 236         return 0;
 237 }
 238
 239 int dpbp_get_num_free_bufs(struct fsl_mc_io     *mc_io,
 240                            uint32_t             cmd_flags,
 241                            uint16_t             token,
 242                            uint32_t *num_free_bufs)
 243 {
 244         struct mc_command cmd = { 0 };
 245         int err;
 246
 247         /* prepare command */
 248         cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_FREE_BUFFERS_NUM,
 249                                           cmd_flags,
 250                                           token);
 251
 252         /* send command to mc*/
 253         err = mc_send_command(mc_io, &cmd);
 254         if (err)
 255                 return err;
 256
 257         /* retrieve response parameters */
 258         DPBP_RSP_GET_NUM_FREE_BUFS(cmd, *num_free_bufs);
 259
 260         return 0;
 261 }