hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

staging: fsl-mc: fsl-mc object allocator driver 

The fsl-mc object allocator driver manages "allocatable" fsl-mc
objects such as DPBPs, DPMCPs and DPCONs. It provides services to
other fsl-mc drivers to allocate/deallocate these types of objects.

Signed-off-by: J. German Rivera <German.Rivera@freescale.com>
Signed-off-by: Stuart Yoder <stuart.yoder@freescale.com>
Acked-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
J. German Rivera 2015-03-05 19:35:25 -06:00 committed by Greg Kroah-Hartman
parent f2f2726b62
commit 197f4d6a4a
15 changed files with 2366 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/staging/fsl-mc/bus/Makefile
View File

@ -5,7 +5,8 @@
#
# This file is released under the GPLv2
#
obj-$(CONFIG_FSL_MC_BUS) += mc-bus-driver.o
obj-$(CONFIG_FSL_MC_BUS) += mc-bus-driver.o \
mc-allocator-driver.o
mc-bus-driver-objs := mc-bus.o \
mc-sys.o \
@ -13,3 +14,6 @@ mc-bus-driver-objs := mc-bus.o \
dpmng.o \
dprc-driver.o
mc-allocator-driver-objs := mc-allocator.o \
dpmcp.o \
dpbp.o

358
drivers/staging/fsl-mc/bus/dpbp.c Normal file
View File

@ -0,0 +1,358 @@
/* Copyright 2013-2014 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.
*
*
* 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 "../include/mc-sys.h"
#include "../include/mc-cmd.h"
#include "../include/dpbp.h"
#include "../include/dpbp-cmd.h"
int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_OPEN,
MC_CMD_PRI_LOW, 0);
cmd.params[0] |= mc_enc(0, 32, dpbp_id);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
return err;
}
EXPORT_SYMBOL(dpbp_open);
int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, MC_CMD_PRI_HIGH,
token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
EXPORT_SYMBOL(dpbp_close);
int dpbp_create(struct fsl_mc_io *mc_io,
const struct dpbp_cfg *cfg,
uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;
(void)(cfg); /* unused */
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
MC_CMD_PRI_LOW, 0);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
return 0;
}
int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, MC_CMD_PRI_LOW,
token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
EXPORT_SYMBOL(dpbp_enable);
int dpbp_disable(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
EXPORT_SYMBOL(dpbp_disable);
int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, MC_CMD_PRI_LOW,
token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*en = (int)mc_dec(cmd.params[0], 0, 1);
return 0;
}
int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_set_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint64_t irq_paddr,
uint32_t irq_val,
int user_irq_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 8, irq_index);
cmd.params[0] |= mc_enc(32, 32, irq_val);
cmd.params[1] |= mc_enc(0, 64, irq_paddr);
cmd.params[2] |= mc_enc(0, 32, user_irq_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_get_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
int *type,
uint64_t *irq_paddr,
uint32_t *irq_val,
int *user_irq_id)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*irq_val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
*irq_paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
*user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
*type = (int)mc_dec(cmd.params[2], 32, 32);
return 0;
}
int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t en)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_ENABLE,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 8, en);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t *en)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_ENABLE,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*en = (uint8_t)mc_dec(cmd.params[0], 0, 8);
return 0;
}
int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t mask)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_SET_IRQ_MASK,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 32, mask);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *mask)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_MASK,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*mask = (uint32_t)mc_dec(cmd.params[0], 0, 32);
return 0;
}
int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *status)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_IRQ_STATUS,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*status = (uint32_t)mc_dec(cmd.params[0], 0, 32);
return 0;
}
int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t status)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLEAR_IRQ_STATUS,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 32, status);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpbp_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpbp_attr *attr)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
attr->bpid = (uint16_t)mc_dec(cmd.params[0], 16, 16);
attr->id = (int)mc_dec(cmd.params[0], 32, 32);
attr->version.major = (uint16_t)mc_dec(cmd.params[1], 0, 16);
attr->version.minor = (uint16_t)mc_dec(cmd.params[1], 16, 16);
return 0;
}
EXPORT_SYMBOL(dpbp_get_attributes);

136
drivers/staging/fsl-mc/bus/dpmcp-cmd.h Normal file
View File

@ -0,0 +1,136 @@
/* 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.
*
*
* 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_DPMCP_CMD_H
#define _FSL_DPMCP_CMD_H
/* DPMCP Version */
#define DPMCP_VER_MAJOR 2
#define DPMCP_VER_MINOR 0
/* Command IDs */
#define DPMCP_CMDID_CLOSE 0x800
#define DPMCP_CMDID_OPEN 0x80b
#define DPMCP_CMDID_CREATE 0x90b
#define DPMCP_CMDID_DESTROY 0x900
#define DPMCP_CMDID_GET_ATTR 0x004
#define DPMCP_CMDID_RESET 0x005
#define DPMCP_CMDID_SET_IRQ 0x010
#define DPMCP_CMDID_GET_IRQ 0x011
#define DPMCP_CMDID_SET_IRQ_ENABLE 0x012
#define DPMCP_CMDID_GET_IRQ_ENABLE 0x013
#define DPMCP_CMDID_SET_IRQ_MASK 0x014
#define DPMCP_CMDID_GET_IRQ_MASK 0x015
#define DPMCP_CMDID_GET_IRQ_STATUS 0x016
#define DPMCP_CMDID_CLEAR_IRQ_STATUS 0x017
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_CREATE(cmd, cfg) \
MC_CMD_OP(cmd, 0, 0, 32, int, cfg->portal_id)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_SET_IRQ(cmd, irq_index, irq_addr, irq_val, user_irq_id) \
do { \
MC_CMD_OP(cmd, 0, 0, 8, uint8_t, irq_index);\
MC_CMD_OP(cmd, 0, 32, 32, uint32_t, irq_val);\
MC_CMD_OP(cmd, 1, 0, 64, uint64_t, irq_addr); \
MC_CMD_OP(cmd, 2, 0, 32, int, user_irq_id); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_GET_IRQ(cmd, irq_index) \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_RSP_GET_IRQ(cmd, type, irq_addr, irq_val, user_irq_id) \
do { \
MC_RSP_OP(cmd, 0, 0, 32, uint32_t, irq_val); \
MC_RSP_OP(cmd, 1, 0, 64, uint64_t, irq_addr); \
MC_RSP_OP(cmd, 2, 0, 32, int, user_irq_id); \
MC_RSP_OP(cmd, 2, 32, 32, int, type); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_SET_IRQ_ENABLE(cmd, irq_index, en) \
do { \
MC_CMD_OP(cmd, 0, 0, 8, uint8_t, en); \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_GET_IRQ_ENABLE(cmd, irq_index) \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_RSP_GET_IRQ_ENABLE(cmd, en) \
MC_RSP_OP(cmd, 0, 0, 8, uint8_t, en)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_SET_IRQ_MASK(cmd, irq_index, mask) \
do { \
MC_CMD_OP(cmd, 0, 0, 32, uint32_t, mask);\
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_GET_IRQ_MASK(cmd, irq_index) \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_RSP_GET_IRQ_MASK(cmd, mask) \
MC_RSP_OP(cmd, 0, 0, 32, uint32_t, mask)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_GET_IRQ_STATUS(cmd, irq_index) \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_RSP_GET_IRQ_STATUS(cmd, status) \
MC_RSP_OP(cmd, 0, 0, 32, uint32_t, status)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status) \
do { \
MC_CMD_OP(cmd, 0, 0, 32, uint32_t, status); \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPMCP_RSP_GET_ATTRIBUTES(cmd, attr) \
do { \
MC_RSP_OP(cmd, 0, 32, 32, int, attr->id);\
MC_RSP_OP(cmd, 1, 0, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, attr->version.minor);\
} while (0)
#endif /* _FSL_DPMCP_CMD_H */

308
drivers/staging/fsl-mc/bus/dpmcp.c Normal file
View File

@ -0,0 +1,308 @@
/* 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.
*
*
* 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 "../include/mc-sys.h"
#include "../include/mc-cmd.h"
#include "dpmcp.h"
#include "dpmcp-cmd.h"
int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_OPEN,
MC_CMD_PRI_LOW, 0);
cmd.params[0] |= mc_enc(0, 32, dpmcp_id);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
return err;
}
int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE, MC_CMD_PRI_HIGH,
token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_create(struct fsl_mc_io *mc_io,
const struct dpmcp_cfg *cfg,
uint16_t *token)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CREATE,
MC_CMD_PRI_LOW, 0);
cmd.params[0] |= mc_enc(0, 32, cfg->portal_id);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
return 0;
}
int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_DESTROY,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_RESET,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_set_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint64_t irq_addr,
uint32_t irq_val,
int user_irq_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 8, irq_index);
cmd.params[0] |= mc_enc(32, 32, irq_val);
cmd.params[1] |= mc_enc(0, 64, irq_addr);
cmd.params[2] |= mc_enc(0, 32, user_irq_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_get_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
int *type,
uint64_t *irq_addr,
uint32_t *irq_val,
int *user_irq_id)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*irq_val = (uint32_t)mc_dec(cmd.params[0], 0, 32);
*irq_addr = (uint64_t)mc_dec(cmd.params[1], 0, 64);
*user_irq_id = (int)mc_dec(cmd.params[2], 0, 32);
*type = (int)mc_dec(cmd.params[2], 32, 32);
return 0;
}
int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t en)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_ENABLE,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 8, en);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t *en)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_ENABLE,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*en = (uint8_t)mc_dec(cmd.params[0], 0, 8);
return 0;
}
int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t mask)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ_MASK,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 32, mask);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *mask)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_MASK,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*mask = (uint32_t)mc_dec(cmd.params[0], 0, 32);
return 0;
}
int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *status)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_IRQ_STATUS,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
*status = (uint32_t)mc_dec(cmd.params[0], 0, 32);
return 0;
}
int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t status)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLEAR_IRQ_STATUS,
MC_CMD_PRI_LOW, token);
cmd.params[0] |= mc_enc(0, 32, status);
cmd.params[0] |= mc_enc(32, 8, irq_index);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpmcp_attr *attr)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMCP_CMDID_GET_ATTR,
MC_CMD_PRI_LOW, token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
attr->id = (int)mc_dec(cmd.params[0], 32, 32);
attr->version.major = (uint16_t)mc_dec(cmd.params[1], 0, 16);
attr->version.minor = (uint16_t)mc_dec(cmd.params[1], 16, 16);
return 0;
}

311
drivers/staging/fsl-mc/bus/dpmcp.h Normal file
View File

@ -0,0 +1,311 @@
/* 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.
*
*
* 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_DPMCP_H
#define __FSL_DPMCP_H
/* Data Path Management Command Portal API
* Contains initialization APIs and runtime control APIs for DPMCP
*/
struct fsl_mc_io;
/**
* dpmcp_open() - Open a control session for the specified object.
* @mc_io: Pointer to MC portal's I/O object
* @dpmcp_id: DPMCP unique ID
* @token: Returned token; use in subsequent API calls
*
* This function can be used to open a control session for an
* already created object; an object may have been declared in
* the DPL or by calling the dpmcp_create function.
* This function returns a unique authentication token,
* associated with the specific object ID and the specific MC
* portal; this token must be used in all subsequent commands for
* this specific object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token);
/* Get portal ID from pool */
#define DPMCP_GET_PORTAL_ID_FROM_POOL (-1)
/**
* dpmcp_close() - Close the control session of the object
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
*
* After this function is called, no further operations are
* allowed on the object without opening a new control session.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token);
/**
* struct dpmcp_cfg() - Structure representing DPMCP configuration
* @portal_id: Portal ID; 'DPMCP_GET_PORTAL_ID_FROM_POOL' to get the portal ID
* from pool
*/
struct dpmcp_cfg {
int portal_id;
};
/**
* dpmcp_create() - Create the DPMCP object.
* @mc_io: Pointer to MC portal's I/O object
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
*
* Create the DPMCP object, allocate required resources and
* perform required initialization.
*
* The object can be created either by declaring it in the
* DPL file, or by calling this function.
* This function returns a unique authentication token,
* associated with the specific object ID and the specific MC
* portal; this token must be used in all subsequent calls to
* this specific object. For objects that are created using the
* DPL file, call dpmcp_open function to get an authentication
* token first.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_create(struct fsl_mc_io *mc_io,
const struct dpmcp_cfg *cfg,
uint16_t *token);
/**
* dpmcp_destroy() - Destroy the DPMCP object and release all its resources.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
*
* Return: '0' on Success; error code otherwise.
*/
int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token);
/**
* dpmcp_reset() - Reset the DPMCP, returns the object to initial state.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token);
/* IRQ */
/*!
* @name dpmcp IRQ Index and Events
*/
#define DPMCP_IRQ_INDEX 0
/*!< Irq index */
#define DPMCP_IRQ_EVENT_CMD_DONE 0x00000001
/*!< irq event - Indicates that the link state changed */
/* @} */
/**
* dpmcp_set_irq() - Set IRQ information for the DPMCP to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: Identifies the interrupt index to configure
* @irq_addr: Address that must be written to
* signal a message-based interrupt
* @irq_val: Value to write into irq_addr address
* @user_irq_id: A user defined number associated with this IRQ
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_set_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint64_t irq_addr,
uint32_t irq_val,
int user_irq_id);
/**
* dpmcp_get_irq() - Get IRQ information from the DPMCP.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @type: Interrupt type: 0 represents message interrupt
* type (both irq_addr and irq_val are valid)
* @irq_addr: Returned address that must be written to
* signal the message-based interrupt
* @irq_val: Value to write into irq_addr address
* @user_irq_id: A user defined number associated with this IRQ
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
int *type,
uint64_t *irq_addr,
uint32_t *irq_val,
int *user_irq_id);
/**
* dpmcp_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
*
* Allows GPP software to control when interrupts are generated.
* Each interrupt can have up to 32 causes. The enable/disable control's the
* overall interrupt state. if the interrupt is disabled no causes will cause
* an interrupt.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t en);
/**
* dpmcp_get_irq_enable() - Get overall interrupt state
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t *en);
/**
* dpmcp_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @mask: Event mask to trigger interrupt;
* each bit:
* 0 = ignore event
* 1 = consider event for asserting IRQ
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t mask);
/**
* dpmcp_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *mask);
/**
* dpmcp_get_irq_status() - Get the current status of any pending interrupts.
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
* 0 = no interrupt pending
* 1 = interrupt pending
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *status);
/**
* dpmcp_clear_irq_status() - Clear a pending interrupt's status
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @irq_index: The interrupt index to configure
* @status: Bits to clear (W1C) - one bit per cause:
* 0 = don't change
* 1 = clear status bit
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t status);
/**
* struct dpmcp_attr - Structure representing DPMCP attributes
* @id: DPMCP object ID
* @version: DPMCP version
*/
struct dpmcp_attr {
int id;
/**
* struct version - Structure representing DPMCP version
* @major: DPMCP major version
* @minor: DPMCP minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
};
/**
* dpmcp_get_attributes - Retrieve DPMCP attributes.
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPMCP object
* @attr: Returned object's attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmcp_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpmcp_attr *attr);
#endif /* __FSL_DPMCP_H */

104
drivers/staging/fsl-mc/bus/dprc-driver.c
View File

@ -156,6 +156,85 @@ static void dprc_add_new_devices(struct fsl_mc_device *mc_bus_dev,
}
}
static void dprc_init_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
{
int pool_type;
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++) {
struct fsl_mc_resource_pool *res_pool =
&mc_bus->resource_pools[pool_type];
res_pool->type = pool_type;
res_pool->max_count = 0;
res_pool->free_count = 0;
res_pool->mc_bus = mc_bus;
INIT_LIST_HEAD(&res_pool->free_list);
mutex_init(&res_pool->mutex);
}
}
static void dprc_cleanup_resource_pool(struct fsl_mc_device *mc_bus_dev,
enum fsl_mc_pool_type pool_type)
{
struct fsl_mc_resource *resource;
struct fsl_mc_resource *next;
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
struct fsl_mc_resource_pool *res_pool =
&mc_bus->resource_pools[pool_type];
int free_count = 0;
WARN_ON(res_pool->type != pool_type);
WARN_ON(res_pool->free_count != res_pool->max_count);
list_for_each_entry_safe(resource, next, &res_pool->free_list, node) {
free_count++;
WARN_ON(resource->type != res_pool->type);
WARN_ON(resource->parent_pool != res_pool);
devm_kfree(&mc_bus_dev->dev, resource);
}
WARN_ON(free_count != res_pool->free_count);
}
static void dprc_cleanup_all_resource_pools(struct fsl_mc_device *mc_bus_dev)
{
int pool_type;
for (pool_type = 0; pool_type < FSL_MC_NUM_POOL_TYPES; pool_type++)
dprc_cleanup_resource_pool(mc_bus_dev, pool_type);
}
static void reorder_obj_desc_array(struct dprc_obj_desc *obj_desc_array,
int num_devs)
{
struct dprc_obj_desc tmp;
struct dprc_obj_desc *top_cursor = &obj_desc_array[0];
struct dprc_obj_desc *bottom_cursor = &obj_desc_array[num_devs - 1];
/*
* Reorder entries in obj_desc_array so that all allocatable devices
* are placed before all non-allocatable devices:
*
* Loop Invariant: everything before top_cursor is allocatable and
* everything after bottom_cursor is non-allocatable.
*/
while (top_cursor < bottom_cursor) {
if (FSL_MC_IS_ALLOCATABLE(top_cursor->type)) {
top_cursor++;
} else {
if (FSL_MC_IS_ALLOCATABLE(bottom_cursor->type)) {
tmp = *bottom_cursor;
*bottom_cursor = *top_cursor;
*top_cursor = tmp;
top_cursor++;
}
bottom_cursor--;
}
}
}
/**
* dprc_scan_objects - Discover objects in a DPRC
*
@ -164,6 +243,14 @@ static void dprc_add_new_devices(struct fsl_mc_device *mc_bus_dev,
* Detects objects added and removed from a DPRC and synchronizes the
* state of the Linux bus driver, MC by adding and removing
* devices accordingly.
* Two types of devices can be found in a DPRC: allocatable objects (e.g.,
* dpbp, dpmcp) and non-allocatable devices (e.g., dprc, dpni).
* All allocatable devices needed to be probed before all non-allocatable
* devices, to ensure that device drivers for non-allocatable
* devices can allocate any type of allocatable devices.
* That is, we need to ensure that the corresponding resource pools are
* populated before they can get allocation requests from probe callbacks
* of the device drivers for the non-allocatable devices.
*/
int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev)
{
@ -226,6 +313,8 @@ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev)
"%d out of %d devices could not be retrieved\n",
dprc_get_obj_failures, num_child_objects);
}
reorder_obj_desc_array(child_obj_desc_array, num_child_objects);
}
dprc_remove_devices(mc_bus_dev, child_obj_desc_array,
@ -255,12 +344,20 @@ int dprc_scan_container(struct fsl_mc_device *mc_bus_dev)
int error;
struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_bus_dev);
dprc_init_all_resource_pools(mc_bus_dev);
/*
* Discover objects in the DPRC:
*/
mutex_lock(&mc_bus->scan_mutex);
error = dprc_scan_objects(mc_bus_dev);
mutex_unlock(&mc_bus->scan_mutex);
if (error < 0)
goto error;
return 0;
error:
dprc_cleanup_all_resource_pools(mc_bus_dev);
return error;
}
EXPORT_SYMBOL_GPL(dprc_scan_container);
@ -272,6 +369,8 @@ EXPORT_SYMBOL_GPL(dprc_scan_container);
*
* It opens the physical DPRC in the MC.
* It scans the DPRC to discover the MC objects contained in it.
* It creates the interrupt pool for the MC bus associated with the DPRC.
* It configures the interrupts for the DPRC device itself.
*/
static int dprc_probe(struct fsl_mc_device *mc_dev)
{
@ -295,7 +394,7 @@ static int dprc_probe(struct fsl_mc_device *mc_dev)
error = fsl_create_mc_io(&mc_dev->dev,
mc_dev->regions[0].start,
region_size,
0, &mc_dev->mc_io);
NULL, 0, &mc_dev->mc_io);
if (error < 0)
return error;
}
@ -334,6 +433,8 @@ error_cleanup_mc_io:
*
* It removes the DPRC's child objects from Linux (not from the MC) and
* closes the DPRC device in the MC.
* It tears down the interrupts that were configured for the DPRC device.
* It destroys the interrupt pool associated with this MC bus.
*/
static int dprc_remove(struct fsl_mc_device *mc_dev)
{
@ -345,6 +446,7 @@ static int dprc_remove(struct fsl_mc_device *mc_dev)
return -EINVAL;
device_for_each_child(&mc_dev->dev, NULL, __fsl_mc_device_remove);
dprc_cleanup_all_resource_pools(mc_dev);
error = dprc_close(mc_dev->mc_io, mc_dev->mc_handle);
if (error < 0)
dev_err(&mc_dev->dev, "dprc_close() failed: %d\n", error);

569
drivers/staging/fsl-mc/bus/mc-allocator.c Normal file
View File

@ -0,0 +1,569 @@
/*
* Freescale MC object device allocator driver
*
* Copyright (C) 2013 Freescale Semiconductor, Inc.
*
* This file is licensed under the terms of the GNU General Public
* License version 2. This program is licensed "as is" without any
* warranty of any kind, whether express or implied.
*/
#include "../include/mc-private.h"
#include "../include/mc-sys.h"
#include <linux/module.h>
#include "../include/dpbp-cmd.h"
#include "../include/dpcon-cmd.h"
#include "dpmcp-cmd.h"
#include "dpmcp.h"
/**
* fsl_mc_resource_pool_add_device - add allocatable device to a resource
* pool of a given MC bus
*
* @mc_bus: pointer to the MC bus
* @pool_type: MC bus pool type
* @mc_dev: Pointer to allocatable MC object device
*
* It adds an allocatable MC object device to a container's resource pool of
* the given resource type
*/
static int __must_check fsl_mc_resource_pool_add_device(struct fsl_mc_bus
*mc_bus,
enum fsl_mc_pool_type
pool_type,
struct fsl_mc_device
*mc_dev)
{
struct fsl_mc_resource_pool *res_pool;
struct fsl_mc_resource *resource;
struct fsl_mc_device *mc_bus_dev = &mc_bus->mc_dev;
int error = -EINVAL;
bool mutex_locked = false;
if (WARN_ON(pool_type < 0 || pool_type >= FSL_MC_NUM_POOL_TYPES))
goto out;
if (WARN_ON(!FSL_MC_IS_ALLOCATABLE(mc_dev->obj_desc.type)))
goto out;
if (WARN_ON(mc_dev->resource))
goto out;
res_pool = &mc_bus->resource_pools[pool_type];
if (WARN_ON(res_pool->type != pool_type))
goto out;
if (WARN_ON(res_pool->mc_bus != mc_bus))
goto out;
mutex_lock(&res_pool->mutex);
mutex_locked = true;
if (WARN_ON(res_pool->max_count < 0))
goto out;
if (WARN_ON(res_pool->free_count < 0 ||
res_pool->free_count > res_pool->max_count))
goto out;
resource = devm_kzalloc(&mc_bus_dev->dev, sizeof(*resource),
GFP_KERNEL);
if (!resource) {
error = -ENOMEM;
dev_err(&mc_bus_dev->dev,
"Failed to allocate memory for fsl_mc_resource\n");
goto out;
}
resource->type = pool_type;
resource->id = mc_dev->obj_desc.id;
resource->data = mc_dev;
resource->parent_pool = res_pool;
INIT_LIST_HEAD(&resource->node);
list_add_tail(&resource->node, &res_pool->free_list);
mc_dev->resource = resource;
res_pool->free_count++;
res_pool->max_count++;
error = 0;
out:
if (mutex_locked)
mutex_unlock(&res_pool->mutex);
return error;
}
/**
* fsl_mc_resource_pool_remove_device - remove an allocatable device from a
* resource pool
*
* @mc_dev: Pointer to allocatable MC object device
*
* It permanently removes an allocatable MC object device from the resource
* pool, the device is currently in, as long as it is in the pool's free list.
*/
static int __must_check fsl_mc_resource_pool_remove_device(struct fsl_mc_device
*mc_dev)
{
struct fsl_mc_device *mc_bus_dev;
struct fsl_mc_bus *mc_bus;
struct fsl_mc_resource_pool *res_pool;
struct fsl_mc_resource *resource;
int error = -EINVAL;
bool mutex_locked = false;
if (WARN_ON(!FSL_MC_IS_ALLOCATABLE(mc_dev->obj_desc.type)))
goto out;
resource = mc_dev->resource;
if (WARN_ON(resource->data != mc_dev))
goto out;
mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
mc_bus = to_fsl_mc_bus(mc_bus_dev);
res_pool = resource->parent_pool;
if (WARN_ON(res_pool != &mc_bus->resource_pools[resource->type]))
goto out;
mutex_lock(&res_pool->mutex);
mutex_locked = true;
if (WARN_ON(res_pool->max_count <= 0))
goto out;
if (WARN_ON(res_pool->free_count <= 0 ||
res_pool->free_count > res_pool->max_count))
goto out;
/*
* If the device is currently allocated, its resource is not
* in the free list and thus, the device cannot be removed.
*/
if (list_empty(&resource->node)) {
error = -EBUSY;
dev_err(&mc_bus_dev->dev,
"Device %s cannot be removed from resource pool\n",
dev_name(&mc_dev->dev));
goto out;
}
list_del(&resource->node);
INIT_LIST_HEAD(&resource->node);
res_pool->free_count--;
res_pool->max_count--;
devm_kfree(&mc_bus_dev->dev, resource);
mc_dev->resource = NULL;
error = 0;
out:
if (mutex_locked)
mutex_unlock(&res_pool->mutex);
return error;
}
static const char *const fsl_mc_pool_type_strings[] = {
[FSL_MC_POOL_DPMCP] = "dpmcp",
[FSL_MC_POOL_DPBP] = "dpbp",
[FSL_MC_POOL_DPCON] = "dpcon",
};
static int __must_check object_type_to_pool_type(const char *object_type,
enum fsl_mc_pool_type
*pool_type)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(fsl_mc_pool_type_strings); i++) {
if (strcmp(object_type, fsl_mc_pool_type_strings[i]) == 0) {
*pool_type = i;
return 0;
}
}
return -EINVAL;
}
int __must_check fsl_mc_resource_allocate(struct fsl_mc_bus *mc_bus,
enum fsl_mc_pool_type pool_type,
struct fsl_mc_resource **new_resource)
{
struct fsl_mc_resource_pool *res_pool;
struct fsl_mc_resource *resource;
struct fsl_mc_device *mc_bus_dev = &mc_bus->mc_dev;
int error = -EINVAL;
bool mutex_locked = false;
BUILD_BUG_ON(ARRAY_SIZE(fsl_mc_pool_type_strings) !=
FSL_MC_NUM_POOL_TYPES);
*new_resource = NULL;
if (WARN_ON(pool_type < 0 || pool_type >= FSL_MC_NUM_POOL_TYPES))
goto error;
res_pool = &mc_bus->resource_pools[pool_type];
if (WARN_ON(res_pool->mc_bus != mc_bus))
goto error;
mutex_lock(&res_pool->mutex);
mutex_locked = true;
resource = list_first_entry_or_null(&res_pool->free_list,
struct fsl_mc_resource, node);
if (!resource) {
WARN_ON(res_pool->free_count != 0);
error = -ENXIO;
dev_err(&mc_bus_dev->dev,
"No more resources of type %s left\n",
fsl_mc_pool_type_strings[pool_type]);
goto error;
}
if (WARN_ON(resource->type != pool_type))
goto error;
if (WARN_ON(resource->parent_pool != res_pool))
goto error;
if (WARN_ON(res_pool->free_count <= 0 ||
res_pool->free_count > res_pool->max_count))
goto error;
list_del(&resource->node);
INIT_LIST_HEAD(&resource->node);
res_pool->free_count--;
mutex_unlock(&res_pool->mutex);
*new_resource = resource;
return 0;
error:
if (mutex_locked)
mutex_unlock(&res_pool->mutex);
return error;
}
EXPORT_SYMBOL_GPL(fsl_mc_resource_allocate);
void fsl_mc_resource_free(struct fsl_mc_resource *resource)
{
struct fsl_mc_resource_pool *res_pool;
bool mutex_locked = false;
res_pool = resource->parent_pool;
if (WARN_ON(resource->type != res_pool->type))
goto out;
mutex_lock(&res_pool->mutex);
mutex_locked = true;
if (WARN_ON(res_pool->free_count < 0 ||
res_pool->free_count >= res_pool->max_count))
goto out;
if (WARN_ON(!list_empty(&resource->node)))
goto out;
list_add_tail(&resource->node, &res_pool->free_list);
res_pool->free_count++;
out:
if (mutex_locked)
mutex_unlock(&res_pool->mutex);
}
EXPORT_SYMBOL_GPL(fsl_mc_resource_free);
/**
* fsl_mc_portal_allocate - Allocates an MC portal
*
* @mc_dev: MC device for which the MC portal is to be allocated
* @mc_io_flags: Flags for the fsl_mc_io object that wraps the allocated
* MC portal.
* @new_mc_io: Pointer to area where the pointer to the fsl_mc_io object
* that wraps the allocated MC portal is to be returned
*
* This function allocates an MC portal from the device's parent DPRC,
* from the corresponding MC bus' pool of MC portals and wraps
* it in a new fsl_mc_io object. If 'mc_dev' is a DPRC itself, the
* portal is allocated from its own MC bus.
*/
int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
uint16_t mc_io_flags,
struct fsl_mc_io **new_mc_io)
{
struct fsl_mc_device *mc_bus_dev;
struct fsl_mc_bus *mc_bus;
phys_addr_t mc_portal_phys_addr;
size_t mc_portal_size;
struct fsl_mc_device *mc_adev;
int error = -EINVAL;
struct fsl_mc_resource *resource = NULL;
struct fsl_mc_io *mc_io = NULL;
if (mc_dev->flags & FSL_MC_IS_DPRC) {
mc_bus_dev = mc_dev;
} else {
if (WARN_ON(mc_dev->dev.parent->bus != &fsl_mc_bus_type))
return error;
mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
}
mc_bus = to_fsl_mc_bus(mc_bus_dev);
*new_mc_io = NULL;
error = fsl_mc_resource_allocate(mc_bus, FSL_MC_POOL_DPMCP, &resource);
if (error < 0)
return error;
mc_adev = resource->data;
if (WARN_ON(!mc_adev))
goto error_cleanup_resource;
if (WARN_ON(mc_adev->obj_desc.region_count == 0))
goto error_cleanup_resource;
mc_portal_phys_addr = mc_adev->regions[0].start;
mc_portal_size = mc_adev->regions[0].end -
mc_adev->regions[0].start + 1;
if (WARN_ON(mc_portal_size != mc_bus_dev->mc_io->portal_size))
goto error_cleanup_resource;
error = fsl_create_mc_io(&mc_bus_dev->dev,
mc_portal_phys_addr,
mc_portal_size, resource,
mc_io_flags, &mc_io);
if (error < 0)
goto error_cleanup_resource;
*new_mc_io = mc_io;
return 0;
error_cleanup_resource:
fsl_mc_resource_free(resource);
return error;
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_allocate);
/**
* fsl_mc_portal_free - Returns an MC portal to the pool of free MC portals
* of a given MC bus
*
* @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
*/
void fsl_mc_portal_free(struct fsl_mc_io *mc_io)
{
struct fsl_mc_resource *resource;
resource = mc_io->resource;
if (WARN_ON(resource->type != FSL_MC_POOL_DPMCP))
return;
if (WARN_ON(!resource->data))
return;
fsl_destroy_mc_io(mc_io);
fsl_mc_resource_free(resource);
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_free);
/**
* fsl_mc_portal_reset - Resets the dpmcp object for a given fsl_mc_io object
*
* @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
*/
int fsl_mc_portal_reset(struct fsl_mc_io *mc_io)
{
int error;
uint16_t token;
struct fsl_mc_resource *resource = mc_io->resource;
struct fsl_mc_device *mc_dev = resource->data;
if (WARN_ON(resource->type != FSL_MC_POOL_DPMCP))
return -EINVAL;
if (WARN_ON(!mc_dev))
return -EINVAL;
error = dpmcp_open(mc_io, mc_dev->obj_desc.id, &token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_open() failed: %d\n", error);
return error;
}
error = dpmcp_reset(mc_io, token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_reset() failed: %d\n", error);
return error;
}
error = dpmcp_close(mc_io, token);
if (error < 0) {
dev_err(&mc_dev->dev, "dpmcp_close() failed: %d\n", error);
return error;
}
return 0;
}
EXPORT_SYMBOL_GPL(fsl_mc_portal_reset);
/**
* fsl_mc_object_allocate - Allocates a MC object device of the given
* pool type from a given MC bus
*
* @mc_dev: MC device for which the MC object device is to be allocated
* @pool_type: MC bus resource pool type
* @new_mc_dev: Pointer to area where the pointer to the allocated
* MC object device is to be returned
*
* This function allocates a MC object device from the device's parent DPRC,
* from the corresponding MC bus' pool of allocatable MC object devices of
* the given resource type. mc_dev cannot be a DPRC itself.
*
* NOTE: pool_type must be different from FSL_MC_POOL_MCP, since MC
* portals are allocated using fsl_mc_portal_allocate(), instead of
* this function.
*/
int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
enum fsl_mc_pool_type pool_type,
struct fsl_mc_device **new_mc_adev)
{
struct fsl_mc_device *mc_bus_dev;
struct fsl_mc_bus *mc_bus;
struct fsl_mc_device *mc_adev;
int error = -EINVAL;
struct fsl_mc_resource *resource = NULL;
*new_mc_adev = NULL;
if (WARN_ON(mc_dev->flags & FSL_MC_IS_DPRC))
goto error;
if (WARN_ON(mc_dev->dev.parent->bus != &fsl_mc_bus_type))
goto error;
if (WARN_ON(pool_type == FSL_MC_POOL_DPMCP))
goto error;
mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
mc_bus = to_fsl_mc_bus(mc_bus_dev);
error = fsl_mc_resource_allocate(mc_bus, pool_type, &resource);
if (error < 0)
goto error;
mc_adev = resource->data;
if (WARN_ON(!mc_adev))
goto error;
*new_mc_adev = mc_adev;
return 0;
error:
if (resource)
fsl_mc_resource_free(resource);
return error;
}
EXPORT_SYMBOL_GPL(fsl_mc_object_allocate);
/**
* fsl_mc_object_free - Returns an allocatable MC object device to the
* corresponding resource pool of a given MC bus.
*
* @mc_adev: Pointer to the MC object device
*/
void fsl_mc_object_free(struct fsl_mc_device *mc_adev)
{
struct fsl_mc_resource *resource;
resource = mc_adev->resource;
if (WARN_ON(resource->type == FSL_MC_POOL_DPMCP))
return;
if (WARN_ON(resource->data != mc_adev))
return;
fsl_mc_resource_free(resource);
}
EXPORT_SYMBOL_GPL(fsl_mc_object_free);
/**
* fsl_mc_allocator_probe - callback invoked when an allocatable device is
* being added to the system
*/
static int fsl_mc_allocator_probe(struct fsl_mc_device *mc_dev)
{
enum fsl_mc_pool_type pool_type;
struct fsl_mc_device *mc_bus_dev;
struct fsl_mc_bus *mc_bus;
int error = -EINVAL;
if (WARN_ON(!FSL_MC_IS_ALLOCATABLE(mc_dev->obj_desc.type)))
goto error;
mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
if (WARN_ON(mc_bus_dev->dev.bus != &fsl_mc_bus_type))
goto error;
mc_bus = to_fsl_mc_bus(mc_bus_dev);
error = object_type_to_pool_type(mc_dev->obj_desc.type, &pool_type);
if (error < 0)
goto error;
error = fsl_mc_resource_pool_add_device(mc_bus, pool_type, mc_dev);
if (error < 0)
goto error;
dev_info(&mc_dev->dev,
"Allocatable MC object device bound to fsl_mc_allocator driver");
return 0;
error:
return error;
}
/**
* fsl_mc_allocator_remove - callback invoked when an allocatable device is
* being removed from the system
*/
static int fsl_mc_allocator_remove(struct fsl_mc_device *mc_dev)
{
int error = -EINVAL;
if (WARN_ON(!FSL_MC_IS_ALLOCATABLE(mc_dev->obj_desc.type)))
goto out;
error = fsl_mc_resource_pool_remove_device(mc_dev);
if (error < 0)
goto out;
dev_info(&mc_dev->dev,
"Allocatable MC object device unbound from fsl_mc_allocator driver");
error = 0;
out:
return error;
}
static const struct fsl_mc_device_match_id match_id_table[] = {
{
.vendor = FSL_MC_VENDOR_FREESCALE,
.obj_type = "dpbp",
.ver_major = DPBP_VER_MAJOR,
.ver_minor = DPBP_VER_MINOR
},
{
.vendor = FSL_MC_VENDOR_FREESCALE,
.obj_type = "dpmcp",
.ver_major = DPMCP_VER_MAJOR,
.ver_minor = DPMCP_VER_MINOR
},
{
.vendor = FSL_MC_VENDOR_FREESCALE,
.obj_type = "dpcon",
.ver_major = DPCON_VER_MAJOR,
.ver_minor = DPCON_VER_MINOR
},
{.vendor = 0x0},
};
static struct fsl_mc_driver fsl_mc_allocator_driver = {
.driver = {
.name = "fsl_mc_allocator",
.owner = THIS_MODULE,
.pm = NULL,
},
.match_id_table = match_id_table,
.probe = fsl_mc_allocator_probe,
.remove = fsl_mc_allocator_remove,
};
module_fsl_mc_driver(fsl_mc_allocator_driver);
MODULE_AUTHOR("Freescale Semiconductor Inc.");
MODULE_DESCRIPTION("Freescale's MC object device allocator");
MODULE_LICENSE("GPL");

2
drivers/staging/fsl-mc/bus/mc-bus.c
View File

@ -604,7 +604,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev)
mc_portal_phys_addr = res.start;
mc_portal_size = resource_size(&res);
error = fsl_create_mc_io(&pdev->dev, mc_portal_phys_addr,
mc_portal_size, 0, &mc_io);
mc_portal_size, NULL, 0, &mc_io);
if (error < 0)
return error;

4
drivers/staging/fsl-mc/bus/mc-sys.c
View File

@ -60,6 +60,8 @@
* @dev: device to be associated with the MC I/O object
* @mc_portal_phys_addr: physical address of the MC portal to use
* @mc_portal_size: size in bytes of the MC portal
* @resource: Pointer to MC bus object allocator resource associated
* with this MC I/O object or NULL if none.
* @flags: flags for the new MC I/O object
* @new_mc_io: Area to return pointer to newly created MC I/O object
*
@ -68,6 +70,7 @@
int __must_check fsl_create_mc_io(struct device *dev,
phys_addr_t mc_portal_phys_addr,
uint32_t mc_portal_size,
struct fsl_mc_resource *resource,
uint32_t flags, struct fsl_mc_io **new_mc_io)
{
struct fsl_mc_io *mc_io;
@ -82,6 +85,7 @@ int __must_check fsl_create_mc_io(struct device *dev,
mc_io->flags = flags;
mc_io->portal_phys_addr = mc_portal_phys_addr;
mc_io->portal_size = mc_portal_size;
mc_io->resource = resource;
res = devm_request_mem_region(dev,
mc_portal_phys_addr,
mc_portal_size,

60
drivers/staging/fsl-mc/include/dpbp-cmd.h Normal file
View File

@ -0,0 +1,60 @@
/* Copyright 2013-2014 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.
*
*
* 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_DPBP_CMD_H
#define _FSL_DPBP_CMD_H
/* DPBP Version */
#define DPBP_VER_MAJOR 2
#define DPBP_VER_MINOR 0
/* Command IDs */
#define DPBP_CMDID_CLOSE 0x800
#define DPBP_CMDID_OPEN 0x804
#define DPBP_CMDID_CREATE 0x904
#define DPBP_CMDID_DESTROY 0x900
#define DPBP_CMDID_ENABLE 0x002
#define DPBP_CMDID_DISABLE 0x003
#define DPBP_CMDID_GET_ATTR 0x004
#define DPBP_CMDID_RESET 0x005
#define DPBP_CMDID_IS_ENABLED 0x006
#define DPBP_CMDID_SET_IRQ 0x010
#define DPBP_CMDID_GET_IRQ 0x011
#define DPBP_CMDID_SET_IRQ_ENABLE 0x012
#define DPBP_CMDID_GET_IRQ_ENABLE 0x013
#define DPBP_CMDID_SET_IRQ_MASK 0x014
#define DPBP_CMDID_GET_IRQ_MASK 0x015
#define DPBP_CMDID_GET_IRQ_STATUS 0x016
#define DPBP_CMDID_CLEAR_IRQ_STATUS 0x017
#endif /* _FSL_DPBP_CMD_H */

330
drivers/staging/fsl-mc/include/dpbp.h Normal file
View File

@ -0,0 +1,330 @@
/* 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.
*
*
* 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_DPBP_H
#define __FSL_DPBP_H
/* Data Path Buffer Pool API
* Contains initialization APIs and runtime control APIs for DPBP
*/
struct fsl_mc_io;
/**
* dpbp_open() - Open a control session for the specified object.
* @mc_io: Pointer to MC portal's I/O object
* @dpbp_id: DPBP unique ID
* @token: Returned token; use in subsequent API calls
*
* This function can be used to open a control session for an
* already created object; an object may have been declared in
* the DPL or by calling the dpbp_create function.
* This function returns a unique authentication token,
* associated with the specific object ID and the specific MC
* portal; this token must be used in all subsequent commands for
* this specific object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token);
/**
* dpbp_close() - Close the control session of the object
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
*
* After this function is called, no further operations are
* allowed on the object without opening a new control session.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token);
/**
* struct dpbp_cfg() - Structure representing DPBP configuration
* @options: place holder
*/
struct dpbp_cfg {
uint32_t options;
};
/**
* dpbp_create() - Create the DPBP object.
* @mc_io: Pointer to MC portal's I/O object
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
*
* Create the DPBP object, allocate required resources and
* perform required initialization.
*
* The object can be created either by declaring it in the
* DPL file, or by calling this function.
* This function returns a unique authentication token,
* associated with the specific object ID and the specific MC
* portal; this token must be used in all subsequent calls to
* this specific object. For objects that are created using the
* DPL file, call dpbp_open function to get an authentication
* token first.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_create(struct fsl_mc_io *mc_io,
const struct dpbp_cfg *cfg,
uint16_t *token);
/**
* dpbp_destroy() - Destroy the DPBP object and release all its resources.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
*
* Return: '0' on Success; error code otherwise.
*/
int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token);
/**
* dpbp_enable() - Enable the DPBP.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token);
/**
* dpbp_disable() - Disable the DPBP.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_disable(struct fsl_mc_io *mc_io, uint16_t token);
/**
* dpbp_is_enabled() - Check if the DPBP is enabled.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @en: Returns '1' if object is enabled; '0' otherwise
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en);
/**
* dpbp_reset() - Reset the DPBP, returns the object to initial state.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token);
/**
* dpbp_set_irq() - Set IRQ information for the DPBP to trigger an interrupt.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: Identifies the interrupt index to configure
* @irq_addr: Address that must be written to
* signal a message-based interrupt
* @irq_val: Value to write into irq_addr address
* @user_irq_id: A user defined number associated with this IRQ
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint64_t irq_addr,
uint32_t irq_val,
int user_irq_id);
/**
* dpbp_get_irq() - Get IRQ information from the DPBP.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @type: Interrupt type: 0 represents message interrupt
* type (both irq_addr and irq_val are valid)
* @irq_addr: Returned address that must be written to
* signal the message-based interrupt
* @irq_val: Value to write into irq_addr address
* @user_irq_id: A user defined number associated with this IRQ
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
int *type,
uint64_t *irq_addr,
uint32_t *irq_val,
int *user_irq_id);
/**
* dpbp_set_irq_enable() - Set overall interrupt state.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Interrupt state - enable = 1, disable = 0
*
* Allows GPP software to control when interrupts are generated.
* Each interrupt can have up to 32 causes. The enable/disable control's the
* overall interrupt state. if the interrupt is disabled no causes will cause
* an interrupt.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t en);
/**
* dpbp_get_irq_enable() - Get overall interrupt state
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @en: Returned interrupt state - enable = 1, disable = 0
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_enable(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint8_t *en);
/**
* dpbp_set_irq_mask() - Set interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Event mask to trigger interrupt;
* each bit:
* 0 = ignore event
* 1 = consider event for asserting IRQ
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_set_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t mask);
/**
* dpbp_get_irq_mask() - Get interrupt mask.
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @mask: Returned event mask to trigger interrupt
*
* Every interrupt can have up to 32 causes and the interrupt model supports
* masking/unmasking each cause independently
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_mask(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *mask);
/**
* dpbp_get_irq_status() - Get the current status of any pending interrupts.
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Returned interrupts status - one bit per cause:
* 0 = no interrupt pending
* 1 = interrupt pending
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t *status);
/**
* dpbp_clear_irq_status() - Clear a pending interrupt's status
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @irq_index: The interrupt index to configure
* @status: Bits to clear (W1C) - one bit per cause:
* 0 = don't change
* 1 = clear status bit
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_clear_irq_status(struct fsl_mc_io *mc_io,
uint16_t token,
uint8_t irq_index,
uint32_t status);
/**
* struct dpbp_attr - Structure representing DPBP attributes
* @id: DPBP object ID
* @version: DPBP version
* @bpid: Hardware buffer pool ID; should be used as an argument in
* acquire/release operations on buffers
*/
struct dpbp_attr {
int id;
/**
* struct version - Structure representing DPBP version
* @major: DPBP major version
* @minor: DPBP minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
uint16_t bpid;
};
/**
* dpbp_get_attributes - Retrieve DPBP attributes.
*
* @mc_io: Pointer to MC portal's I/O object
* @token: Token of DPBP object
* @attr: Returned object's attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpbp_attr *attr);
/** @} */
#endif /* __FSL_DPBP_H */

62
drivers/staging/fsl-mc/include/dpcon-cmd.h Normal file
View File

@ -0,0 +1,62 @@
/* 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.
*
*
* 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_DPCON_CMD_H
#define _FSL_DPCON_CMD_H
/* DPCON Version */
#define DPCON_VER_MAJOR 2
#define DPCON_VER_MINOR 0
/* Command IDs */
#define DPCON_CMDID_CLOSE 0x800
#define DPCON_CMDID_OPEN 0x808
#define DPCON_CMDID_CREATE 0x908
#define DPCON_CMDID_DESTROY 0x900
#define DPCON_CMDID_ENABLE 0x002
#define DPCON_CMDID_DISABLE 0x003
#define DPCON_CMDID_GET_ATTR 0x004
#define DPCON_CMDID_RESET 0x005
#define DPCON_CMDID_IS_ENABLED 0x006
#define DPCON_CMDID_SET_IRQ 0x010
#define DPCON_CMDID_GET_IRQ 0x011
#define DPCON_CMDID_SET_IRQ_ENABLE 0x012
#define DPCON_CMDID_GET_IRQ_ENABLE 0x013
#define DPCON_CMDID_SET_IRQ_MASK 0x014
#define DPCON_CMDID_GET_IRQ_MASK 0x015
#define DPCON_CMDID_GET_IRQ_STATUS 0x016
#define DPCON_CMDID_CLEAR_IRQ_STATUS 0x017
#define DPCON_CMDID_SET_NOTIFICATION 0x100
#endif /* _FSL_DPCON_CMD_H */

61
drivers/staging/fsl-mc/include/mc-private.h
View File

@ -21,6 +21,11 @@
(strcmp((_mc_dev)->obj_desc.type, (_obj_desc)->type) == 0 && \
(_mc_dev)->obj_desc.id == (_obj_desc)->id)
#define FSL_MC_IS_ALLOCATABLE(_obj_type) \
(strcmp(_obj_type, "dpbp") == 0 || \
strcmp(_obj_type, "dpmcp") == 0 || \
strcmp(_obj_type, "dpcon") == 0)
/**
* struct fsl_mc - Private data of a "fsl,qoriq-mc" platform device
* @root_mc_bus_dev: MC object device representing the root DPRC
@ -32,19 +37,6 @@ struct fsl_mc {
struct fsl_mc_addr_translation_range *translation_ranges;
};
/**
* struct fsl_mc_bus - logical bus that corresponds to a physical DPRC
* @mc_dev: fsl-mc device for the bus device itself.
* @scan_mutex: Serializes bus scanning
*/
struct fsl_mc_bus {
struct fsl_mc_device mc_dev;
struct mutex scan_mutex; /* serializes bus scanning */
};
#define to_fsl_mc_bus(_mc_dev) \
container_of(_mc_dev, struct fsl_mc_bus, mc_dev)
/**
* struct fsl_mc_addr_translation_range - bus to system address translation
* range
@ -59,6 +51,42 @@ struct fsl_mc_addr_translation_range {
phys_addr_t start_phys_addr;
};
/**
* struct fsl_mc_resource_pool - Pool of MC resources of a given
* type
* @type: type of resources in the pool
* @max_count: maximum number of resources in the pool
* @free_count: number of free resources in the pool
* @mutex: mutex to serialize access to the pool's free list
* @free_list: anchor node of list of free resources in the pool
* @mc_bus: pointer to the MC bus that owns this resource pool
*/
struct fsl_mc_resource_pool {
enum fsl_mc_pool_type type;
int16_t max_count;
int16_t free_count;
struct mutex mutex; /* serializes access to free_list */
struct list_head free_list;
struct fsl_mc_bus *mc_bus;
};
/**
* struct fsl_mc_bus - logical bus that corresponds to a physical DPRC
* @mc_dev: fsl-mc device for the bus device itself.
* @resource_pools: array of resource pools (one pool per resource type)
* for this MC bus. These resources represent allocatable entities
* from the physical DPRC.
* @scan_mutex: Serializes bus scanning
*/
struct fsl_mc_bus {
struct fsl_mc_device mc_dev;
struct fsl_mc_resource_pool resource_pools[FSL_MC_NUM_POOL_TYPES];
struct mutex scan_mutex; /* serializes bus scanning */
};
#define to_fsl_mc_bus(_mc_dev) \
container_of(_mc_dev, struct fsl_mc_bus, mc_dev)
int __must_check fsl_mc_device_add(struct dprc_obj_desc *obj_desc,
struct fsl_mc_io *mc_io,
struct device *parent_dev,
@ -74,4 +102,11 @@ int __init dprc_driver_init(void);
void __exit dprc_driver_exit(void);
int __must_check fsl_mc_resource_allocate(struct fsl_mc_bus *mc_bus,
enum fsl_mc_pool_type pool_type,
struct fsl_mc_resource
**new_resource);
void fsl_mc_resource_free(struct fsl_mc_resource *resource);
#endif /* _FSL_MC_PRIVATE_H_ */

6
drivers/staging/fsl-mc/include/mc-sys.h
View File

@ -40,6 +40,7 @@
#include <linux/io.h>
#include <linux/dma-mapping.h>
struct fsl_mc_resource;
struct mc_command;
/**
@ -49,6 +50,9 @@ struct mc_command;
* @portal_size: MC command portal size in bytes
* @portal_phys_addr: MC command portal physical address
* @portal_virt_addr: MC command portal virtual address
* @resource: generic resource associated with the MC portal if
* the MC portal came from a resource pool, or NULL if the MC portal
* is permanently bound to a device (e.g., a DPRC)
*/
struct fsl_mc_io {
struct device *dev;
@ -56,11 +60,13 @@ struct fsl_mc_io {
uint32_t portal_size;
phys_addr_t portal_phys_addr;
void __iomem *portal_virt_addr;
struct fsl_mc_resource *resource;
};
int __must_check fsl_create_mc_io(struct device *dev,
phys_addr_t mc_portal_phys_addr,
uint32_t mc_portal_size,
struct fsl_mc_resource *resource,
uint32_t flags, struct fsl_mc_io **new_mc_io);
void fsl_destroy_mc_io(struct fsl_mc_io *mc_io);

65
drivers/staging/fsl-mc/include/mc.h
View File

@ -65,6 +65,44 @@ struct fsl_mc_device_match_id {
uint32_t ver_minor;
};
/**
* enum fsl_mc_pool_type - Types of allocatable MC bus resources
*
* Entries in these enum are used as indices in the array of resource
* pools of an fsl_mc_bus object.
*/
enum fsl_mc_pool_type {
FSL_MC_POOL_DPMCP = 0x0, /* corresponds to "dpmcp" in the MC */
FSL_MC_POOL_DPBP, /* corresponds to "dpbp" in the MC */
FSL_MC_POOL_DPCON, /* corresponds to "dpcon" in the MC */
/*
* NOTE: New resource pool types must be added before this entry
*/
FSL_MC_NUM_POOL_TYPES
};
/**
* struct fsl_mc_resource - MC generic resource
* @type: type of resource
* @id: unique MC resource Id within the resources of the same type
* @data: pointer to resource-specific data if the resource is currently
* allocated, or NULL if the resource is not currently allocated.
* @parent_pool: pointer to the parent resource pool from which this
* resource is allocated from.
* @node: Node in the free list of the corresponding resource pool
*
* NOTE: This structure is to be embedded as a field of specific
* MC resource structures.
*/
struct fsl_mc_resource {
enum fsl_mc_pool_type type;
int32_t id;
void *data;
struct fsl_mc_resource_pool *parent_pool;
struct list_head node;
};
/**
* Bit masks for a MC object device (struct fsl_mc_device) flags
*/
@ -86,6 +124,7 @@ struct fsl_mc_device_match_id {
* NULL if none.
* @obj_desc: MC description of the DPAA device
* @regions: pointer to array of MMIO region entries
* @resource: generic resource associated with this MC object device, if any.
*
* Generic device object for MC object devices that are "attached" to a
* MC bus.
@ -95,6 +134,17 @@ struct fsl_mc_device_match_id {
* - The SMMU notifier callback gets invoked after device_add() has been
* called for an MC object device, but before the device-specific probe
* callback gets called.
* - DP_OBJ_DPRC objects are the only MC objects that have built-in MC
* portals. For all other MC objects, their device drivers are responsible for
* allocating MC portals for them by calling fsl_mc_portal_allocate().
* - Some types of MC objects (e.g., DP_OBJ_DPBP, DP_OBJ_DPCON) are
* treated as resources that can be allocated/deallocated from the
* corresponding resource pool in the object's parent DPRC, using the
* fsl_mc_object_allocate()/fsl_mc_object_free() functions. These MC objects
* are known as "allocatable" objects. For them, the corresponding
* fsl_mc_device's 'resource' points to the associated resource object.
* For MC objects that are not allocatable (e.g., DP_OBJ_DPRC, DP_OBJ_DPNI),
* 'resource' is NULL.
*/
struct fsl_mc_device {
struct device dev;
@ -105,6 +155,7 @@ struct fsl_mc_device {
struct fsl_mc_io *mc_io;
struct dprc_obj_desc obj_desc;
struct resource *regions;
struct fsl_mc_resource *resource;
};
#define to_fsl_mc_device(_dev) \
@ -131,6 +182,20 @@ int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver,
void fsl_mc_driver_unregister(struct fsl_mc_driver *driver);
int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
uint16_t mc_io_flags,
struct fsl_mc_io **new_mc_io);
void fsl_mc_portal_free(struct fsl_mc_io *mc_io);
int fsl_mc_portal_reset(struct fsl_mc_io *mc_io);
int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
enum fsl_mc_pool_type pool_type,
struct fsl_mc_device **new_mc_adev);
void fsl_mc_object_free(struct fsl_mc_device *mc_adev);
extern struct bus_type fsl_mc_bus_type;
#endif /* _FSL_MC_H_ */