dpio.c

  1// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
  2/*
  3 * Copyright 2013-2016 Freescale Semiconductor Inc.
  4 * Copyright 2016 NXP
  5 *
  6 */
  7#include <linux/kernel.h>
  8#include <linux/fsl/mc.h>
  9
 10#include "dpio.h"
 11#include "dpio-cmd.h"
 12
 13/*
 14 * Data Path I/O Portal API
 15 * Contains initialization APIs and runtime control APIs for DPIO
 16 */
 17
 18/**
 19 * dpio_open() - Open a control session for the specified object
 20 * @mc_io:	Pointer to MC portal's I/O object
 21 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 22 * @dpio_id:	DPIO unique ID
 23 * @token:	Returned token; use in subsequent API calls
 24 *
 25 * This function can be used to open a control session for an
 26 * already created object; an object may have been declared in
 27 * the DPL or by calling the dpio_create() function.
 28 * This function returns a unique authentication token,
 29 * associated with the specific object ID and the specific MC
 30 * portal; this token must be used in all subsequent commands for
 31 * this specific object.
 32 *
 33 * Return:	'0' on Success; Error code otherwise.
 34 */
 35int dpio_open(struct fsl_mc_io *mc_io,
 36	      u32 cmd_flags,
 37	      int dpio_id,
 38	      u16 *token)
 39{
 40	struct fsl_mc_command cmd = { 0 };
 41	struct dpio_cmd_open *dpio_cmd;
 42	int err;
 43
 44	/* prepare command */
 45	cmd.header = mc_encode_cmd_header(DPIO_CMDID_OPEN,
 46					  cmd_flags,
 47					  0);
 48	dpio_cmd = (struct dpio_cmd_open *)cmd.params;
 49	dpio_cmd->dpio_id = cpu_to_le32(dpio_id);
 50
 51	err = mc_send_command(mc_io, &cmd);
 52	if (err)
 53		return err;
 54
 55	/* retrieve response parameters */
 56	*token = mc_cmd_hdr_read_token(&cmd);
 57
 58	return 0;
 59}
 60
 61/**
 62 * dpio_close() - Close the control session of the object
 63 * @mc_io:	Pointer to MC portal's I/O object
 64 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
 65 * @token:	Token of DPIO object
 66 *
 67 * Return:	'0' on Success; Error code otherwise.
 68 */
 69int dpio_close(struct fsl_mc_io *mc_io,
 70	       u32 cmd_flags,
 71	       u16 token)
 72{
 73	struct fsl_mc_command cmd = { 0 };
 74
 75	/* prepare command */
 76	cmd.header = mc_encode_cmd_header(DPIO_CMDID_CLOSE,
 77					  cmd_flags,
 78					  token);
 79
 80	return mc_send_command(mc_io, &cmd);
 81}
 82
 83/**
 84 * dpio_enable() - Enable the DPIO, allow I/O portal operations.
 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 DPIO object
 88 *
 89 * Return:	'0' on Success; Error code otherwise
 90 */
 91int dpio_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(DPIO_CMDID_ENABLE,
 99					  cmd_flags,
100					  token);
101
102	return mc_send_command(mc_io, &cmd);
103}
104
105/**
106 * dpio_disable() - Disable the DPIO, stop any I/O portal operation.
107 * @mc_io:	Pointer to MC portal's I/O object
108 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
109 * @token:	Token of DPIO object
110 *
111 * Return:	'0' on Success; Error code otherwise
112 */
113int dpio_disable(struct fsl_mc_io *mc_io,
114		 u32 cmd_flags,
115		 u16 token)
116{
117	struct fsl_mc_command cmd = { 0 };
118
119	/* prepare command */
120	cmd.header = mc_encode_cmd_header(DPIO_CMDID_DISABLE,
121					  cmd_flags,
122					  token);
123
124	return mc_send_command(mc_io, &cmd);
125}
126
127/**
128 * dpio_get_attributes() - Retrieve DPIO attributes
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 DPIO object
132 * @attr:	Returned object's attributes
133 *
134 * Return:	'0' on Success; Error code otherwise
135 */
136int dpio_get_attributes(struct fsl_mc_io *mc_io,
137			u32 cmd_flags,
138			u16 token,
139			struct dpio_attr *attr)
140{
141	struct fsl_mc_command cmd = { 0 };
142	struct dpio_rsp_get_attr *dpio_rsp;
143	int err;
144
145	/* prepare command */
146	cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_ATTR,
147					  cmd_flags,
148					  token);
149
150	err = mc_send_command(mc_io, &cmd);
151	if (err)
152		return err;
153
154	/* retrieve response parameters */
155	dpio_rsp = (struct dpio_rsp_get_attr *)cmd.params;
156	attr->id = le32_to_cpu(dpio_rsp->id);
157	attr->qbman_portal_id = le16_to_cpu(dpio_rsp->qbman_portal_id);
158	attr->num_priorities = dpio_rsp->num_priorities;
159	attr->channel_mode = dpio_rsp->channel_mode & DPIO_CHANNEL_MODE_MASK;
160	attr->qbman_portal_ce_offset =
161		le64_to_cpu(dpio_rsp->qbman_portal_ce_addr);
162	attr->qbman_portal_ci_offset =
163		le64_to_cpu(dpio_rsp->qbman_portal_ci_addr);
164	attr->qbman_version = le32_to_cpu(dpio_rsp->qbman_version);
165	attr->clk = le32_to_cpu(dpio_rsp->clk);
166
167	return 0;
168}
169
170int dpio_set_stashing_destination(struct fsl_mc_io *mc_io,
171				  u32 cmd_flags,
172				  u16 token,
173				  u8 sdest)
174{
175	struct fsl_mc_command cmd = { 0 };
176	struct dpio_stashing_dest *dpio_cmd;
177
178	cmd.header = mc_encode_cmd_header(DPIO_CMDID_SET_STASHING_DEST,
179					  cmd_flags, token);
180	dpio_cmd = (struct dpio_stashing_dest *)cmd.params;
181	dpio_cmd->sdest = sdest;
182
183	return mc_send_command(mc_io, &cmd);
184}
185
186/**
187 * dpio_get_api_version - Get Data Path I/O API version
188 * @mc_io:	Pointer to MC portal's DPIO object
189 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
190 * @major_ver:	Major version of DPIO API
191 * @minor_ver:	Minor version of DPIO API
192 *
193 * Return:	'0' on Success; Error code otherwise
194 */
195int dpio_get_api_version(struct fsl_mc_io *mc_io,
196			 u32 cmd_flags,
197			 u16 *major_ver,
198			 u16 *minor_ver)
199{
200	struct fsl_mc_command cmd = { 0 };
201	int err;
202
203	/* prepare command */
204	cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
205					  cmd_flags, 0);
206
207	err = mc_send_command(mc_io, &cmd);
208	if (err)
209		return err;
210
211	/* retrieve response parameters */
212	mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
213
214	return 0;
215}
216
217/**
218 * dpio_reset() - Reset the DPIO, returns the object to initial state.
219 * @mc_io:	Pointer to MC portal's I/O object
220 * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
221 * @token:	Token of DPIO object
222 *
223 * Return:	'0' on Success; Error code otherwise.
224 */
225int dpio_reset(struct fsl_mc_io *mc_io,
226	       u32 cmd_flags,
227	       u16 token)
228{
229	struct fsl_mc_command cmd = { 0 };
230
231	/* prepare command */
232	cmd.header = mc_encode_cmd_header(DPIO_CMDID_RESET,
233					  cmd_flags,
234					  token);
235
236	/* send command to mc*/
237	return mc_send_command(mc_io, &cmd);
238}