d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bus/fslmc: introduce MC object functions

Browse Source 
This patch introduces the DPAA2 MC(Management complex Driver).

This is a minimal set of low level functions to send and
receive commands to the fsl-mc. It includes support for basic
management commands and commands to manipulate MC objects.

This is common to be used by various DPAA2 PMDs. e.g.net, crypto
and other drivers.

This is a low level library also used in kernel.

Signed-off-by: Cristian Sovaiala <cristian.sovaiala@nxp.com>
Signed-off-by: Hemant Agrawal <hemant.agrawal@nxp.com>
This commit is contained in:
Hemant Agrawal 2017-04-11 19:07:10 +05:30 committed by Ferruh Yigit
parent 531b17a780
commit 3af733ba8d
5 changed files with 463 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/bus/fslmc/Makefile
View File

@ -49,6 +49,7 @@ CFLAGS += $(WERROR_FLAGS)
endif
CFLAGS += -I$(RTE_SDK)/drivers/bus/fslmc
CFLAGS += -I$(RTE_SDK)/drivers/bus/fslmc/mc
CFLAGS += -I$(RTE_SDK)/drivers/bus/fslmc/qbman/include
CFLAGS += -I$(RTE_SDK)/lib/librte_eal/linuxapp/eal
@ -61,6 +62,9 @@ LIBABIVER := 1
SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += \
qbman/qbman_portal.c
SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += \
mc/mc_sys.c
SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += fslmc_bus.c
include $(RTE_SDK)/mk/rte.lib.mk

239
drivers/bus/fslmc/mc/fsl_mc_cmd.h Normal file
View File

@ -0,0 +1,239 @@
/*-
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* BSD LICENSE
*
* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright (c) 2016 NXP.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* GPL LICENSE SUMMARY
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FSL_MC_CMD_H
#define __FSL_MC_CMD_H
#define MC_CMD_NUM_OF_PARAMS 7
#define MAKE_UMASK64(_width) \
((uint64_t)((_width) < 64 ? ((uint64_t)1 << (_width)) - 1 : \
(uint64_t)-1))
static inline uint64_t mc_enc(int lsoffset, int width, uint64_t val)
{
return (uint64_t)(((uint64_t)val & MAKE_UMASK64(width)) << lsoffset);
}
static inline uint64_t mc_dec(uint64_t val, int lsoffset, int width)
{
return (uint64_t)((val >> lsoffset) & MAKE_UMASK64(width));
}
struct mc_command {
uint64_t header;
uint64_t params[MC_CMD_NUM_OF_PARAMS];
};
/**
* enum mc_cmd_status - indicates MC status at command response
* @MC_CMD_STATUS_OK: Completed successfully
* @MC_CMD_STATUS_READY: Ready to be processed
* @MC_CMD_STATUS_AUTH_ERR: Authentication error
* @MC_CMD_STATUS_NO_PRIVILEGE: No privilege
* @MC_CMD_STATUS_DMA_ERR: DMA or I/O error
* @MC_CMD_STATUS_CONFIG_ERR: Configuration error
* @MC_CMD_STATUS_TIMEOUT: Operation timed out
* @MC_CMD_STATUS_NO_RESOURCE: No resources
* @MC_CMD_STATUS_NO_MEMORY: No memory available
* @MC_CMD_STATUS_BUSY: Device is busy
* @MC_CMD_STATUS_UNSUPPORTED_OP: Unsupported operation
* @MC_CMD_STATUS_INVALID_STATE: Invalid state
*/
enum mc_cmd_status {
MC_CMD_STATUS_OK = 0x0,
MC_CMD_STATUS_READY = 0x1,
MC_CMD_STATUS_AUTH_ERR = 0x3,
MC_CMD_STATUS_NO_PRIVILEGE = 0x4,
MC_CMD_STATUS_DMA_ERR = 0x5,
MC_CMD_STATUS_CONFIG_ERR = 0x6,
MC_CMD_STATUS_TIMEOUT = 0x7,
MC_CMD_STATUS_NO_RESOURCE = 0x8,
MC_CMD_STATUS_NO_MEMORY = 0x9,
MC_CMD_STATUS_BUSY = 0xA,
MC_CMD_STATUS_UNSUPPORTED_OP = 0xB,
MC_CMD_STATUS_INVALID_STATE = 0xC
};
/* MC command flags */
/**
* High priority flag
*/
#define MC_CMD_FLAG_PRI 0x00008000
/**
* Command completion flag
*/
#define MC_CMD_FLAG_INTR_DIS 0x01000000
/**
* Command ID field offset
*/
#define MC_CMD_HDR_CMDID_O 48
/**
* Command ID field size
*/
#define MC_CMD_HDR_CMDID_S 16
/**
* Token field offset
*/
#define MC_CMD_HDR_TOKEN_O 32
/**
* Token field size
*/
#define MC_CMD_HDR_TOKEN_S 16
/**
* Status field offset
*/
#define MC_CMD_HDR_STATUS_O 16
/**
* Status field size
*/
#define MC_CMD_HDR_STATUS_S 8
/**
* Flags field offset
*/
#define MC_CMD_HDR_FLAGS_O 0
/**
* Flags field size
*/
#define MC_CMD_HDR_FLAGS_S 32
/**
* Command flags mask
*/
#define MC_CMD_HDR_FLAGS_MASK 0xFF00FF00
#define MC_CMD_HDR_READ_STATUS(_hdr) \
((enum mc_cmd_status)mc_dec((_hdr), \
MC_CMD_HDR_STATUS_O, MC_CMD_HDR_STATUS_S))
#define MC_CMD_HDR_READ_TOKEN(_hdr) \
((uint16_t)mc_dec((_hdr), MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S))
#define MC_PREP_OP(_ext, _param, _offset, _width, _type, _arg) \
((_ext)[_param] |= cpu_to_le64(mc_enc((_offset), (_width), _arg)))
#define MC_EXT_OP(_ext, _param, _offset, _width, _type, _arg) \
(_arg = (_type)mc_dec(cpu_to_le64(_ext[_param]), (_offset), (_width)))
#define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \
((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg))
#define MC_RSP_OP(_cmd, _param, _offset, _width, _type, _arg) \
(_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width)))
/* cmd, param, offset, width, type, arg_name */
#define CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, object_id) \
MC_RSP_OP(cmd, 0, 0, 32, uint32_t, object_id)
/* cmd, param, offset, width, type, arg_name */
#define CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id) \
MC_CMD_OP(cmd, 0, 0, 32, uint32_t, object_id)
static inline uint64_t mc_encode_cmd_header(uint16_t cmd_id,
uint32_t cmd_flags,
uint16_t token)
{
uint64_t hdr;
hdr = mc_enc(MC_CMD_HDR_CMDID_O, MC_CMD_HDR_CMDID_S, cmd_id);
hdr |= mc_enc(MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S,
(cmd_flags & MC_CMD_HDR_FLAGS_MASK));
hdr |= mc_enc(MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S, token);
hdr |= mc_enc(MC_CMD_HDR_STATUS_O, MC_CMD_HDR_STATUS_S,
MC_CMD_STATUS_READY);
return hdr;
}
/**
* mc_write_command - writes a command to a Management Complex (MC) portal
*
* @portal: pointer to an MC portal
* @cmd: pointer to a filled command
*/
static inline void mc_write_command(struct mc_command __iomem *portal,
struct mc_command *cmd)
{
int i;
uint32_t word;
char *header = (char *)&portal->header;
/* copy command parameters into the portal */
for (i = 0; i < MC_CMD_NUM_OF_PARAMS; i++)
iowrite64(cmd->params[i], &portal->params[i]);
/* submit the command by writing the header */
word = (uint32_t)mc_dec(cmd->header, 32, 32);
iowrite32(word, (((uint32_t *)header) + 1));
word = (uint32_t)mc_dec(cmd->header, 0, 32);
iowrite32(word, (uint32_t *)header);
}
/**
* mc_read_response - reads the response for the last MC command from a
* Management Complex (MC) portal
*
* @portal: pointer to an MC portal
* @resp: pointer to command response buffer
*
* Returns MC_CMD_STATUS_OK on Success; Error code otherwise.
*/
static inline enum mc_cmd_status mc_read_response(
struct mc_command __iomem *portal,
struct mc_command *resp)
{
int i;
enum mc_cmd_status status;
/* Copy command response header from MC portal: */
resp->header = ioread64(&portal->header);
status = MC_CMD_HDR_READ_STATUS(resp->header);
if (status != MC_CMD_STATUS_OK)
return status;
/* Copy command response data from MC portal: */
for (i = 0; i < MC_CMD_NUM_OF_PARAMS; i++)
resp->params[i] = ioread64(&portal->params[i]);
return status;
}
#endif /* __FSL_MC_CMD_H */

105
drivers/bus/fslmc/mc/fsl_mc_sys.h Normal file
View File

@ -0,0 +1,105 @@
/*-
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* BSD LICENSE
*
* Copyright 2013-2015 Freescale Semiconductor Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* GPL LICENSE SUMMARY
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _FSL_MC_SYS_H
#define _FSL_MC_SYS_H
#ifdef __linux_driver__
#include <linux/errno.h>
#include <asm/io.h>
#include <linux/slab.h>
struct fsl_mc_io {
void *regs;
};
#ifndef ENOTSUP
#define ENOTSUP 95
#endif
#define ioread64(_p) readq(_p)
#define iowrite64(_v, _p) writeq(_v, _p)
#else /* __linux_driver__ */
#include <stdio.h>
#include <libio.h>
#include <stdint.h>
#include <errno.h>
#include <sys/uio.h>
#include <linux/byteorder/little_endian.h>
#define cpu_to_le64(x) __cpu_to_le64(x)
#ifndef dmb
#define dmb() {__asm__ __volatile__("" : : : "memory"); }
#endif
#define __iormb() dmb()
#define __iowmb() dmb()
#define __arch_getq(a) (*(volatile unsigned long *)(a))
#define __arch_putq(v, a) (*(volatile unsigned long *)(a) = (v))
#define __arch_putq32(v, a) (*(volatile unsigned int *)(a) = (v))
#define readq(c) \
({ uint64_t __v = __arch_getq(c); __iormb(); __v; })
#define writeq(v, c) \
({ uint64_t __v = v; __iowmb(); __arch_putq(__v, c); __v; })
#define writeq32(v, c) \
({ uint32_t __v = v; __iowmb(); __arch_putq32(__v, c); __v; })
#define ioread64(_p) readq(_p)
#define iowrite64(_v, _p) writeq(_v, _p)
#define iowrite32(_v, _p) writeq32(_v, _p)
#define __iomem
struct fsl_mc_io {
void *regs;
};
#ifndef ENOTSUP
#define ENOTSUP 95
#endif
/*GPP is supposed to use MC commands with low priority*/
#define CMD_PRI_LOW 0 /*!< Low Priority command indication */
struct mc_command;
int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd);
#endif /* __linux_driver__ */
#endif /* _FSL_MC_SYS_H */

114
drivers/bus/fslmc/mc/mc_sys.c Normal file
View File

@ -0,0 +1,114 @@
/*-
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* BSD LICENSE
*
* Copyright 2013-2015 Freescale Semiconductor Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* GPL LICENSE SUMMARY
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <fsl_mc_sys.h>
#include <fsl_mc_cmd.h>
#include <rte_spinlock.h>
/** User space framework uses MC Portal in shared mode. Following change
* introduces lock in MC FLIB
*/
/**
* A static spinlock initializer.
*/
static rte_spinlock_t mc_portal_lock = RTE_SPINLOCK_INITIALIZER;
static int mc_status_to_error(enum mc_cmd_status status)
{
switch (status) {
case MC_CMD_STATUS_OK:
return 0;
case MC_CMD_STATUS_AUTH_ERR:
return -EACCES; /* Token error */
case MC_CMD_STATUS_NO_PRIVILEGE:
return -EPERM; /* Permission denied */
case MC_CMD_STATUS_DMA_ERR:
return -EIO; /* Input/Output error */
case MC_CMD_STATUS_CONFIG_ERR:
return -EINVAL; /* Device not configured */
case MC_CMD_STATUS_TIMEOUT:
return -ETIMEDOUT; /* Operation timed out */
case MC_CMD_STATUS_NO_RESOURCE:
return -ENAVAIL; /* Resource temporarily unavailable */
case MC_CMD_STATUS_NO_MEMORY:
return -ENOMEM; /* Cannot allocate memory */
case MC_CMD_STATUS_BUSY:
return -EBUSY; /* Device busy */
case MC_CMD_STATUS_UNSUPPORTED_OP:
return -ENOTSUP; /* Operation not supported by device */
case MC_CMD_STATUS_INVALID_STATE:
return -ENODEV; /* Invalid device state */
default:
break;
}
/* Not expected to reach here */
return -EINVAL;
}
int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd)
{
enum mc_cmd_status status;
if (!mc_io || !mc_io->regs)
return -EACCES;
/* --- Call lock function here in case portal is shared --- */
rte_spinlock_lock(&mc_portal_lock);
mc_write_command(mc_io->regs, cmd);
/* Spin until status changes */
do {
status = MC_CMD_HDR_READ_STATUS(ioread64(mc_io->regs));
/* --- Call wait function here to prevent blocking ---
* Change the loop condition accordingly to exit on timeout.
*/
} while (status == MC_CMD_STATUS_READY);
/* Read the response back into the command buffer */
mc_read_response(mc_io->regs, cmd);
/* --- Call unlock function here in case portal is shared --- */
rte_spinlock_unlock(&mc_portal_lock);
return mc_status_to_error(status);
}

1
drivers/bus/fslmc/rte_bus_fslmc_version.map
View File

@ -1,6 +1,7 @@
DPDK_17.05 {
global:
mc_send_command;
qbman_check_command_complete;
qbman_eq_desc_clear;
qbman_eq_desc_set_no_orp;