dpbp.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 * dpbp_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 * @dpbp_id:	DPBP 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 dpbp_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 dpbp_open(struct fsl_mc_io *mc_io,
 29	      u32 cmd_flags,
 30	      int dpbp_id,
 31	      u16 *token)
 32{
 33	struct fsl_mc_command cmd = { 0 };
 34	struct dpbp_cmd_open *cmd_params;
 35	int err;
 36
 37	/* prepare command */
 38	cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
 39					  cmd_flags, 0);
 40	cmd_params = (struct dpbp_cmd_open *)cmd.params;
 41	cmd_params->dpbp_id = cpu_to_le32(dpbp_id);
 42
 43	/* send command to mc*/
 44	err = mc_send_command(mc_io, &cmd);
 45	if (err)
 46		return err;
 47
 48	/* retrieve response parameters */
 49	*token = mc_cmd_hdr_read_token(&cmd);
 50
 51	return err;
 52}
 53EXPORT_SYMBOL_GPL(dpbp_open);
 54
 55/**
 56 * dpbp_close() - Close the control session of the object
 57 * @mc_io:	Pointer to MC portal's I/O object
 58 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 59 * @token:	Token of DPBP object
 60 *
 61 * After this function is called, no further operations are
 62 * allowed on the object without opening a new control session.
 63 *
 64 * Return:	'0' on Success; Error code otherwise.
 65 */
 66int dpbp_close(struct fsl_mc_io *mc_io,
 67	       u32 cmd_flags,
 68	       u16 token)
 69{
 70	struct fsl_mc_command cmd = { 0 };
 71
 72	/* prepare command */
 73	cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags,
 74					  token);
 75
 76	/* send command to mc*/
 77	return mc_send_command(mc_io, &cmd);
 78}
 79EXPORT_SYMBOL_GPL(dpbp_close);
 80
 81/**
 82 * dpbp_enable() - Enable the DPBP.
 83 * @mc_io:	Pointer to MC portal's I/O object
 84 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 85 * @token:	Token of DPBP object
 86 *
 87 * Return:	'0' on Success; Error code otherwise.
 88 */
 89int dpbp_enable(struct fsl_mc_io *mc_io,
 90		u32 cmd_flags,
 91		u16 token)
 92{
 93	struct fsl_mc_command cmd = { 0 };
 94
 95	/* prepare command */
 96	cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags,
 97					  token);
 98
 99	/* send command to mc*/
100	return mc_send_command(mc_io, &cmd);
101}
102EXPORT_SYMBOL_GPL(dpbp_enable);
103
104/**
105 * dpbp_disable() - Disable the DPBP.
106 * @mc_io:	Pointer to MC portal's I/O object
107 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
108 * @token:	Token of DPBP object
109 *
110 * Return:	'0' on Success; Error code otherwise.
111 */
112int dpbp_disable(struct fsl_mc_io *mc_io,
113		 u32 cmd_flags,
114		 u16 token)
115{
116	struct fsl_mc_command cmd = { 0 };
117
118	/* prepare command */
119	cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE,
120					  cmd_flags, token);
121
122	/* send command to mc*/
123	return mc_send_command(mc_io, &cmd);
124}
125EXPORT_SYMBOL_GPL(dpbp_disable);
126
127/**
128 * dpbp_reset() - Reset the DPBP, returns the object to initial state.
129 * @mc_io:	Pointer to MC portal's I/O object
130 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
131 * @token:	Token of DPBP object
132 *
133 * Return:	'0' on Success; Error code otherwise.
134 */
135int dpbp_reset(struct fsl_mc_io *mc_io,
136	       u32 cmd_flags,
137	       u16 token)
138{
139	struct fsl_mc_command cmd = { 0 };
140
141	/* prepare command */
142	cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET,
143					  cmd_flags, token);
144
145	/* send command to mc*/
146	return mc_send_command(mc_io, &cmd);
147}
148EXPORT_SYMBOL_GPL(dpbp_reset);
149
150/**
151 * dpbp_get_attributes - Retrieve DPBP attributes.
152 *
153 * @mc_io:	Pointer to MC portal's I/O object
154 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
155 * @token:	Token of DPBP object
156 * @attr:	Returned object's attributes
157 *
158 * Return:	'0' on Success; Error code otherwise.
159 */
160int dpbp_get_attributes(struct fsl_mc_io *mc_io,
161			u32 cmd_flags,
162			u16 token,
163			struct dpbp_attr *attr)
164{
165	struct fsl_mc_command cmd = { 0 };
166	struct dpbp_rsp_get_attributes *rsp_params;
167	int err;
168
169	/* prepare command */
170	cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR,
171					  cmd_flags, token);
172
173	/* send command to mc*/
174	err = mc_send_command(mc_io, &cmd);
175	if (err)
176		return err;
177
178	/* retrieve response parameters */
179	rsp_params = (struct dpbp_rsp_get_attributes *)cmd.params;
180	attr->bpid = le16_to_cpu(rsp_params->bpid);
181	attr->id = le32_to_cpu(rsp_params->id);
182
183	return 0;
184}
185EXPORT_SYMBOL_GPL(dpbp_get_attributes);