Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752110AbbHSRVa (ORCPT ); Wed, 19 Aug 2015 13:21:30 -0400 Received: from mail-bn1bbn0108.outbound.protection.outlook.com ([157.56.111.108]:50542 "EHLO na01-bn1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751687AbbHSRV1 (ORCPT ); Wed, 19 Aug 2015 13:21:27 -0400 X-Greylist: delayed 956 seconds by postgrey-1.27 at vger.kernel.org; Wed, 19 Aug 2015 13:21:26 EDT Authentication-Results: spf=temperror (sender IP is 192.88.168.50) smtp.mailfrom=freescale.com; freescale.mail.onmicrosoft.com; dkim=none (message not signed) header.d=none; From: "J. German Rivera" To: , , , CC: , , , , , , , , , , "J. German Rivera" Subject: [PATCH] staging: fsl-mc: Upgraded MC flibs used in MC bus driver Date: Wed, 19 Aug 2015 11:52:40 -0500 Message-ID: <1440003160-28717-1-git-send-email-German.Rivera@freescale.com> X-Mailer: git-send-email 2.3.3 X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1;BN1BFFO11FD039;1:IMgkV17rFvsQWjQNBAaXBnjkZR+oI4bjD63043Ekb7fRlSqq5pGONKFO174q6eE5CbTMWimj7JF6FUSaSMjnE5rqgVi00oqWMWN8SgZ2TH6TBvrlYR4YLQC/2mRpTBhFoNhc0GUZADRbOG3fYtQw/8tSs22IVRLPnTK2IRJk7pPxXQU7jV+izGtJzaUerDyTbiYmD6IzTk/SweM2adK5RmxHysBwz+rR5GZCWT2u8nS6hrMpDjztcFhNCJwlBDepIaQ6M0cgFEoU4Jw9TOxGompgoG6nCeRbN9PXlX00RJqfkHwxeBTahU6f9hXC/JwssOsIrMpecntRrYnCf2wT9PnANnd2l2XgRfNgqvXaTurSLx57CxL/AzRE7hDKciYZ50ooqS10JGzHN7t6/WYOeg== X-Forefront-Antispam-Report: CIP:192.88.168.50;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10019020)(6009001)(2980300002)(3050300001)(45074003)(199003)(189002)(105606002)(5890100001)(50986999)(36756003)(189998001)(5001860100001)(5001920100001)(87936001)(5001830100001)(104016003)(5001960100002)(47776003)(68736005)(97736004)(229853001)(106466001)(64706001)(77096005)(46102003)(92566002)(48376002)(86362001)(4001540100001)(50466002)(107886002)(19580405001)(5001770100001)(81156007)(2201001)(62966003)(50226001)(6806004)(5003940100001)(77156002)(19580395003)(2004002)(4001430100001)(569005);DIR:OUT;SFP:1102;SCL:1;SRVR:BLUPR03MB501;H:tx30smr01.am.freescale.net;FPR:;SPF:TempError;PTR:InfoDomainNonexistent;A:1;MX:1;LANG:en; MIME-Version: 1.0 Content-Type: text/plain X-Microsoft-Exchange-Diagnostics: 1;BLUPR03MB501;2:DJUsPI416Ab/uHGq4r5SZuinlzSLmsYSubcWgaKYBn+cytMBBTdVk0N/+dEyD+hR4s9FGGyXC8FXsfUFitFn+GYBeyIoxqamzxva98YjecHxAYSJZPT4H41YvfBNCzMwWojek5OfMQtJ1RdjPTKeiGCOfF3r3PhuE+vr8fXvcOQ=;3:O+sfto64lS4rGUOGwq1bcuKvJwVp9J9Tu59BD8gIFxrIlbOnI6Fqv7uKdz16ANsyUqRr2aIdPSees+UQ1LY0ArARxTAApTYKZffNp9zcKVBHger955Wn/JKg2cOJl5kBhShNfC62d/+ljeOJ5YmDs7kjAk6wEBpz83FIwq3Zp/FdMCfkQHUjSmVdvNKFkaDKdJtLpvYG4/HmvkKhNmSNaZRwUYP8fuS+7XjGPa0ocMg=;25:NGduw8vfwupgCJynB0JwNapO4p4rPUJk0sKdw7Lx1xLGgCQP+9oHlmzFN+bbkDHUxQDgVT5Ue7pkw2z8Gzs4J/dOQHM3/af8id72UPksjuIr9Y7guOXR/HG0nrtGs+yn8IGDzeaCtlssyidjGyIqMLxTnYDwzxFcYE3EMJ1F+hACLA9tWONyquVR3OISV0wtpV9bk/tePvXePWU5sy9LollSqxrIB9f1nl7F4VO2/8jFm0DzugPT5F+w5CkZgG/c X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB501; X-Microsoft-Exchange-Diagnostics: 1;BLUPR03MB501;20:L8YrpsjEgXvRufgxIANlCX1/dYKfzWnRBiPdLbDVhVOqnq7ZsA1iMbprsBq3J5IMayOr1bVsBhB8nvM7CI//tSjEfJz/EGG5bU2WvI7Mps4tBfZNl9BEY8qwHHdE/8KkcNJkQSnYE4ROI20+bPxSmkme9yCUebHIKl4vNuDlpRu7m14h2FzETwIIUM3ATALGYFbaEKEJflCLlScGSRwM+MKIw7FG3mPVRzAYm8cU3k7jXBdXiPPsYWfDYxDJzFAFiDWNBCMBbX/F+i36IyRdReyJxWKl46f6MDd8lZwbGlWz/ha+6LEPouoBUIdlwLfwqpyLAY8s2WIv9G42/PHhYPfE4UDI0Bx6I37PFGkyQy8=;4:K590xvOyQZFEXKg4vG3hnaMrcYwFDN1PFBEGoHfQ0TopGYw9v2uBk2Twj6XIkvqnHebgWOdLq3kN5mVNbjuORGhSSc4iVxms8k5WMzzX7Cy3aAn89TZw+C4wpADLgcvzVZNnOdVEZNtJesC0CYsohzYgA7ptzgHImeSOqH3dO+nvv9uzf5V1JuqVLZW9jrTbjB1Tj7QBxzhCKmY4QTP4mqgIH/LwzvXAF2eTGbMUi2iphSjSBjA1uQoM5vw5J+neuZzkvFeDmfuUOcLWec1bwy0oyk45q+CqMmqQFEYfX9S9oEuCZWYWrYPDcr/tQu1i X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(8121501046)(5005006)(3002001);SRVR:BLUPR03MB501;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB501; X-Forefront-PRVS: 0673F5BE31 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;BLUPR03MB501;23:/C3TANmT8HwAGHYRkIFNnToSken4eFGhFNceCbg/Xr?= =?us-ascii?Q?+HcUV8QO5y/KTAwGGrgTAHsWdKnWw2rh6QwSg8d4DN1y4Pua4QNJjQcZmIYL?= =?us-ascii?Q?8ZctdT7Js2wAYGZiHFVjf/SAf84vfkBI6uONaoGh7wfejB9pEVtkduUxhmy0?= =?us-ascii?Q?CY81j6CKsE00wl6LmNKRZSpXBOHFJK3mBU45L/Yv9jjVrZtMJa5UL09MK0eD?= =?us-ascii?Q?OU7pDTsstI2glbm36B3FD9HRHwWLEoH1oV/nWaHxWJ9ttrraqedqQ/e+WvUB?= =?us-ascii?Q?KMLkSlA45G8adfg3l0SkvzJKV+LuoY2hSw5DVfQVyoDG7JoBqUoGiYiFbpaL?= =?us-ascii?Q?6Qjz8s7qEWAosPbTRSpyTzAYnIF0g4bxaqX49MBoS4AAFDWp3duQdmchpZrl?= =?us-ascii?Q?8WoKigzUv+0Ly4qpSrfcch/DhMipewjyy66h+l0Ph/OYvfcSKGv83mOjH85j?= =?us-ascii?Q?SCs4a0fCABET5EpvEwU6fp7sU31Nk19xk3fLT1nFe4ML1HfDg2urrBhvShDz?= =?us-ascii?Q?hkoX+kDE4VqH0rJK0YQqEbQcDTfJxZ7Uzn4DeCOBR6iGyT1Q4dNJH0MKSTF3?= =?us-ascii?Q?loE2dOJyQsfw0jhByGDlO55wpiV8JiFm7pAfOF4uTMipFj9NhMtnGup6R2Lt?= =?us-ascii?Q?ee9SNFETJag2ERTdan31w/0DmRkiG1ABwAoLdeUmw768dOV+bYLJhNkENscJ?= =?us-ascii?Q?7y1fUY1cKyDC7/727s3y2ty+QmT1vaNU1Ok10Wx53KybdD47N0Obe+bcc+an?= =?us-ascii?Q?LI9mrS8XFmIfCF+Kkci0wVuO+Rl8XuWIgl2QDxbHcOZCq29h2pWfniK6Fk5p?= =?us-ascii?Q?KygfZl2aBZWhqMRx+oC+Nh+yKDXr2ve7HyOc7jVTUjoufCJxYHiEeObTaNT7?= =?us-ascii?Q?sObjcNccJQ3NPwrzeFm8dpD29rkriAv9/54GmSWegacCVF4qBJBmOVyn94IG?= =?us-ascii?Q?Kg7UHg7LEnFr2H2VgicgtsPeDpn+xDCCIZVWKDeNSKVnJX9Sh3LWzVEp0dyS?= =?us-ascii?Q?0oJtWsfq1rmBkWm54tIEVNZP+OTbAGrNHtGeBH1psYhhrA9CREJuKj+ZB7XF?= =?us-ascii?Q?MZ7cZ0HbOGfTBLo6lChM9IYIY2UsTxV/P8/Nn8hkNCCLPs9OuDVMaYn7aw0a?= =?us-ascii?Q?/zrqzKlWp9nbb6Dvl9Mtsjk94/Cap7HoNOAg06JfZ7NKFa/NlGJcrJjq7U7a?= =?us-ascii?Q?FYa9XkHboXnT07IlY7eyOCaPlfvw5dPCnH?= X-Microsoft-Exchange-Diagnostics: 1;BLUPR03MB501;5:FK1uML929CJTLJy9sgovZQjmridWg4suqzPqRQi962LdjRt9NEaWSDiduTcZBKBqlo31zJbwh7eCXjG9pBkzyJdFobLQ3Ac/syM0fitfHjG07iDSg9U2OzE013AHKQRrAWD5PPJIfEot0d4YP/nK8g==;24:Duwx1mKE6yfZan6WA9BGprmsrjQzUgguVm/QMLsZe26iUfdq2dtvLqBX5UKDxnNm0CDi9AeudDv2Guqu9jIdtOgFlKJmRFKZyEt2zgCHLuU=;20:W7pn7db65xgSE0+ATB9JYQe7s6fhARAhTGySNz3/K/ZbQl58pcqkj1bOuwCy4/b2wQL6V4wRwhtdga7bRrAaUQ== X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Aug 2015 17:05:15.4878 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d;Ip=[192.88.168.50];Helo=[tx30smr01.am.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR03MB501 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 158668 Lines: 4695 Since signatures of flib functions have changed, we had to change all the corresponding calls in the MC bus driver Signed-off-by: J. German Rivera --- drivers/staging/fsl-mc/bus/dpbp.c | 232 ++++++++------ drivers/staging/fsl-mc/bus/dpmcp-cmd.h | 81 +---- drivers/staging/fsl-mc/bus/dpmcp.c | 123 +++++--- drivers/staging/fsl-mc/bus/dpmcp.h | 123 +++++--- drivers/staging/fsl-mc/bus/dpmng.c | 14 +- drivers/staging/fsl-mc/bus/dprc-cmd.h | 7 +- drivers/staging/fsl-mc/bus/dprc-driver.c | 61 +++- drivers/staging/fsl-mc/bus/dprc.c | 464 +++++++++++++++++++++++----- drivers/staging/fsl-mc/bus/mc-allocator.c | 122 ++++---- drivers/staging/fsl-mc/bus/mc-bus.c | 72 +++-- drivers/staging/fsl-mc/bus/mc-sys.c | 188 +++++++++-- drivers/staging/fsl-mc/include/dpbp-cmd.h | 147 +++++++-- drivers/staging/fsl-mc/include/dpbp.h | 91 ++++-- drivers/staging/fsl-mc/include/dpcon-cmd.h | 159 ++++++++-- drivers/staging/fsl-mc/include/dpmng.h | 14 +- drivers/staging/fsl-mc/include/dprc.h | 313 +++++++++++++++---- drivers/staging/fsl-mc/include/mc-cmd.h | 28 +- drivers/staging/fsl-mc/include/mc-private.h | 17 +- drivers/staging/fsl-mc/include/mc-sys.h | 51 ++- 19 files changed, 1661 insertions(+), 646 deletions(-) diff --git a/drivers/staging/fsl-mc/bus/dpbp.c b/drivers/staging/fsl-mc/bus/dpbp.c index d99ab6d..6857a67 100644 --- a/drivers/staging/fsl-mc/bus/dpbp.c +++ b/drivers/staging/fsl-mc/bus/dpbp.c @@ -1,48 +1,52 @@ -/* 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. -*/ +/* 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 "../include/dpbp.h" #include "../include/dpbp-cmd.h" -int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token) +int dpbp_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + 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); + cmd_flags, + 0); + DPBP_CMD_OPEN(cmd, dpbp_id); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -54,22 +58,23 @@ int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token) return err; } -EXPORT_SYMBOL(dpbp_open); -int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token) +int dpbp_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ - cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, MC_CMD_PRI_HIGH, + cmd.header = mc_encode_cmd_header(DPBP_CMDID_CLOSE, cmd_flags, 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, + uint32_t cmd_flags, const struct dpbp_cfg *cfg, uint16_t *token) { @@ -80,7 +85,8 @@ int dpbp_create(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE, - MC_CMD_PRI_LOW, 0); + cmd_flags, + 0); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -93,50 +99,59 @@ int dpbp_create(struct fsl_mc_io *mc_io, return 0; } -int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token) +int dpbp_destroy(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } -int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token) +int dpbp_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ - cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, MC_CMD_PRI_LOW, + cmd.header = mc_encode_cmd_header(DPBP_CMDID_ENABLE, cmd_flags, 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) +int dpbp_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_DISABLE, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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) +int dpbp_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + 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, + cmd.header = mc_encode_cmd_header(DPBP_CMDID_IS_ENABLED, cmd_flags, token); /* send command to mc*/ @@ -145,59 +160,61 @@ int dpbp_is_enabled(struct fsl_mc_io *mc_io, uint16_t token, int *en) return err; /* retrieve response parameters */ - *en = (int)mc_dec(cmd.params[0], 0, 1); + DPBP_RSP_IS_ENABLED(cmd, *en); return 0; } -int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token) +int dpbp_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_RESET, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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) +int dpbp_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + uint8_t irq_index, + struct dpbp_irq_cfg *irq_cfg) { 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); + cmd_flags, + token); + + DPBP_CMD_SET_IRQ(cmd, irq_index, irq_cfg); /* 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) +int dpbp_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + uint8_t irq_index, + int *type, + struct dpbp_irq_cfg *irq_cfg) { 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); + cmd_flags, + token); + + DPBP_CMD_GET_IRQ(cmd, irq_index); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -205,14 +222,13 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io, 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); + DPBP_RSP_GET_IRQ(cmd, *type, irq_cfg); + return 0; } int dpbp_set_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t en) @@ -221,15 +237,17 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_SET_IRQ_ENABLE(cmd, irq_index, en); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t *en) @@ -239,8 +257,10 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_GET_IRQ_ENABLE(cmd, irq_index); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -248,11 +268,13 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, return err; /* retrieve response parameters */ - *en = (uint8_t)mc_dec(cmd.params[0], 0, 8); + DPBP_RSP_GET_IRQ_ENABLE(cmd, *en); + return 0; } int dpbp_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t mask) @@ -261,15 +283,17 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_SET_IRQ_MASK(cmd, irq_index, mask); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *mask) @@ -279,8 +303,10 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_GET_IRQ_MASK(cmd, irq_index); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -288,11 +314,13 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, return err; /* retrieve response parameters */ - *mask = (uint32_t)mc_dec(cmd.params[0], 0, 32); + DPBP_RSP_GET_IRQ_MASK(cmd, *mask); + return 0; } int dpbp_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *status) @@ -302,8 +330,10 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_GET_IRQ_STATUS(cmd, irq_index); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -311,11 +341,13 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io, return err; /* retrieve response parameters */ - *status = (uint32_t)mc_dec(cmd.params[0], 0, 32); + DPBP_RSP_GET_IRQ_STATUS(cmd, *status); + return 0; } int dpbp_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t status) @@ -324,15 +356,17 @@ int dpbp_clear_irq_status(struct fsl_mc_io *mc_io, /* 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); + cmd_flags, + token); + + DPBP_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } int dpbp_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, struct dpbp_attr *attr) { @@ -341,7 +375,8 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_ATTR, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -349,10 +384,7 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io, 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); + DPBP_RSP_GET_ATTRIBUTES(cmd, attr); + return 0; } -EXPORT_SYMBOL(dpbp_get_attributes); diff --git a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h index 57f326b..a87e9f8 100644 --- a/drivers/staging/fsl-mc/bus/dpmcp-cmd.h +++ b/drivers/staging/fsl-mc/bus/dpmcp-cmd.h @@ -34,7 +34,7 @@ /* DPMCP Version */ #define DPMCP_VER_MAJOR 2 -#define DPMCP_VER_MINOR 0 +#define DPMCP_VER_MINOR 1 /* Command IDs */ #define DPMCP_CMDID_CLOSE 0x800 @@ -54,83 +54,4 @@ #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 */ diff --git a/drivers/staging/fsl-mc/bus/dpmcp.c b/drivers/staging/fsl-mc/bus/dpmcp.c index 6b9da5b..ee63380 100644 --- a/drivers/staging/fsl-mc/bus/dpmcp.c +++ b/drivers/staging/fsl-mc/bus/dpmcp.c @@ -34,14 +34,18 @@ #include "dpmcp.h" #include "dpmcp-cmd.h" -int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token) +int dpmcp_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + 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_flags, + 0); cmd.params[0] |= mc_enc(0, 32, dpmcp_id); /* send command to mc*/ @@ -55,12 +59,15 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token) return err; } -int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token) +int dpmcp_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ - cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE, MC_CMD_PRI_HIGH, + cmd.header = mc_encode_cmd_header(DPMCP_CMDID_CLOSE, + cmd_flags, token); /* send command to mc*/ @@ -68,15 +75,17 @@ int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token) } int dpmcp_create(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, const struct dpmcp_cfg *cfg, - uint16_t *token) + 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_flags, + 0); cmd.params[0] |= mc_enc(0, 32, cfg->portal_id); /* send command to mc*/ @@ -90,65 +99,71 @@ int dpmcp_create(struct fsl_mc_io *mc_io, return 0; } -int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token) +int dpmcp_destroy(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPMCP_CMDID_DESTROY, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } -int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token) +int dpmcp_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPMCP_CMDID_RESET, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } int dpmcp_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint64_t irq_addr, - uint32_t irq_val, - int user_irq_id) + uint8_t irq_index, + struct dpmcp_irq_cfg *irq_cfg) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPMCP_CMDID_SET_IRQ, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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); + cmd.params[0] |= mc_enc(32, 32, irq_cfg->val); + cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr); + cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } int dpmcp_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - int *type, - uint64_t *irq_addr, - uint32_t *irq_val, - int *user_irq_id) + uint8_t irq_index, + int *type, + struct dpmcp_irq_cfg *irq_cfg) { 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_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -157,23 +172,25 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io, 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); + irq_cfg->val = (uint32_t)mc_dec(cmd.params[0], 0, 32); + irq_cfg->paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64); + irq_cfg->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, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint8_t en) + 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_flags, + token); cmd.params[0] |= mc_enc(0, 8, en); cmd.params[0] |= mc_enc(32, 8, irq_index); @@ -182,16 +199,18 @@ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io, } int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint8_t *en) + 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_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -205,15 +224,17 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io, } int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t mask) + 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_flags, + token); cmd.params[0] |= mc_enc(0, 32, mask); cmd.params[0] |= mc_enc(32, 8, irq_index); @@ -222,16 +243,18 @@ int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io, } int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t *mask) + 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_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -245,16 +268,18 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io, } int dpmcp_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t *status) + 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_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -268,15 +293,17 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io, } int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t status) + 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_flags, + token); cmd.params[0] |= mc_enc(0, 32, status); cmd.params[0] |= mc_enc(32, 8, irq_index); @@ -285,15 +312,17 @@ int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io, } int dpmcp_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - struct dpmcp_attr *attr) + 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); + cmd_flags, + token); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); diff --git a/drivers/staging/fsl-mc/bus/dpmcp.h b/drivers/staging/fsl-mc/bus/dpmcp.h index 5e7c219..164684f 100644 --- a/drivers/staging/fsl-mc/bus/dpmcp.h +++ b/drivers/staging/fsl-mc/bus/dpmcp.h @@ -41,6 +41,7 @@ struct fsl_mc_io; /** * dpmcp_open() - Open a control session for the specified object. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @dpmcp_id: DPMCP unique ID * @token: Returned token; use in subsequent API calls * @@ -54,7 +55,10 @@ struct fsl_mc_io; * * Return: '0' on Success; Error code otherwise. */ -int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token); +int dpmcp_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int dpmcp_id, + uint16_t *token); /* Get portal ID from pool */ #define DPMCP_GET_PORTAL_ID_FROM_POOL (-1) @@ -62,6 +66,7 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token); /** * dpmcp_close() - Close the control session of the object * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * * After this function is called, no further operations are @@ -69,12 +74,14 @@ int dpmcp_open(struct fsl_mc_io *mc_io, int dpmcp_id, uint16_t *token); * * Return: '0' on Success; Error code otherwise. */ -int dpmcp_close(struct fsl_mc_io *mc_io, uint16_t token); +int dpmcp_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** - * struct dpmcp_cfg() - Structure representing DPMCP configuration + * struct dpmcp_cfg - Structure representing DPMCP configuration * @portal_id: Portal ID; 'DPMCP_GET_PORTAL_ID_FROM_POOL' to get the portal ID - * from pool + * from pool */ struct dpmcp_cfg { int portal_id; @@ -83,6 +90,7 @@ struct dpmcp_cfg { /** * dpmcp_create() - Create the DPMCP object. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @cfg: Configuration structure * @token: Returned token; use in subsequent API calls * @@ -101,81 +109,91 @@ struct dpmcp_cfg { * Return: '0' on Success; Error code otherwise. */ int dpmcp_create(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, const struct dpmcp_cfg *cfg, - uint16_t *token); + uint16_t *token); /** * dpmcp_destroy() - Destroy the DPMCP object and release all its resources. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * * Return: '0' on Success; error code otherwise. */ -int dpmcp_destroy(struct fsl_mc_io *mc_io, uint16_t token); +int dpmcp_destroy(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** * dpmcp_reset() - Reset the DPMCP, returns the object to initial state. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * * Return: '0' on Success; Error code otherwise. */ -int dpmcp_reset(struct fsl_mc_io *mc_io, uint16_t token); +int dpmcp_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /* IRQ */ -/*! - * @name dpmcp IRQ Index and Events - */ +/* IRQ Index */ #define DPMCP_IRQ_INDEX 0 -/*!< Irq index */ +/* irq event - Indicates that the link state changed */ #define DPMCP_IRQ_EVENT_CMD_DONE 0x00000001 -/*!< irq event - Indicates that the link state changed */ -/* @} */ + +/** + * struct dpmcp_irq_cfg - IRQ configuration + * @paddr: Address that must be written to signal a message-based interrupt + * @val: Value to write into irq_addr address + * @user_irq_id: A user defined number associated with this IRQ + */ +struct dpmcp_irq_cfg { + uint64_t paddr; + uint32_t val; + int user_irq_id; +}; /** * dpmcp_set_irq() - Set IRQ information for the DPMCP to trigger an interrupt. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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 + * @irq_cfg: IRQ configuration * * Return: '0' on Success; Error code otherwise. */ int dpmcp_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint64_t irq_addr, - uint32_t irq_val, - int user_irq_id); + uint8_t irq_index, + struct dpmcp_irq_cfg *irq_cfg); /** * dpmcp_get_irq() - Get IRQ information from the DPMCP. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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 + * type (both irq_addr and irq_val are valid) + * @irq_cfg: IRQ attributes * * Return: '0' on Success; Error code otherwise. */ int dpmcp_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - int *type, - uint64_t *irq_addr, - uint32_t *irq_val, - int *user_irq_id); + uint8_t irq_index, + int *type, + struct dpmcp_irq_cfg *irq_cfg); /** * dpmcp_set_irq_enable() - Set overall interrupt state. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @en: Interrupt state - enable = 1, disable = 0 @@ -188,13 +206,15 @@ int dpmcp_get_irq(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint8_t en); + 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @en: Returned interrupt state - enable = 1, disable = 0 @@ -202,13 +222,15 @@ int dpmcp_set_irq_enable(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint8_t *en); + uint8_t irq_index, + uint8_t *en); /** * dpmcp_set_irq_mask() - Set interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @mask: Event mask to trigger interrupt; @@ -221,14 +243,16 @@ int dpmcp_get_irq_enable(struct fsl_mc_io *mc_io, * * Return: '0' on Success; Error code otherwise. */ -int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io, +int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t mask); + uint8_t irq_index, + uint32_t mask); /** * dpmcp_get_irq_mask() - Get interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @mask: Returned event mask to trigger interrupt @@ -238,15 +262,17 @@ int dpmcp_set_irq_mask(struct fsl_mc_io *mc_io, * * Return: '0' on Success; Error code otherwise. */ -int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io, +int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t *mask); + 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @status: Returned interrupts status - one bit per cause: @@ -256,14 +282,16 @@ int dpmcp_get_irq_mask(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t *status); + 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPMCP object * @irq_index: The interrupt index to configure * @status: Bits to clear (W1C) - one bit per cause: @@ -273,9 +301,10 @@ int dpmcp_get_irq_status(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpmcp_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - uint8_t irq_index, - uint32_t status); + uint8_t irq_index, + uint32_t status); /** * struct dpmcp_attr - Structure representing DPMCP attributes @@ -299,13 +328,15 @@ struct dpmcp_attr { * dpmcp_get_attributes - Retrieve DPMCP attributes. * * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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, + uint32_t cmd_flags, uint16_t token, - struct dpmcp_attr *attr); + struct dpmcp_attr *attr); #endif /* __FSL_DPMCP_H */ diff --git a/drivers/staging/fsl-mc/bus/dpmng.c b/drivers/staging/fsl-mc/bus/dpmng.c index 58328e8..1aeca05 100644 --- a/drivers/staging/fsl-mc/bus/dpmng.c +++ b/drivers/staging/fsl-mc/bus/dpmng.c @@ -34,14 +34,17 @@ #include "../include/dpmng.h" #include "dpmng-cmd.h" -int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info) +int mc_get_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + struct mc_version *mc_ver_info) { struct mc_command cmd = { 0 }; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPMNG_CMDID_GET_VERSION, - MC_CMD_PRI_LOW, 0); + cmd_flags, + 0); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -56,14 +59,17 @@ int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info) return 0; } -int dpmng_get_container_id(struct fsl_mc_io *mc_io, int *container_id) +int dpmng_get_container_id(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int *container_id) { struct mc_command cmd = { 0 }; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPMNG_CMDID_GET_CONT_ID, - MC_CMD_PRI_LOW, 0); + cmd_flags, + 0); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); diff --git a/drivers/staging/fsl-mc/bus/dprc-cmd.h b/drivers/staging/fsl-mc/bus/dprc-cmd.h index 0920248..6552c20 100644 --- a/drivers/staging/fsl-mc/bus/dprc-cmd.h +++ b/drivers/staging/fsl-mc/bus/dprc-cmd.h @@ -41,7 +41,7 @@ #define _FSL_DPRC_CMD_H /* DPRC Version */ -#define DPRC_VER_MAJOR 3 +#define DPRC_VER_MAJOR 4 #define DPRC_VER_MINOR 0 /* Command IDs */ @@ -72,12 +72,15 @@ #define DPRC_CMDID_GET_RES_COUNT 0x15B #define DPRC_CMDID_GET_RES_IDS 0x15C #define DPRC_CMDID_GET_OBJ_REG 0x15E +#define DPRC_CMDID_SET_OBJ_IRQ 0x15F +#define DPRC_CMDID_GET_OBJ_IRQ 0x160 +#define DPRC_CMDID_SET_OBJ_LABEL 0x161 +#define DPRC_CMDID_GET_OBJ_DESC 0x162 #define DPRC_CMDID_CONNECT 0x167 #define DPRC_CMDID_DISCONNECT 0x168 #define DPRC_CMDID_GET_POOL 0x169 #define DPRC_CMDID_GET_POOL_COUNT 0x16A -#define DPRC_CMDID_GET_PORTAL_PADDR 0x16B #define DPRC_CMDID_GET_CONNECTION 0x16C diff --git a/drivers/staging/fsl-mc/bus/dprc-driver.c b/drivers/staging/fsl-mc/bus/dprc-driver.c index 35c06cf..f87714f 100644 --- a/drivers/staging/fsl-mc/bus/dprc-driver.c +++ b/drivers/staging/fsl-mc/bus/dprc-driver.c @@ -262,6 +262,7 @@ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev) struct dprc_obj_desc *child_obj_desc_array = NULL; error = dprc_get_obj_count(mc_bus_dev->mc_io, + 0, mc_bus_dev->mc_handle, &num_child_objects); if (error < 0) { @@ -289,8 +290,19 @@ int dprc_scan_objects(struct fsl_mc_device *mc_bus_dev) &child_obj_desc_array[i]; error = dprc_get_obj(mc_bus_dev->mc_io, + 0, mc_bus_dev->mc_handle, i, obj_desc); + + /* + * -ENXIO means object index was invalid. + * This is caused when the DPRC was changed at + * the MC during the scan. In this case, + * abort the current scan. + */ + if (error == -ENXIO) + return error; + if (error < 0) { dev_err(&mc_bus_dev->dev, "dprc_get_obj(i=%d) failed: %d\n", @@ -357,6 +369,7 @@ int dprc_scan_container(struct fsl_mc_device *mc_bus_dev) return 0; error: + device_for_each_child(&mc_bus_dev->dev, NULL, __fsl_mc_device_remove); dprc_cleanup_all_resource_pools(mc_bus_dev); return error; } @@ -377,14 +390,28 @@ static int dprc_probe(struct fsl_mc_device *mc_dev) int error; size_t region_size; struct fsl_mc_bus *mc_bus = to_fsl_mc_bus(mc_dev); + bool mc_io_created = false; + bool dev_root_set = false; if (WARN_ON(strcmp(mc_dev->obj_desc.type, "dprc") != 0)) return -EINVAL; - if (!mc_dev->mc_io) { + if (mc_dev->mc_io) { + /* + * This is the root DPRC + */ + if (WARN_ON(fsl_mc_bus_type.dev_root)) + return -EINVAL; + + fsl_mc_bus_type.dev_root = &mc_dev->dev; + dev_root_set = true; + } else { /* - * This is a child DPRC: + * This is a child DPRC */ + if (WARN_ON(!fsl_mc_bus_type.dev_root)) + return -EINVAL; + if (WARN_ON(mc_dev->obj_desc.region_count == 0)) return -EINVAL; @@ -397,19 +424,29 @@ static int dprc_probe(struct fsl_mc_device *mc_dev) NULL, 0, &mc_dev->mc_io); if (error < 0) return error; + + mc_io_created = true; } - error = dprc_open(mc_dev->mc_io, mc_dev->obj_desc.id, + error = dprc_open(mc_dev->mc_io, 0, mc_dev->obj_desc.id, &mc_dev->mc_handle); if (error < 0) { dev_err(&mc_dev->dev, "dprc_open() failed: %d\n", error); goto error_cleanup_mc_io; } + error = dprc_get_attributes(mc_dev->mc_io, 0, mc_dev->mc_handle, + &mc_bus->dprc_attr); + if (error < 0) { + dev_err(&mc_dev->dev, "dprc_get_attributes() failed: %d\n", + error); + goto error_cleanup_open; + } + mutex_init(&mc_bus->scan_mutex); /* - * Discover MC objects in DPRC object: + * Discover MC objects in the DPRC object: */ error = dprc_scan_container(mc_dev); if (error < 0) @@ -419,10 +456,17 @@ static int dprc_probe(struct fsl_mc_device *mc_dev) return 0; error_cleanup_open: - (void)dprc_close(mc_dev->mc_io, mc_dev->mc_handle); + (void)dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle); error_cleanup_mc_io: - fsl_destroy_mc_io(mc_dev->mc_io); + if (mc_io_created) { + fsl_destroy_mc_io(mc_dev->mc_io); + mc_dev->mc_io = NULL; + } + + if (dev_root_set) + fsl_mc_bus_type.dev_root = NULL; + return error; } @@ -447,10 +491,13 @@ static int dprc_remove(struct fsl_mc_device *mc_dev) 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); + error = dprc_close(mc_dev->mc_io, 0, mc_dev->mc_handle); if (error < 0) dev_err(&mc_dev->dev, "dprc_close() failed: %d\n", error); + if (&mc_dev->dev == fsl_mc_bus_type.dev_root) + fsl_mc_bus_type.dev_root = NULL; + dev_info(&mc_dev->dev, "DPRC device unbound from driver"); return 0; } diff --git a/drivers/staging/fsl-mc/bus/dprc.c b/drivers/staging/fsl-mc/bus/dprc.c index 19b26e6..a1cdafd 100644 --- a/drivers/staging/fsl-mc/bus/dprc.c +++ b/drivers/staging/fsl-mc/bus/dprc.c @@ -34,13 +34,16 @@ #include "../include/dprc.h" #include "dprc-cmd.h" -int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token) +int dprc_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int container_id, + uint16_t *token) { struct mc_command cmd = { 0 }; int err; /* prepare command */ - cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, MC_CMD_PRI_LOW, + cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags, 0); cmd.params[0] |= mc_enc(0, 32, container_id); @@ -56,12 +59,14 @@ int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token) } EXPORT_SYMBOL(dprc_open); -int dprc_close(struct fsl_mc_io *mc_io, uint16_t token) +int dprc_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) { struct mc_command cmd = { 0 }; /* prepare command */ - cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, MC_CMD_PRI_HIGH, + cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags, token); /* send command to mc*/ @@ -70,10 +75,11 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token) EXPORT_SYMBOL(dprc_close); int dprc_create_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, struct dprc_cfg *cfg, int *child_container_id, - uint64_t *child_portal_paddr) + uint64_t *child_portal_offset) { struct mc_command cmd = { 0 }; int err; @@ -82,9 +88,26 @@ int dprc_create_container(struct fsl_mc_io *mc_io, cmd.params[0] |= mc_enc(32, 16, cfg->icid); cmd.params[0] |= mc_enc(0, 32, cfg->options); cmd.params[1] |= mc_enc(32, 32, cfg->portal_id); + cmd.params[2] |= mc_enc(0, 8, cfg->label[0]); + cmd.params[2] |= mc_enc(8, 8, cfg->label[1]); + cmd.params[2] |= mc_enc(16, 8, cfg->label[2]); + cmd.params[2] |= mc_enc(24, 8, cfg->label[3]); + cmd.params[2] |= mc_enc(32, 8, cfg->label[4]); + cmd.params[2] |= mc_enc(40, 8, cfg->label[5]); + cmd.params[2] |= mc_enc(48, 8, cfg->label[6]); + cmd.params[2] |= mc_enc(56, 8, cfg->label[7]); + cmd.params[3] |= mc_enc(0, 8, cfg->label[8]); + cmd.params[3] |= mc_enc(8, 8, cfg->label[9]); + cmd.params[3] |= mc_enc(16, 8, cfg->label[10]); + cmd.params[3] |= mc_enc(24, 8, cfg->label[11]); + cmd.params[3] |= mc_enc(32, 8, cfg->label[12]); + cmd.params[3] |= mc_enc(40, 8, cfg->label[13]); + cmd.params[3] |= mc_enc(48, 8, cfg->label[14]); + cmd.params[3] |= mc_enc(56, 8, cfg->label[15]); cmd.header = mc_encode_cmd_header(DPRC_CMDID_CREATE_CONT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -93,12 +116,14 @@ int dprc_create_container(struct fsl_mc_io *mc_io, /* retrieve response parameters */ *child_container_id = mc_dec(cmd.params[1], 0, 32); - *child_portal_paddr = mc_dec(cmd.params[2], 0, 64); + *child_portal_offset = mc_dec(cmd.params[2], 0, 64); return 0; } +EXPORT_SYMBOL(dprc_create_container); int dprc_destroy_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id) { @@ -106,14 +131,17 @@ int dprc_destroy_container(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_DESTROY_CONT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, child_container_id); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_destroy_container); int dprc_reset_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id) { @@ -121,27 +149,28 @@ int dprc_reset_container(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_RESET_CONT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, child_container_id); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_reset_container); int dprc_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, int *type, - uint64_t *irq_paddr, - uint32_t *irq_val, - int *user_irq_id) + struct dprc_irq_cfg *irq_cfg) { struct mc_command cmd = { 0 }; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(32, 8, irq_index); @@ -151,37 +180,39 @@ int dprc_get_irq(struct fsl_mc_io *mc_io, return err; /* retrieve response parameters */ - *irq_val = mc_dec(cmd.params[0], 0, 32); - *irq_paddr = mc_dec(cmd.params[1], 0, 64); - *user_irq_id = mc_dec(cmd.params[2], 0, 32); + irq_cfg->val = mc_dec(cmd.params[0], 0, 32); + irq_cfg->paddr = mc_dec(cmd.params[1], 0, 64); + irq_cfg->user_irq_id = mc_dec(cmd.params[2], 0, 32); *type = mc_dec(cmd.params[2], 32, 32); return 0; } +EXPORT_SYMBOL(dprc_get_irq); int dprc_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, - uint64_t irq_paddr, - uint32_t irq_val, - int user_irq_id) + struct dprc_irq_cfg *irq_cfg) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(32, 8, irq_index); - cmd.params[0] |= mc_enc(0, 32, irq_val); - cmd.params[1] |= mc_enc(0, 64, irq_paddr); - cmd.params[2] |= mc_enc(0, 32, user_irq_id); + cmd.params[0] |= mc_enc(0, 32, irq_cfg->val); + cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr); + cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id); /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_set_irq); int dprc_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t *en) @@ -191,7 +222,8 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_ENABLE, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -204,8 +236,10 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_irq_enable); int dprc_set_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t en) @@ -214,15 +248,18 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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); } +EXPORT_SYMBOL(dprc_set_irq_enable); int dprc_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *mask) @@ -232,7 +269,8 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_MASK, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -245,8 +283,10 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_irq_mask); int dprc_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t mask) @@ -255,15 +295,18 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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); } +EXPORT_SYMBOL(dprc_set_irq_mask); int dprc_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *status) @@ -273,7 +316,8 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(32, 8, irq_index); /* send command to mc*/ @@ -286,8 +330,10 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_irq_status); int dprc_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t status) @@ -296,15 +342,18 @@ int dprc_clear_irq_status(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS, - MC_CMD_PRI_LOW, token); + cmd_flags, + 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); } +EXPORT_SYMBOL(dprc_clear_irq_status); int dprc_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, struct dprc_attributes *attr) { @@ -313,7 +362,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR, - MC_CMD_PRI_LOW, + cmd_flags, token); /* send command to mc*/ @@ -331,8 +380,10 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_attributes); int dprc_set_res_quota(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, char *type, @@ -342,7 +393,8 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_RES_QUOTA, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, child_container_id); cmd.params[0] |= mc_enc(32, 16, quota); cmd.params[1] |= mc_enc(0, 8, type[0]); @@ -365,8 +417,10 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io, /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_set_res_quota); int dprc_get_res_quota(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, char *type, @@ -377,7 +431,8 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_QUOTA, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, child_container_id); cmd.params[1] |= mc_enc(0, 8, type[0]); cmd.params[1] |= mc_enc(8, 8, type[1]); @@ -406,8 +461,10 @@ int dprc_get_res_quota(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_res_quota); int dprc_assign(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int container_id, struct dprc_res_req *res_req) @@ -416,7 +473,8 @@ int dprc_assign(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_ASSIGN, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, container_id); cmd.params[0] |= mc_enc(32, 32, res_req->options); cmd.params[1] |= mc_enc(0, 32, res_req->num); @@ -441,8 +499,10 @@ int dprc_assign(struct fsl_mc_io *mc_io, /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_assign); int dprc_unassign(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, struct dprc_res_req *res_req) @@ -451,7 +511,7 @@ int dprc_unassign(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_UNASSIGN, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, child_container_id); cmd.params[0] |= mc_enc(32, 32, res_req->options); @@ -477,8 +537,10 @@ int dprc_unassign(struct fsl_mc_io *mc_io, /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_unassign); int dprc_get_pool_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int *pool_count) { @@ -487,7 +549,8 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_POOL_COUNT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -499,8 +562,10 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_pool_count); int dprc_get_pool(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int pool_index, char *type) @@ -510,7 +575,7 @@ int dprc_get_pool(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_POOL, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, pool_index); @@ -539,15 +604,20 @@ int dprc_get_pool(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_pool); -int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count) +int dprc_get_obj_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *obj_count) { struct mc_command cmd = { 0 }; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); /* send command to mc*/ err = mc_send_command(mc_io, &cmd); @@ -562,6 +632,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count) EXPORT_SYMBOL(dprc_get_obj_count); int dprc_get_obj(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int obj_index, struct dprc_obj_desc *obj_desc) @@ -571,7 +642,7 @@ int dprc_get_obj(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, obj_index); @@ -604,12 +675,201 @@ int dprc_get_obj(struct fsl_mc_io *mc_io, obj_desc->type[13] = mc_dec(cmd.params[4], 40, 8); obj_desc->type[14] = mc_dec(cmd.params[4], 48, 8); obj_desc->type[15] = '\0'; - + obj_desc->label[0] = mc_dec(cmd.params[5], 0, 8); + obj_desc->label[1] = mc_dec(cmd.params[5], 8, 8); + obj_desc->label[2] = mc_dec(cmd.params[5], 16, 8); + obj_desc->label[3] = mc_dec(cmd.params[5], 24, 8); + obj_desc->label[4] = mc_dec(cmd.params[5], 32, 8); + obj_desc->label[5] = mc_dec(cmd.params[5], 40, 8); + obj_desc->label[6] = mc_dec(cmd.params[5], 48, 8); + obj_desc->label[7] = mc_dec(cmd.params[5], 56, 8); + obj_desc->label[8] = mc_dec(cmd.params[6], 0, 8); + obj_desc->label[9] = mc_dec(cmd.params[6], 8, 8); + obj_desc->label[10] = mc_dec(cmd.params[6], 16, 8); + obj_desc->label[11] = mc_dec(cmd.params[6], 24, 8); + obj_desc->label[12] = mc_dec(cmd.params[6], 32, 8); + obj_desc->label[13] = mc_dec(cmd.params[6], 40, 8); + obj_desc->label[14] = mc_dec(cmd.params[6], 48, 8); + obj_desc->label[15] = '\0'; return 0; } EXPORT_SYMBOL(dprc_get_obj); +int dprc_get_obj_desc(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + struct dprc_obj_desc *obj_desc) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_DESC, + cmd_flags, + token); + cmd.params[0] |= mc_enc(0, 32, obj_id); + cmd.params[1] |= mc_enc(0, 8, obj_type[0]); + cmd.params[1] |= mc_enc(8, 8, obj_type[1]); + cmd.params[1] |= mc_enc(16, 8, obj_type[2]); + cmd.params[1] |= mc_enc(24, 8, obj_type[3]); + cmd.params[1] |= mc_enc(32, 8, obj_type[4]); + cmd.params[1] |= mc_enc(40, 8, obj_type[5]); + cmd.params[1] |= mc_enc(48, 8, obj_type[6]); + cmd.params[1] |= mc_enc(56, 8, obj_type[7]); + cmd.params[2] |= mc_enc(0, 8, obj_type[8]); + cmd.params[2] |= mc_enc(8, 8, obj_type[9]); + cmd.params[2] |= mc_enc(16, 8, obj_type[10]); + cmd.params[2] |= mc_enc(24, 8, obj_type[11]); + cmd.params[2] |= mc_enc(32, 8, obj_type[12]); + cmd.params[2] |= mc_enc(40, 8, obj_type[13]); + cmd.params[2] |= mc_enc(48, 8, obj_type[14]); + cmd.params[2] |= mc_enc(56, 8, obj_type[15]); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + obj_desc->id = (int)mc_dec(cmd.params[0], 32, 32); + obj_desc->vendor = (uint16_t)mc_dec(cmd.params[1], 0, 16); + obj_desc->vendor = (uint8_t)mc_dec(cmd.params[1], 16, 8); + obj_desc->region_count = (uint8_t)mc_dec(cmd.params[1], 24, 8); + obj_desc->state = (uint32_t)mc_dec(cmd.params[1], 32, 32); + obj_desc->ver_major = (uint16_t)mc_dec(cmd.params[2], 0, 16); + obj_desc->ver_minor = (uint16_t)mc_dec(cmd.params[2], 16, 16); + obj_desc->type[0] = (char)mc_dec(cmd.params[3], 0, 8); + obj_desc->type[1] = (char)mc_dec(cmd.params[3], 8, 8); + obj_desc->type[2] = (char)mc_dec(cmd.params[3], 16, 8); + obj_desc->type[3] = (char)mc_dec(cmd.params[3], 24, 8); + obj_desc->type[4] = (char)mc_dec(cmd.params[3], 32, 8); + obj_desc->type[5] = (char)mc_dec(cmd.params[3], 40, 8); + obj_desc->type[6] = (char)mc_dec(cmd.params[3], 48, 8); + obj_desc->type[7] = (char)mc_dec(cmd.params[3], 56, 8); + obj_desc->type[8] = (char)mc_dec(cmd.params[4], 0, 8); + obj_desc->type[9] = (char)mc_dec(cmd.params[4], 8, 8); + obj_desc->type[10] = (char)mc_dec(cmd.params[4], 16, 8); + obj_desc->type[11] = (char)mc_dec(cmd.params[4], 24, 8); + obj_desc->type[12] = (char)mc_dec(cmd.params[4], 32, 8); + obj_desc->type[13] = (char)mc_dec(cmd.params[4], 40, 8); + obj_desc->type[14] = (char)mc_dec(cmd.params[4], 48, 8); + obj_desc->type[15] = (char)mc_dec(cmd.params[4], 56, 8); + obj_desc->label[0] = (char)mc_dec(cmd.params[5], 0, 8); + obj_desc->label[1] = (char)mc_dec(cmd.params[5], 8, 8); + obj_desc->label[2] = (char)mc_dec(cmd.params[5], 16, 8); + obj_desc->label[3] = (char)mc_dec(cmd.params[5], 24, 8); + obj_desc->label[4] = (char)mc_dec(cmd.params[5], 32, 8); + obj_desc->label[5] = (char)mc_dec(cmd.params[5], 40, 8); + obj_desc->label[6] = (char)mc_dec(cmd.params[5], 48, 8); + obj_desc->label[7] = (char)mc_dec(cmd.params[5], 56, 8); + obj_desc->label[8] = (char)mc_dec(cmd.params[6], 0, 8); + obj_desc->label[9] = (char)mc_dec(cmd.params[6], 8, 8); + obj_desc->label[10] = (char)mc_dec(cmd.params[6], 16, 8); + obj_desc->label[11] = (char)mc_dec(cmd.params[6], 24, 8); + obj_desc->label[12] = (char)mc_dec(cmd.params[6], 32, 8); + obj_desc->label[13] = (char)mc_dec(cmd.params[6], 40, 8); + obj_desc->label[14] = (char)mc_dec(cmd.params[6], 48, 8); + obj_desc->label[15] = (char)mc_dec(cmd.params[6], 56, 8); + + return 0; +} +EXPORT_SYMBOL(dprc_get_obj_desc); + +int dprc_set_obj_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + uint8_t irq_index, + struct dprc_irq_cfg *irq_cfg) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ, + cmd_flags, + token); + cmd.params[0] |= mc_enc(32, 8, irq_index); + cmd.params[0] |= mc_enc(0, 32, irq_cfg->val); + cmd.params[1] |= mc_enc(0, 64, irq_cfg->paddr); + cmd.params[2] |= mc_enc(0, 32, irq_cfg->user_irq_id); + cmd.params[2] |= mc_enc(32, 32, obj_id); + cmd.params[3] |= mc_enc(0, 8, obj_type[0]); + cmd.params[3] |= mc_enc(8, 8, obj_type[1]); + cmd.params[3] |= mc_enc(16, 8, obj_type[2]); + cmd.params[3] |= mc_enc(24, 8, obj_type[3]); + cmd.params[3] |= mc_enc(32, 8, obj_type[4]); + cmd.params[3] |= mc_enc(40, 8, obj_type[5]); + cmd.params[3] |= mc_enc(48, 8, obj_type[6]); + cmd.params[3] |= mc_enc(56, 8, obj_type[7]); + cmd.params[4] |= mc_enc(0, 8, obj_type[8]); + cmd.params[4] |= mc_enc(8, 8, obj_type[9]); + cmd.params[4] |= mc_enc(16, 8, obj_type[10]); + cmd.params[4] |= mc_enc(24, 8, obj_type[11]); + cmd.params[4] |= mc_enc(32, 8, obj_type[12]); + cmd.params[4] |= mc_enc(40, 8, obj_type[13]); + cmd.params[4] |= mc_enc(48, 8, obj_type[14]); + cmd.params[4] |= mc_enc(56, 8, obj_type[15]); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} +EXPORT_SYMBOL(dprc_set_obj_irq); + +int dprc_get_obj_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + uint8_t irq_index, + int *type, + struct dprc_irq_cfg *irq_cfg) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_IRQ, + cmd_flags, + token); + cmd.params[0] |= mc_enc(0, 32, obj_id); + cmd.params[0] |= mc_enc(32, 8, irq_index); + cmd.params[1] |= mc_enc(0, 8, obj_type[0]); + cmd.params[1] |= mc_enc(8, 8, obj_type[1]); + cmd.params[1] |= mc_enc(16, 8, obj_type[2]); + cmd.params[1] |= mc_enc(24, 8, obj_type[3]); + cmd.params[1] |= mc_enc(32, 8, obj_type[4]); + cmd.params[1] |= mc_enc(40, 8, obj_type[5]); + cmd.params[1] |= mc_enc(48, 8, obj_type[6]); + cmd.params[1] |= mc_enc(56, 8, obj_type[7]); + cmd.params[2] |= mc_enc(0, 8, obj_type[8]); + cmd.params[2] |= mc_enc(8, 8, obj_type[9]); + cmd.params[2] |= mc_enc(16, 8, obj_type[10]); + cmd.params[2] |= mc_enc(24, 8, obj_type[11]); + cmd.params[2] |= mc_enc(32, 8, obj_type[12]); + cmd.params[2] |= mc_enc(40, 8, obj_type[13]); + cmd.params[2] |= mc_enc(48, 8, obj_type[14]); + cmd.params[2] |= mc_enc(56, 8, obj_type[15]); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + irq_cfg->val = (uint32_t)mc_dec(cmd.params[0], 0, 32); + irq_cfg->paddr = (uint64_t)mc_dec(cmd.params[1], 0, 64); + irq_cfg->user_irq_id = (int)mc_dec(cmd.params[2], 0, 32); + *type = (int)mc_dec(cmd.params[2], 32, 32); + + return 0; +} +EXPORT_SYMBOL(dprc_get_obj_irq); + int dprc_get_res_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *type, int *res_count) @@ -621,7 +881,8 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_COUNT, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[1] |= mc_enc(0, 8, type[0]); cmd.params[1] |= mc_enc(8, 8, type[1]); cmd.params[1] |= mc_enc(16, 8, type[2]); @@ -652,6 +913,7 @@ int dprc_get_res_count(struct fsl_mc_io *mc_io, EXPORT_SYMBOL(dprc_get_res_count); int dprc_get_res_ids(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *type, struct dprc_res_ids_range_desc *range_desc) @@ -661,7 +923,8 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_RES_IDS, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(42, 7, range_desc->iter_status); cmd.params[1] |= mc_enc(0, 32, range_desc->base_id); cmd.params[1] |= mc_enc(32, 32, range_desc->last_id); @@ -696,32 +959,8 @@ int dprc_get_res_ids(struct fsl_mc_io *mc_io, } EXPORT_SYMBOL(dprc_get_res_ids); -int dprc_get_portal_paddr(struct fsl_mc_io *mc_io, - uint16_t token, - int portal_id, - uint64_t *portal_addr) -{ - struct mc_command cmd = { 0 }; - int err; - - /* prepare command */ - cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_PORTAL_PADDR, - MC_CMD_PRI_LOW, token); - cmd.params[0] |= mc_enc(0, 32, portal_id); - - /* send command to mc*/ - err = mc_send_command(mc_io, &cmd); - if (err) - return err; - - /* retrieve response parameters */ - *portal_addr = mc_dec(cmd.params[1], 0, 64); - - return 0; -} -EXPORT_SYMBOL(dprc_get_portal_paddr); - int dprc_get_obj_region(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *obj_type, int obj_id, @@ -733,7 +972,8 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG, - MC_CMD_PRI_LOW, token); + cmd_flags, + token); cmd.params[0] |= mc_enc(0, 32, obj_id); cmd.params[0] |= mc_enc(48, 8, region_index); cmd.params[3] |= mc_enc(0, 8, obj_type[0]); @@ -759,28 +999,83 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io, return err; /* retrieve response parameters */ - region_desc->base_paddr = mc_dec(cmd.params[1], 0, 64); + region_desc->base_offset = mc_dec(cmd.params[1], 0, 64); region_desc->size = mc_dec(cmd.params[2], 0, 32); return 0; } EXPORT_SYMBOL(dprc_get_obj_region); +int dprc_set_obj_label(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + char *label) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_LABEL, + cmd_flags, + token); + + cmd.params[0] |= mc_enc(0, 32, obj_id); + cmd.params[1] |= mc_enc(0, 8, label[0]); + cmd.params[1] |= mc_enc(8, 8, label[1]); + cmd.params[1] |= mc_enc(16, 8, label[2]); + cmd.params[1] |= mc_enc(24, 8, label[3]); + cmd.params[1] |= mc_enc(32, 8, label[4]); + cmd.params[1] |= mc_enc(40, 8, label[5]); + cmd.params[1] |= mc_enc(48, 8, label[6]); + cmd.params[1] |= mc_enc(56, 8, label[7]); + cmd.params[2] |= mc_enc(0, 8, label[8]); + cmd.params[2] |= mc_enc(8, 8, label[9]); + cmd.params[2] |= mc_enc(16, 8, label[10]); + cmd.params[2] |= mc_enc(24, 8, label[11]); + cmd.params[2] |= mc_enc(32, 8, label[12]); + cmd.params[2] |= mc_enc(40, 8, label[13]); + cmd.params[2] |= mc_enc(48, 8, label[14]); + cmd.params[2] |= mc_enc(56, 8, label[15]); + cmd.params[3] |= mc_enc(0, 8, obj_type[0]); + cmd.params[3] |= mc_enc(8, 8, obj_type[1]); + cmd.params[3] |= mc_enc(16, 8, obj_type[2]); + cmd.params[3] |= mc_enc(24, 8, obj_type[3]); + cmd.params[3] |= mc_enc(32, 8, obj_type[4]); + cmd.params[3] |= mc_enc(40, 8, obj_type[5]); + cmd.params[3] |= mc_enc(48, 8, obj_type[6]); + cmd.params[3] |= mc_enc(56, 8, obj_type[7]); + cmd.params[4] |= mc_enc(0, 8, obj_type[8]); + cmd.params[4] |= mc_enc(8, 8, obj_type[9]); + cmd.params[4] |= mc_enc(16, 8, obj_type[10]); + cmd.params[4] |= mc_enc(24, 8, obj_type[11]); + cmd.params[4] |= mc_enc(32, 8, obj_type[12]); + cmd.params[4] |= mc_enc(40, 8, obj_type[13]); + cmd.params[4] |= mc_enc(48, 8, obj_type[14]); + cmd.params[4] |= mc_enc(56, 8, obj_type[15]); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} +EXPORT_SYMBOL(dprc_set_obj_label); + int dprc_connect(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, const struct dprc_endpoint *endpoint1, - const struct dprc_endpoint *endpoint2) + const struct dprc_endpoint *endpoint2, + const struct dprc_connection_cfg *cfg) { struct mc_command cmd = { 0 }; /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_CONNECT, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, endpoint1->id); - cmd.params[0] |= mc_enc(32, 32, endpoint1->interface_id); + cmd.params[0] |= mc_enc(32, 32, endpoint1->if_id); cmd.params[1] |= mc_enc(0, 32, endpoint2->id); - cmd.params[1] |= mc_enc(32, 32, endpoint2->interface_id); + cmd.params[1] |= mc_enc(32, 32, endpoint2->if_id); cmd.params[2] |= mc_enc(0, 8, endpoint1->type[0]); cmd.params[2] |= mc_enc(8, 8, endpoint1->type[1]); cmd.params[2] |= mc_enc(16, 8, endpoint1->type[2]); @@ -797,6 +1092,8 @@ int dprc_connect(struct fsl_mc_io *mc_io, cmd.params[3] |= mc_enc(40, 8, endpoint1->type[13]); cmd.params[3] |= mc_enc(48, 8, endpoint1->type[14]); cmd.params[3] |= mc_enc(56, 8, endpoint1->type[15]); + cmd.params[4] |= mc_enc(0, 32, cfg->max_rate); + cmd.params[4] |= mc_enc(32, 32, cfg->committed_rate); cmd.params[5] |= mc_enc(0, 8, endpoint2->type[0]); cmd.params[5] |= mc_enc(8, 8, endpoint2->type[1]); cmd.params[5] |= mc_enc(16, 8, endpoint2->type[2]); @@ -817,8 +1114,10 @@ int dprc_connect(struct fsl_mc_io *mc_io, /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_connect); int dprc_disconnect(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, const struct dprc_endpoint *endpoint) { @@ -826,10 +1125,10 @@ int dprc_disconnect(struct fsl_mc_io *mc_io, /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_DISCONNECT, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, endpoint->id); - cmd.params[0] |= mc_enc(32, 32, endpoint->interface_id); + cmd.params[0] |= mc_enc(32, 32, endpoint->if_id); cmd.params[1] |= mc_enc(0, 8, endpoint->type[0]); cmd.params[1] |= mc_enc(8, 8, endpoint->type[1]); cmd.params[1] |= mc_enc(16, 8, endpoint->type[2]); @@ -850,22 +1149,24 @@ int dprc_disconnect(struct fsl_mc_io *mc_io, /* send command to mc*/ return mc_send_command(mc_io, &cmd); } +EXPORT_SYMBOL(dprc_disconnect); int dprc_get_connection(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, - const struct dprc_endpoint *endpoint1, - struct dprc_endpoint *endpoint2, - int *state) + const struct dprc_endpoint *endpoint1, + struct dprc_endpoint *endpoint2, + int *state) { struct mc_command cmd = { 0 }; int err; /* prepare command */ cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION, - MC_CMD_PRI_LOW, + cmd_flags, token); cmd.params[0] |= mc_enc(0, 32, endpoint1->id); - cmd.params[0] |= mc_enc(32, 32, endpoint1->interface_id); + cmd.params[0] |= mc_enc(32, 32, endpoint1->if_id); cmd.params[1] |= mc_enc(0, 8, endpoint1->type[0]); cmd.params[1] |= mc_enc(8, 8, endpoint1->type[1]); cmd.params[1] |= mc_enc(16, 8, endpoint1->type[2]); @@ -890,7 +1191,7 @@ int dprc_get_connection(struct fsl_mc_io *mc_io, /* retrieve response parameters */ endpoint2->id = mc_dec(cmd.params[3], 0, 32); - endpoint2->interface_id = mc_dec(cmd.params[3], 32, 32); + endpoint2->if_id = mc_dec(cmd.params[3], 32, 32); endpoint2->type[0] = mc_dec(cmd.params[4], 0, 8); endpoint2->type[1] = mc_dec(cmd.params[4], 8, 8); endpoint2->type[2] = mc_dec(cmd.params[4], 16, 8); @@ -911,3 +1212,4 @@ int dprc_get_connection(struct fsl_mc_io *mc_io, return 0; } +EXPORT_SYMBOL(dprc_get_connection); diff --git a/drivers/staging/fsl-mc/bus/mc-allocator.c b/drivers/staging/fsl-mc/bus/mc-allocator.c index e36235d..60fb3d5 100644 --- a/drivers/staging/fsl-mc/bus/mc-allocator.c +++ b/drivers/staging/fsl-mc/bus/mc-allocator.c @@ -111,7 +111,7 @@ static int __must_check fsl_mc_resource_pool_remove_device(struct fsl_mc_device goto out; resource = mc_dev->resource; - if (WARN_ON(resource->data != mc_dev)) + if (WARN_ON(!resource || resource->data != mc_dev)) goto out; mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent); @@ -284,12 +284,17 @@ int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_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; + struct fsl_mc_device *dpmcp_dev; int error = -EINVAL; struct fsl_mc_resource *resource = NULL; struct fsl_mc_io *mc_io = NULL; - if (mc_dev->flags & FSL_MC_IS_DPRC) { + if (!mc_dev) { + if (WARN_ON(!fsl_mc_bus_type.dev_root)) + return error; + + mc_bus_dev = to_fsl_mc_device(fsl_mc_bus_type.dev_root); + } else 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)) @@ -304,23 +309,24 @@ int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev, if (error < 0) return error; - mc_adev = resource->data; - if (WARN_ON(!mc_adev)) + dpmcp_dev = resource->data; + if (WARN_ON(!dpmcp_dev || + strcmp(dpmcp_dev->obj_desc.type, "dpmcp") != 0)) goto error_cleanup_resource; - if (WARN_ON(mc_adev->obj_desc.region_count == 0)) + if (WARN_ON(dpmcp_dev->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; + mc_portal_phys_addr = dpmcp_dev->regions[0].start; + mc_portal_size = dpmcp_dev->regions[0].end - + dpmcp_dev->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_portal_size, dpmcp_dev, mc_io_flags, &mc_io); if (error < 0) goto error_cleanup_resource; @@ -342,12 +348,26 @@ EXPORT_SYMBOL_GPL(fsl_mc_portal_allocate); */ void fsl_mc_portal_free(struct fsl_mc_io *mc_io) { + struct fsl_mc_device *dpmcp_dev; struct fsl_mc_resource *resource; - resource = mc_io->resource; - if (WARN_ON(resource->type != FSL_MC_POOL_DPMCP)) + /* + * Every mc_io obtained by calling fsl_mc_portal_allocate() is supposed + * to have a DPMCP object associated with. + */ + dpmcp_dev = mc_io->dpmcp_dev; + if (WARN_ON(!dpmcp_dev)) + return; + if (WARN_ON(strcmp(dpmcp_dev->obj_desc.type, "dpmcp") != 0)) return; - if (WARN_ON(!resource->data)) + if (WARN_ON(dpmcp_dev->mc_io != mc_io)) + return; + + resource = dpmcp_dev->resource; + if (WARN_ON(!resource || resource->type != FSL_MC_POOL_DPMCP)) + return; + + if (WARN_ON(resource->data != dpmcp_dev)) return; fsl_destroy_mc_io(mc_io); @@ -363,31 +383,14 @@ EXPORT_SYMBOL_GPL(fsl_mc_portal_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; + struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev; - if (WARN_ON(!mc_dev)) + if (WARN_ON(!dpmcp_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); + error = dpmcp_reset(mc_io, 0, dpmcp_dev->mc_handle); if (error < 0) { - dev_err(&mc_dev->dev, "dpmcp_close() failed: %d\n", error); + dev_err(&dpmcp_dev->dev, "dpmcp_reset() failed: %d\n", error); return error; } @@ -491,16 +494,31 @@ static int fsl_mc_allocator_probe(struct fsl_mc_device *mc_dev) 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; + /* + * If mc_dev is the DPMCP object for the parent DPRC's built-in + * portal, we don't add this DPMCP to the DPMCP object pool, + * but instead allocate it directly to the parent DPRC (mc_bus_dev): + */ + if (strcmp(mc_dev->obj_desc.type, "dpmcp") == 0 && + mc_dev->obj_desc.id == mc_bus->dprc_attr.portal_id) { + error = fsl_mc_io_set_dpmcp(mc_bus_dev->mc_io, mc_dev); + if (error < 0) + goto error; + } else { + 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"); + dev_dbg(&mc_dev->dev, + "Allocatable MC object device bound to fsl_mc_allocator driver"); return 0; error: @@ -513,20 +531,20 @@ error: */ static int fsl_mc_allocator_remove(struct fsl_mc_device *mc_dev) { - int error = -EINVAL; + int error; if (WARN_ON(!FSL_MC_IS_ALLOCATABLE(mc_dev->obj_desc.type))) - goto out; + return -EINVAL; - error = fsl_mc_resource_pool_remove_device(mc_dev); - if (error < 0) - goto out; + if (mc_dev->resource) { + error = fsl_mc_resource_pool_remove_device(mc_dev); + if (error < 0) + return error; + } - dev_info(&mc_dev->dev, - "Allocatable MC object device unbound from fsl_mc_allocator driver"); - error = 0; -out: - return error; + dev_dbg(&mc_dev->dev, + "Allocatable MC object device unbound from fsl_mc_allocator driver"); + return 0; } static const struct fsl_mc_device_match_id match_id_table[] = { diff --git a/drivers/staging/fsl-mc/bus/mc-bus.c b/drivers/staging/fsl-mc/bus/mc-bus.c index 766a659..749036b 100644 --- a/drivers/staging/fsl-mc/bus/mc-bus.c +++ b/drivers/staging/fsl-mc/bus/mc-bus.c @@ -39,18 +39,18 @@ static int fsl_mc_bus_match(struct device *dev, struct device_driver *drv) bool major_version_mismatch = false; bool minor_version_mismatch = false; - if (WARN_ON(!fsl_mc_bus_type.dev_root)) - goto out; - if (!mc_drv->match_id_table) goto out; /* * If the object is not 'plugged' don't match. * Only exception is the root DPRC, which is a special case. + * + * NOTE: Only when this function is invoked for the root DPRC, + * mc_dev->mc_io is not NULL */ if ((mc_dev->obj_desc.state & DPRC_OBJ_STATE_PLUGGED) == 0 && - &mc_dev->dev != fsl_mc_bus_type.dev_root) + !mc_dev->mc_io) goto out; /* @@ -213,14 +213,14 @@ static int get_dprc_icid(struct fsl_mc_io *mc_io, struct dprc_attributes attr; int error; - error = dprc_open(mc_io, container_id, &dprc_handle); + error = dprc_open(mc_io, 0, container_id, &dprc_handle); if (error < 0) { pr_err("dprc_open() failed: %d\n", error); return error; } memset(&attr, 0, sizeof(attr)); - error = dprc_get_attributes(mc_io, dprc_handle, &attr); + error = dprc_get_attributes(mc_io, 0, dprc_handle, &attr); if (error < 0) { pr_err("dprc_get_attributes() failed: %d\n", error); goto common_cleanup; @@ -230,11 +230,12 @@ static int get_dprc_icid(struct fsl_mc_io *mc_io, error = 0; common_cleanup: - (void)dprc_close(mc_io, dprc_handle); + (void)dprc_close(mc_io, 0, dprc_handle); return error; } -static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr) +static int translate_mc_addr(enum dprc_region_type mc_region_type, + uint64_t mc_offset, phys_addr_t *phys_addr) { int i; struct fsl_mc *mc = dev_get_drvdata(fsl_mc_bus_type.dev_root->parent); @@ -243,7 +244,7 @@ static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr) /* * Do identity mapping: */ - *phys_addr = mc_addr; + *phys_addr = mc_offset; return 0; } @@ -251,10 +252,11 @@ static int translate_mc_addr(uint64_t mc_addr, phys_addr_t *phys_addr) struct fsl_mc_addr_translation_range *range = &mc->translation_ranges[i]; - if (mc_addr >= range->start_mc_addr && - mc_addr < range->end_mc_addr) { + if (mc_region_type == range->mc_region_type && + mc_offset >= range->start_mc_offset && + mc_offset < range->end_mc_offset) { *phys_addr = range->start_phys_addr + - (mc_addr - range->start_mc_addr); + (mc_offset - range->start_mc_offset); return 0; } } @@ -270,6 +272,22 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev, struct resource *regions; struct dprc_obj_desc *obj_desc = &mc_dev->obj_desc; struct device *parent_dev = mc_dev->dev.parent; + enum dprc_region_type mc_region_type; + + if (strcmp(obj_desc->type, "dprc") == 0 || + strcmp(obj_desc->type, "dpmcp") == 0) { + mc_region_type = DPRC_REGION_TYPE_MC_PORTAL; + } else if (strcmp(obj_desc->type, "dpio") == 0) { + mc_region_type = DPRC_REGION_TYPE_QBMAN_PORTAL; + } else { + /* + * This function should not have been called for this MC object + * type, as this object type is not supposed to have MMIO + * regions + */ + WARN_ON(true); + return -EINVAL; + } regions = kmalloc_array(obj_desc->region_count, sizeof(regions[0]), GFP_KERNEL); @@ -280,6 +298,7 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev, struct dprc_region_desc region_desc; error = dprc_get_obj_region(mc_bus_dev->mc_io, + 0, mc_bus_dev->mc_handle, obj_desc->type, obj_desc->id, i, ®ion_desc); @@ -289,14 +308,15 @@ static int fsl_mc_device_get_mmio_regions(struct fsl_mc_device *mc_dev, goto error_cleanup_regions; } - WARN_ON(region_desc.base_paddr == 0x0); WARN_ON(region_desc.size == 0); - error = translate_mc_addr(region_desc.base_paddr, + error = translate_mc_addr(mc_region_type, + region_desc.base_offset, ®ions[i].start); if (error < 0) { dev_err(parent_dev, - "Invalid MC address: %#llx\n", - region_desc.base_paddr); + "Invalid MC offset: %#x (for %s.%d\'s region %d)\n", + region_desc.base_offset, + obj_desc->type, obj_desc->id, i); goto error_cleanup_regions; } @@ -386,9 +406,6 @@ int fsl_mc_device_add(struct dprc_obj_desc *obj_desc, } mc_io2 = mc_io; - - if (!fsl_mc_bus_type.dev_root) - fsl_mc_bus_type.dev_root = &mc_dev->dev; } error = get_dprc_icid(mc_io2, obj_desc->id, &mc_dev->icid); @@ -473,7 +490,8 @@ void fsl_mc_device_remove(struct fsl_mc_device *mc_dev) if (&mc_dev->dev == fsl_mc_bus_type.dev_root) fsl_mc_bus_type.dev_root = NULL; - } + } else + WARN_ON(mc_dev->mc_io != NULL); if (mc_bus) devm_kfree(mc_dev->dev.parent, mc_bus); @@ -574,12 +592,14 @@ static int get_mc_addr_translation_ranges(struct device *dev, for (i = 0; i < *num_ranges; ++i) { struct fsl_mc_addr_translation_range *range = &(*ranges)[i]; - range->start_mc_addr = of_read_number(cell, mc_addr_cells); + range->mc_region_type = of_read_number(cell, 1); + range->start_mc_offset = of_read_number(cell + 1, + mc_addr_cells - 1); cell += mc_addr_cells; range->start_phys_addr = of_read_number(cell, paddr_cells); cell += paddr_cells; - range->end_mc_addr = range->start_mc_addr + - of_read_number(cell, mc_size_cells); + range->end_mc_offset = range->start_mc_offset + + of_read_number(cell, mc_size_cells); cell += mc_size_cells; } @@ -630,7 +650,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev) if (error < 0) return error; - error = mc_get_version(mc_io, &mc_version); + error = mc_get_version(mc_io, 0, &mc_version); if (error != 0) { dev_err(&pdev->dev, "mc_get_version() failed with error %d\n", error); @@ -661,7 +681,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev) if (error < 0) goto error_cleanup_mc_io; - error = dpmng_get_container_id(mc_io, &container_id); + error = dpmng_get_container_id(mc_io, 0, &container_id); if (error < 0) { dev_err(&pdev->dev, "dpmng_get_container_id() failed: %d\n", error); @@ -673,6 +693,7 @@ static int fsl_mc_bus_probe(struct platform_device *pdev) obj_desc.id = container_id; obj_desc.ver_major = DPRC_VER_MAJOR; obj_desc.ver_minor = DPRC_VER_MINOR; + obj_desc.irq_count = 1; obj_desc.region_count = 0; error = fsl_mc_device_add(&obj_desc, mc_io, &pdev->dev, &mc_bus_dev); @@ -713,6 +734,7 @@ MODULE_DEVICE_TABLE(of, fsl_mc_bus_match_table); static struct platform_driver fsl_mc_bus_driver = { .driver = { .name = "fsl_mc_bus", + .owner = THIS_MODULE, .pm = NULL, .of_match_table = fsl_mc_bus_match_table, }, diff --git a/drivers/staging/fsl-mc/bus/mc-sys.c b/drivers/staging/fsl-mc/bus/mc-sys.c index 5737f59..dc3aedb 100644 --- a/drivers/staging/fsl-mc/bus/mc-sys.c +++ b/drivers/staging/fsl-mc/bus/mc-sys.c @@ -34,15 +34,16 @@ #include "../include/mc-sys.h" #include "../include/mc-cmd.h" +#include "../include/mc.h" #include #include #include #include /** - * Timeout in jiffies to wait for the completion of an MC command + * Timeout in milliseconds to wait for the completion of an MC command */ -#define MC_CMD_COMPLETION_TIMEOUT_JIFFIES (HZ / 2) /* 500 ms */ +#define MC_CMD_COMPLETION_TIMEOUT_MS 500 /* * usleep_range() min and max values used to throttle down polling @@ -70,9 +71,10 @@ 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, + struct fsl_mc_device *dpmcp_dev, uint32_t flags, struct fsl_mc_io **new_mc_io) { + int error; struct fsl_mc_io *mc_io; void __iomem *mc_portal_virt_addr; struct resource *res; @@ -85,7 +87,11 @@ 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; + if (flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL) + spin_lock_init(&mc_io->spinlock); + else + mutex_init(&mc_io->mutex); + res = devm_request_mem_region(dev, mc_portal_phys_addr, mc_portal_size, @@ -108,8 +114,19 @@ int __must_check fsl_create_mc_io(struct device *dev, } mc_io->portal_virt_addr = mc_portal_virt_addr; + if (dpmcp_dev) { + error = fsl_mc_io_set_dpmcp(mc_io, dpmcp_dev); + if (error < 0) + goto error_destroy_mc_io; + } + *new_mc_io = mc_io; return 0; + +error_destroy_mc_io: + fsl_destroy_mc_io(mc_io); + return error; + } EXPORT_SYMBOL_GPL(fsl_create_mc_io); @@ -120,6 +137,11 @@ EXPORT_SYMBOL_GPL(fsl_create_mc_io); */ void fsl_destroy_mc_io(struct fsl_mc_io *mc_io) { + struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev; + + if (dpmcp_dev) + fsl_mc_io_unset_dpmcp(mc_io); + devm_iounmap(mc_io->dev, mc_io->portal_virt_addr); devm_release_mem_region(mc_io->dev, mc_io->portal_phys_addr, @@ -130,6 +152,39 @@ void fsl_destroy_mc_io(struct fsl_mc_io *mc_io) } EXPORT_SYMBOL_GPL(fsl_destroy_mc_io); +int fsl_mc_io_set_dpmcp(struct fsl_mc_io *mc_io, + struct fsl_mc_device *dpmcp_dev) +{ + if (WARN_ON(!dpmcp_dev)) + return -EINVAL; + + if (WARN_ON(mc_io->dpmcp_dev)) + return -EINVAL; + + if (WARN_ON(dpmcp_dev->mc_io)) + return -EINVAL; + + mc_io->dpmcp_dev = dpmcp_dev; + dpmcp_dev->mc_io = mc_io; + return 0; +} +EXPORT_SYMBOL_GPL(fsl_mc_io_set_dpmcp); + +void fsl_mc_io_unset_dpmcp(struct fsl_mc_io *mc_io) +{ + struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev; + + if (WARN_ON(!dpmcp_dev)) + return; + + if (WARN_ON(dpmcp_dev->mc_io != mc_io)) + return; + + mc_io->dpmcp_dev = NULL; + dpmcp_dev->mc_io = NULL; +} +EXPORT_SYMBOL_GPL(fsl_mc_io_unset_dpmcp); + static int mc_status_to_error(enum mc_cmd_status status) { static const int mc_status_to_error_map[] = { @@ -223,26 +278,13 @@ static inline enum mc_cmd_status mc_read_response(struct mc_command __iomem * return status; } -/** - * Sends an command to the MC device using the given MC I/O object - * - * @mc_io: MC I/O object to be used - * @cmd: command to be sent - * - * Returns '0' on Success; Error code otherwise. - * - * NOTE: This function cannot be invoked from from atomic contexts. - */ -int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd) +static int mc_polling_wait_preemptible(struct fsl_mc_io *mc_io, + struct mc_command *cmd, + enum mc_cmd_status *mc_status) { enum mc_cmd_status status; unsigned long jiffies_until_timeout = - jiffies + MC_CMD_COMPLETION_TIMEOUT_JIFFIES; - - /* - * Send command to the MC hardware: - */ - mc_write_command(mc_io->portal_virt_addr, cmd); + jiffies + msecs_to_jiffies(MC_CMD_COMPLETION_TIMEOUT_MS); /* * Wait for response from the MC hardware: @@ -271,17 +313,103 @@ int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd) } } - if (status != MC_CMD_STATUS_OK) { - pr_debug("MC command failed: portal: %#llx, obj handle: %#x, command: %#x, status: %s (%#x)\n", - mc_io->portal_phys_addr, - (unsigned int)MC_CMD_HDR_READ_TOKEN(cmd->header), - (unsigned int)MC_CMD_HDR_READ_CMDID(cmd->header), - mc_status_to_string(status), - (unsigned int)status); - - return mc_status_to_error(status); + *mc_status = status; + return 0; +} + +static int mc_polling_wait_atomic(struct fsl_mc_io *mc_io, + struct mc_command *cmd, + enum mc_cmd_status *mc_status) +{ + enum mc_cmd_status status; + unsigned long timeout_usecs = MC_CMD_COMPLETION_TIMEOUT_MS * 1000; + + BUILD_BUG_ON((MC_CMD_COMPLETION_TIMEOUT_MS * 1000) % + MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS != 0); + + for (;;) { + status = mc_read_response(mc_io->portal_virt_addr, cmd); + if (status != MC_CMD_STATUS_READY) + break; + + udelay(MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS); + timeout_usecs -= MC_CMD_COMPLETION_POLLING_MAX_SLEEP_USECS; + if (timeout_usecs == 0) { + pr_debug("MC command timed out (portal: %#llx, obj handle: %#x, command: %#x)\n", + mc_io->portal_phys_addr, + (unsigned int) + MC_CMD_HDR_READ_TOKEN(cmd->header), + (unsigned int) + MC_CMD_HDR_READ_CMDID(cmd->header)); + + return -ETIMEDOUT; + } } + *mc_status = status; return 0; } + +/** + * Sends a command to the MC device using the given MC I/O object + * + * @mc_io: MC I/O object to be used + * @cmd: command to be sent + * + * Returns '0' on Success; Error code otherwise. + */ +int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd) +{ + int error; + enum mc_cmd_status status; + unsigned long irq_flags = 0; + + if (WARN_ON(in_irq() && + !(mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL))) + return -EINVAL; + + if (mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL) + spin_lock_irqsave(&mc_io->spinlock, irq_flags); + else + mutex_lock(&mc_io->mutex); + + /* + * Send command to the MC hardware: + */ + mc_write_command(mc_io->portal_virt_addr, cmd); + + /* + * Wait for response from the MC hardware: + */ + if (!(mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL)) + error = mc_polling_wait_preemptible(mc_io, cmd, &status); + else + error = mc_polling_wait_atomic(mc_io, cmd, &status); + + if (error < 0) + goto common_exit; + + if (status != MC_CMD_STATUS_OK) { + pr_debug( + "MC command failed: portal: %#llx, obj handle: %#x, command: %#x, status: %s (%#x)\n", + mc_io->portal_phys_addr, + (unsigned int)MC_CMD_HDR_READ_TOKEN(cmd->header), + (unsigned int)MC_CMD_HDR_READ_CMDID(cmd->header), + mc_status_to_string(status), + (unsigned int)status); + + error = mc_status_to_error(status); + goto common_exit; + } + + error = 0; + +common_exit: + if (mc_io->flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL) + spin_unlock_irqrestore(&mc_io->spinlock, irq_flags); + else + mutex_unlock(&mc_io->mutex); + + return error; +} EXPORT_SYMBOL(mc_send_command); diff --git a/drivers/staging/fsl-mc/include/dpbp-cmd.h b/drivers/staging/fsl-mc/include/dpbp-cmd.h index 1fd70a21..be80c03 100644 --- a/drivers/staging/fsl-mc/include/dpbp-cmd.h +++ b/drivers/staging/fsl-mc/include/dpbp-cmd.h @@ -1,40 +1,40 @@ -/* 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. -*/ +/* 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_CMD_H #define _FSL_DPBP_CMD_H /* DPBP Version */ #define DPBP_VER_MAJOR 2 -#define DPBP_VER_MINOR 0 +#define DPBP_VER_MINOR 1 /* Command IDs */ #define DPBP_CMDID_CLOSE 0x800 @@ -57,4 +57,87 @@ #define DPBP_CMDID_GET_IRQ_STATUS 0x016 #define DPBP_CMDID_CLEAR_IRQ_STATUS 0x017 +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_CMD_OPEN(cmd, dpbp_id) \ + MC_CMD_OP(cmd, 0, 0, 32, int, dpbp_id) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_RSP_IS_ENABLED(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 1, int, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_CMD_SET_IRQ(cmd, irq_index, irq_cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, irq_index);\ + MC_CMD_OP(cmd, 0, 32, 32, uint32_t, irq_cfg->val);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr); \ + MC_CMD_OP(cmd, 2, 0, 32, int, irq_cfg->user_irq_id); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_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 DPBP_RSP_GET_IRQ(cmd, type, irq_cfg) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, irq_cfg->val); \ + MC_RSP_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr); \ + MC_RSP_OP(cmd, 2, 0, 32, int, irq_cfg->user_irq_id); \ + MC_RSP_OP(cmd, 2, 32, 32, int, type); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_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 DPBP_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 DPBP_RSP_GET_IRQ_ENABLE(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 8, uint8_t, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_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 DPBP_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 DPBP_RSP_GET_IRQ_MASK(cmd, mask) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, mask) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_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 DPBP_RSP_GET_IRQ_STATUS(cmd, status) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, status) + +/* cmd, param, offset, width, type, arg_name */ +#define DPBP_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 DPBP_RSP_GET_ATTRIBUTES(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 16, 16, uint16_t, attr->bpid); \ + 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_DPBP_CMD_H */ diff --git a/drivers/staging/fsl-mc/include/dpbp.h b/drivers/staging/fsl-mc/include/dpbp.h index 5f3c8e7..5d16bb1 100644 --- a/drivers/staging/fsl-mc/include/dpbp.h +++ b/drivers/staging/fsl-mc/include/dpbp.h @@ -41,6 +41,7 @@ struct fsl_mc_io; /** * dpbp_open() - Open a control session for the specified object. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @dpbp_id: DPBP unique ID * @token: Returned token; use in subsequent API calls * @@ -54,11 +55,15 @@ struct fsl_mc_io; * * Return: '0' on Success; Error code otherwise. */ -int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token); +int dpbp_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * * After this function is called, no further operations are @@ -66,10 +71,12 @@ int dpbp_open(struct fsl_mc_io *mc_io, int dpbp_id, uint16_t *token); * * Return: '0' on Success; Error code otherwise. */ -int dpbp_close(struct fsl_mc_io *mc_io, uint16_t token); +int dpbp_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** - * struct dpbp_cfg() - Structure representing DPBP configuration + * struct dpbp_cfg - Structure representing DPBP configuration * @options: place holder */ struct dpbp_cfg { @@ -79,6 +86,7 @@ struct dpbp_cfg { /** * dpbp_create() - Create the DPBP object. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @cfg: Configuration structure * @token: Returned token; use in subsequent API calls * @@ -97,99 +105,123 @@ struct dpbp_cfg { * Return: '0' on Success; Error code otherwise. */ int dpbp_create(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * * Return: '0' on Success; error code otherwise. */ -int dpbp_destroy(struct fsl_mc_io *mc_io, uint16_t token); +int dpbp_destroy(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** * dpbp_enable() - Enable the DPBP. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * * Return: '0' on Success; Error code otherwise. */ -int dpbp_enable(struct fsl_mc_io *mc_io, uint16_t token); +int dpbp_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** * dpbp_disable() - Disable the DPBP. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * * Return: '0' on Success; Error code otherwise. */ -int dpbp_disable(struct fsl_mc_io *mc_io, uint16_t token); +int dpbp_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** * dpbp_is_enabled() - Check if the DPBP is enabled. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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); +int dpbp_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + 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 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * * Return: '0' on Success; Error code otherwise. */ -int dpbp_reset(struct fsl_mc_io *mc_io, uint16_t token); +int dpbp_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * struct dpbp_irq_cfg - IRQ configuration + * @addr: Address that must be written to signal a message-based interrupt + * @val: Value to write into irq_addr address + * @user_irq_id: A user defined number associated with this IRQ + */ +struct dpbp_irq_cfg { + uint64_t addr; + uint32_t val; + int user_irq_id; +}; /** * dpbp_set_irq() - Set IRQ information for the DPBP to trigger an interrupt. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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 + * @irq_cfg: IRQ configuration * * Return: '0' on Success; Error code otherwise. */ int dpbp_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, - uint64_t irq_addr, - uint32_t irq_val, - int user_irq_id); + struct dpbp_irq_cfg *irq_cfg); /** * dpbp_get_irq() - Get IRQ information from the DPBP. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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 + * type (both irq_addr and irq_val are valid) + * @irq_cfg: IRQ attributes * * Return: '0' on Success; Error code otherwise. */ int dpbp_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, int *type, - uint64_t *irq_addr, - uint32_t *irq_val, - int *user_irq_id); + struct dpbp_irq_cfg *irq_cfg); /** * dpbp_set_irq_enable() - Set overall interrupt state. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @en: Interrupt state - enable = 1, disable = 0 @@ -202,6 +234,7 @@ int dpbp_get_irq(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t en); @@ -209,6 +242,7 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io, /** * dpbp_get_irq_enable() - Get overall interrupt state * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @en: Returned interrupt state - enable = 1, disable = 0 @@ -216,6 +250,7 @@ int dpbp_set_irq_enable(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t *en); @@ -223,6 +258,7 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, /** * dpbp_set_irq_mask() - Set interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @mask: Event mask to trigger interrupt; @@ -236,6 +272,7 @@ int dpbp_get_irq_enable(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t mask); @@ -243,6 +280,7 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io, /** * dpbp_get_irq_mask() - Get interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @mask: Returned event mask to trigger interrupt @@ -253,6 +291,7 @@ int dpbp_set_irq_mask(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *mask); @@ -261,6 +300,7 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, * dpbp_get_irq_status() - Get the current status of any pending interrupts. * * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @status: Returned interrupts status - one bit per cause: @@ -270,6 +310,7 @@ int dpbp_get_irq_mask(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *status); @@ -278,6 +319,7 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io, * dpbp_clear_irq_status() - Clear a pending interrupt's status * * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPBP object * @irq_index: The interrupt index to configure * @status: Bits to clear (W1C) - one bit per cause: @@ -287,6 +329,7 @@ int dpbp_get_irq_status(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dpbp_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t status); @@ -316,12 +359,14 @@ struct dpbp_attr { * dpbp_get_attributes - Retrieve DPBP attributes. * * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @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, + uint32_t cmd_flags, uint16_t token, struct dpbp_attr *attr); diff --git a/drivers/staging/fsl-mc/include/dpcon-cmd.h b/drivers/staging/fsl-mc/include/dpcon-cmd.h index c878d33..0c1fc63 100644 --- a/drivers/staging/fsl-mc/include/dpcon-cmd.h +++ b/drivers/staging/fsl-mc/include/dpcon-cmd.h @@ -1,40 +1,40 @@ /* 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. -*/ + * + * 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 +#define DPCON_VER_MINOR 1 /* Command IDs */ #define DPCON_CMDID_CLOSE 0x800 @@ -59,4 +59,101 @@ #define DPCON_CMDID_SET_NOTIFICATION 0x100 +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_OPEN(cmd, dpcon_id) \ + MC_CMD_OP(cmd, 0, 0, 32, int, dpcon_id) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_CREATE(cmd, cfg) \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, cfg->num_priorities) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_IS_ENABLED(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 1, int, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ(cmd, irq_index, irq_cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, irq_index);\ + MC_CMD_OP(cmd, 0, 32, 32, uint32_t, irq_cfg->val);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_CMD_OP(cmd, 2, 0, 32, int, irq_cfg->user_irq_id); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_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 DPCON_RSP_GET_IRQ(cmd, type, irq_cfg) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, irq_cfg->val);\ + MC_RSP_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_RSP_OP(cmd, 2, 0, 32, int, irq_cfg->user_irq_id); \ + MC_RSP_OP(cmd, 2, 32, 32, int, type);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_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 DPCON_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 DPCON_RSP_GET_IRQ_ENABLE(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 8, uint8_t, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_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 DPCON_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 DPCON_RSP_GET_IRQ_MASK(cmd, mask) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, mask) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_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 DPCON_RSP_GET_IRQ_STATUS(cmd, status) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, status) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_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 DPCON_RSP_GET_ATTR(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, int, attr->id);\ + MC_RSP_OP(cmd, 0, 32, 16, uint16_t, attr->qbman_ch_id);\ + MC_RSP_OP(cmd, 0, 48, 8, uint8_t, attr->num_priorities);\ + 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) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_NOTIFICATION(cmd, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, int, cfg->dpio_id);\ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->priority);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->user_ctx);\ +} while (0) + #endif /* _FSL_DPCON_CMD_H */ diff --git a/drivers/staging/fsl-mc/include/dpmng.h b/drivers/staging/fsl-mc/include/dpmng.h index 1b052b8..4a0996c 100644 --- a/drivers/staging/fsl-mc/include/dpmng.h +++ b/drivers/staging/fsl-mc/include/dpmng.h @@ -41,11 +41,11 @@ struct fsl_mc_io; /** * Management Complex firmware version information */ -#define MC_VER_MAJOR 6 +#define MC_VER_MAJOR 8 #define MC_VER_MINOR 0 /** - * struct mc_versoin + * struct mc_version * @major: Major version number: incremented on API compatibility changes * @minor: Minor version number: incremented on API additions (that are * backward compatible); reset when major version is incremented @@ -62,19 +62,25 @@ struct mc_version { * mc_get_version() - Retrieves the Management Complex firmware * version information * @mc_io: Pointer to opaque I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @mc_ver_info: Returned version information structure * * Return: '0' on Success; Error code otherwise. */ -int mc_get_version(struct fsl_mc_io *mc_io, struct mc_version *mc_ver_info); +int mc_get_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + struct mc_version *mc_ver_info); /** * dpmng_get_container_id() - Get container ID associated with a given portal. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @container_id: Requested container ID * * Return: '0' on Success; Error code otherwise. */ -int dpmng_get_container_id(struct fsl_mc_io *mc_io, int *container_id); +int dpmng_get_container_id(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int *container_id); #endif /* __FSL_DPMNG_H */ diff --git a/drivers/staging/fsl-mc/include/dprc.h b/drivers/staging/fsl-mc/include/dprc.h index f1862a7..253ef7d 100644 --- a/drivers/staging/fsl-mc/include/dprc.h +++ b/drivers/staging/fsl-mc/include/dprc.h @@ -32,6 +32,8 @@ #ifndef _FSL_DPRC_H #define _FSL_DPRC_H +#include "mc-cmd.h" + /* Data Path Resource Container API * Contains DPRC API for managing and querying DPAA resources */ @@ -55,6 +57,7 @@ struct fsl_mc_io; /** * dprc_open() - Open DPRC object for use * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @container_id: Container ID to open * @token: Returned token of DPRC object * @@ -62,11 +65,15 @@ struct fsl_mc_io; * * @warning Required before any operation on the object. */ -int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token); +int dprc_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int container_id, + uint16_t *token); /** * dprc_close() - Close the control session of the object * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * * After this function is called, no further operations are @@ -74,7 +81,9 @@ int dprc_open(struct fsl_mc_io *mc_io, int container_id, uint16_t *token); * * Return: '0' on Success; Error code otherwise. */ -int dprc_close(struct fsl_mc_io *mc_io, uint16_t token); +int dprc_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); /** * Container general options @@ -99,7 +108,7 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token); /* Object initialization allowed - software context associated with this * container is allowed to invoke object initialization operations. */ -#define DPRC_CFG_OPT_OBJ_CREATE_ALLOWED 0x00000004 +#define DPRC_CFG_OPT_OBJ_CREATE_ALLOWED 0x00000004 /* Topology change allowed - software context associated with this * container is allowed to invoke topology operations, such as attach/detach @@ -115,6 +124,9 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token); /* AIOP - Indicates that container belongs to AIOP. */ #define DPRC_CFG_OPT_AIOP 0x00000020 +/* IRQ Config - Indicates that the container allowed to configure its IRQs. */ +#define DPRC_CFG_OPT_IRQ_CFG_ALLOWED 0x00000040 + /** * struct dprc_cfg - Container configuration options * @icid: Container's ICID; if set to 'DPRC_GET_ICID_FROM_POOL', a free @@ -122,33 +134,37 @@ int dprc_close(struct fsl_mc_io *mc_io, uint16_t token); * @portal_id: Portal ID; if set to 'DPRC_GET_PORTAL_ID_FROM_POOL', a free * portal ID is allocated by the DPRC * @options: Combination of 'DPRC_CFG_OPT_' options + * @label: Object's label */ struct dprc_cfg { - uint16_t icid; - int portal_id; - uint64_t options; + uint16_t icid; + int portal_id; + uint64_t options; + char label[16]; }; /** * dprc_create_container() - Create child container * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @cfg: Child container configuration * @child_container_id: Returned child container ID - * @child_portal_paddr: Returned base physical address of the - * child portal + * @child_portal_offset: Returned child portal offset from MC portal base * * Return: '0' on Success; Error code otherwise. */ int dprc_create_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, struct dprc_cfg *cfg, int *child_container_id, - uint64_t *child_portal_paddr); + uint64_t *child_portal_offset); /** * dprc_destroy_container() - Destroy child container. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @child_container_id: ID of the container to destroy * @@ -168,12 +184,14 @@ int dprc_create_container(struct fsl_mc_io *mc_io, * */ int dprc_destroy_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id); /** * dprc_reset_container - Reset child container. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @child_container_id: ID of the container to reset * @@ -192,25 +210,33 @@ int dprc_destroy_container(struct fsl_mc_io *mc_io, * * Return: '0' on Success; Error code otherwise. */ -int dprc_reset_container(struct fsl_mc_io *mc_io, - uint16_t token, - int child_container_id); +int dprc_reset_container(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int child_container_id); /* IRQ */ +/* IRQ index */ +#define DPRC_IRQ_INDEX 0 + /* Number of dprc's IRQs */ #define DPRC_NUM_OF_IRQS 1 -/* Object irq events */ +/* DPRC IRQ events */ -/* IRQ event - Indicates that a new object assigned to the container */ +/* IRQ event - Indicates that a new object added to the container */ #define DPRC_IRQ_EVENT_OBJ_ADDED 0x00000001 -/* IRQ event - Indicates that an object was unassigned from the container */ + +/* IRQ event - Indicates that an object was removed from the container */ #define DPRC_IRQ_EVENT_OBJ_REMOVED 0x00000002 -/* IRQ event - Indicates that resources assigned to the container */ + +/* IRQ event - Indicates that resources added to the container */ #define DPRC_IRQ_EVENT_RES_ADDED 0x00000004 -/* IRQ event - Indicates that resources unassigned from the container */ + +/* IRQ event - Indicates that resources removed from the container */ #define DPRC_IRQ_EVENT_RES_REMOVED 0x00000008 + /* IRQ event - Indicates that one of the descendant containers that opened by * this container is destroyed */ @@ -225,49 +251,56 @@ int dprc_reset_container(struct fsl_mc_io *mc_io, #define DPRC_IRQ_EVENT_OBJ_CREATED 0x00000040 /** + * struct dprc_irq_cfg - IRQ configuration + * @paddr: Address that must be written to signal a message-based interrupt + * @val: Value to write into irq_addr address + * @user_irq_id: A user defined number associated with this IRQ + */ +struct dprc_irq_cfg { + uint64_t paddr; + uint32_t val; + int user_irq_id; +}; + +/** * dprc_set_irq() - Set IRQ information for the DPRC to trigger an interrupt. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC 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: Returned a user defined number associated with this IRQ + * @irq_cfg: IRQ configuration * * Return: '0' on Success; Error code otherwise. */ int dprc_set_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, - uint64_t irq_addr, - uint32_t irq_val, - int user_irq_id); + struct dprc_irq_cfg *irq_cfg); /** * dprc_get_irq() - Get IRQ information from the DPRC. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure - * @type: Returned 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 + * @type: Interrupt type: 0 represents message interrupt + * type (both irq_addr and irq_val are valid) + * @irq_cfg: IRQ attributes * * Return: '0' on Success; Error code otherwise. */ int dprc_get_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, int *type, - uint64_t *irq_addr, - uint32_t *irq_val, - int *user_irq_id); + struct dprc_irq_cfg *irq_cfg); /** * dprc_set_irq_enable() - Set overall interrupt state. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @en: Interrupt state - enable = 1, disable = 0 @@ -280,6 +313,7 @@ int dprc_get_irq(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_set_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t en); @@ -287,6 +321,7 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io, /** * dprc_get_irq_enable() - Get overall interrupt state. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @en: Returned interrupt state - enable = 1, disable = 0 @@ -294,6 +329,7 @@ int dprc_set_irq_enable(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_irq_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint8_t *en); @@ -301,6 +337,7 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io, /** * dprc_set_irq_mask() - Set interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @mask: event mask to trigger interrupt; @@ -314,6 +351,7 @@ int dprc_get_irq_enable(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_set_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t mask); @@ -321,6 +359,7 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io, /** * dprc_get_irq_mask() - Get interrupt mask. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @mask: Returned event mask to trigger interrupt @@ -331,6 +370,7 @@ int dprc_set_irq_mask(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_irq_mask(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *mask); @@ -338,6 +378,7 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io, /** * dprc_get_irq_status() - Get the current status of any pending interrupts. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @status: Returned interrupts status - one bit per cause: @@ -347,6 +388,7 @@ int dprc_get_irq_mask(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t *status); @@ -354,6 +396,7 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io, /** * dprc_clear_irq_status() - Clear a pending interrupt's status * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @irq_index: The interrupt index to configure * @status: bits to clear (W1C) - one bit per cause: @@ -363,6 +406,7 @@ int dprc_get_irq_status(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_clear_irq_status(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, uint8_t irq_index, uint32_t status); @@ -394,12 +438,14 @@ struct dprc_attributes { /** * dprc_get_attributes() - Obtains container attributes * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object - * @attributes Returned container attributes + * @attributes: Returned container attributes * * Return: '0' on Success; Error code otherwise. */ int dprc_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, struct dprc_attributes *attributes); @@ -407,6 +453,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io, * dprc_set_res_quota() - Set allocation policy for a specific resource/object * type in a child container * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @child_container_id: ID of the child container * @type: Resource/object type @@ -428,6 +475,7 @@ int dprc_get_attributes(struct fsl_mc_io *mc_io, * @warning Only the parent container is allowed to change a child policy. */ int dprc_set_res_quota(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, char *type, @@ -437,8 +485,9 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io, * dprc_get_res_quota() - Gets the allocation policy of a specific * resource/object type in a child container * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object - * @child_container_id; ID of the child container + * @child_container_id: ID of the child container * @type: resource/object type * @quota: Returnes the maximum number of resources of the selected type * that the child container is allowed to allocate from the parent; @@ -448,6 +497,7 @@ int dprc_set_res_quota(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_res_quota(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, char *type, @@ -500,6 +550,7 @@ struct dprc_res_req { /** * dprc_assign() - Assigns objects or resource to a child container. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @container_id: ID of the child container * @res_req: Describes the type and amount of resources to @@ -529,6 +580,7 @@ struct dprc_res_req { * Return: '0' on Success; Error code otherwise. */ int dprc_assign(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int container_id, struct dprc_res_req *res_req); @@ -537,6 +589,7 @@ int dprc_assign(struct fsl_mc_io *mc_io, * dprc_unassign() - Un-assigns objects or resources from a child container * and moves them into this (parent) DPRC. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @child_container_id: ID of the child container * @res_req: Describes the type and amount of resources to un-assign from @@ -548,12 +601,14 @@ int dprc_assign(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_unassign(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int child_container_id, struct dprc_res_req *res_req); /** * dprc_get_pool_count() - Get the number of dprc's pools + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @mc_io: Pointer to MC portal's I/O object * @token: Token of DPRC object * @pool_count: Returned number of resource pools in the dprc @@ -561,14 +616,16 @@ int dprc_unassign(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_pool_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int *pool_count); /** * dprc_get_pool() - Get the type (string) of a certain dprc's pool * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object - * @pool_index; Index of the pool to be queried (< pool_count) + * @pool_index: Index of the pool to be queried (< pool_count) * @type: The type of the pool * * The pool types retrieved one by one by incrementing @@ -579,6 +636,7 @@ int dprc_get_pool_count(struct fsl_mc_io *mc_io, * Return: '0' on Success; Error code otherwise. */ int dprc_get_pool(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int pool_index, char *type); @@ -586,12 +644,16 @@ int dprc_get_pool(struct fsl_mc_io *mc_io, /** * dprc_get_obj_count() - Obtains the number of objects in the DPRC * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @obj_count: Number of objects assigned to the DPRC * * Return: '0' on Success; Error code otherwise. */ -int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count); +int dprc_get_obj_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *obj_count); /* Objects Attributes Flags */ @@ -610,6 +672,7 @@ int dprc_get_obj_count(struct fsl_mc_io *mc_io, uint16_t token, int *obj_count); * @irq_count: Number of interrupts supported by the object * @region_count: Number of mappable regions supported by the object * @state: Object state: combination of DPRC_OBJ_STATE_ states + * @label: Object label */ struct dprc_obj_desc { char type[16]; @@ -620,11 +683,13 @@ struct dprc_obj_desc { uint8_t irq_count; uint8_t region_count; uint32_t state; + char label[16]; }; /** * dprc_get_obj() - Get general information on an object * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @obj_index: Index of the object to be queried (< obj_count) * @obj_desc: Returns the requested object descriptor @@ -637,14 +702,79 @@ struct dprc_obj_desc { * Return: '0' on Success; Error code otherwise. */ int dprc_get_obj(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, int obj_index, struct dprc_obj_desc *obj_desc); /** + * dprc_get_obj_desc() - Get object descriptor. + * + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPRC object + * @obj_type: The type of the object to get its descriptor. + * @obj_id: The id of the object to get its descriptor + * @obj_desc: The returned descriptor to fill and return to the user + * + * Return: '0' on Success; Error code otherwise. + * + */ +int dprc_get_obj_desc(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + struct dprc_obj_desc *obj_desc); + +/** + * dprc_set_obj_irq() - Set IRQ information for object to trigger an interrupt. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPRC object + * @obj_type: Type of the object to set its IRQ + * @obj_id: ID of the object to set its IRQ + * @irq_index: The interrupt index to configure + * @irq_cfg: IRQ configuration + * + * Return: '0' on Success; Error code otherwise. + */ +int dprc_set_obj_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + uint8_t irq_index, + struct dprc_irq_cfg *irq_cfg); + +/** + * dprc_get_obj_irq() - Get IRQ information from object. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPRC object + * @obj_type: Type od the object to get its IRQ + * @obj_id: ID of the object to get its IRQ + * @irq_index: The interrupt index to configure + * @type: Interrupt type: 0 represents message interrupt + * type (both irq_addr and irq_val are valid) + * @irq_cfg: The returned IRQ attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dprc_get_obj_irq(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + uint8_t irq_index, + int *type, + struct dprc_irq_cfg *irq_cfg); + +/** * dprc_get_res_count() - Obtains the number of free resources that are assigned * to this container, by pool type * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @type: pool type * @res_count: Returned number of free resources of the given @@ -652,7 +782,8 @@ int dprc_get_obj(struct fsl_mc_io *mc_io, * * Return: '0' on Success; Error code otherwise. */ -int dprc_get_res_count(struct fsl_mc_io *mc_io, +int dprc_get_res_count(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *type, int *res_count); @@ -687,6 +818,7 @@ struct dprc_res_ids_range_desc { /** * dprc_get_res_ids() - Obtains IDs of free resources in the container * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @type: pool type * @range_desc: range descriptor @@ -694,39 +826,48 @@ struct dprc_res_ids_range_desc { * Return: '0' on Success; Error code otherwise. */ int dprc_get_res_ids(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *type, struct dprc_res_ids_range_desc *range_desc); +/* Region flags */ +/* Cacheable - Indicates that region should be mapped as cacheable */ +#define DPRC_REGION_CACHEABLE 0x00000001 + /** - * dprc_get_portal_paddr() - Get the physical address of MC portals - * @mc_io: Pointer to MC portal's I/O object - * @token: Token of DPRC object - * @portal_id: MC portal ID - * @portal_addr: The physical address of the MC portal ID - * - * Return: '0' on Success; Error code otherwise. + * enum dprc_region_type - Region type + * @DPRC_REGION_TYPE_MC_PORTAL: MC portal region + * @DPRC_REGION_TYPE_QBMAN_PORTAL: Qbman portal region */ -int dprc_get_portal_paddr(struct fsl_mc_io *mc_io, - uint16_t token, - int portal_id, - uint64_t *portal_addr); +enum dprc_region_type { + DPRC_REGION_TYPE_MC_PORTAL, + DPRC_REGION_TYPE_QBMAN_PORTAL +}; /** * struct dprc_region_desc - Mappable region descriptor - * @base_paddr: Region base physical address + * @base_offset: Region offset from region's base address. + * For DPMCP and DPRC objects, region base is offset from SoC MC portals + * base address; For DPIO, region base is offset from SoC QMan portals + * base address * @size: Region size (in bytes) + * @flags: Region attributes + * @type: Portal region type */ struct dprc_region_desc { - uint64_t base_paddr; - uint32_t size; + uint32_t base_offset; + uint32_t size; + uint32_t flags; + enum dprc_region_type type; }; /** * dprc_get_obj_region() - Get region information for a specified object. * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object - * @obj_type; Object type as returned in dprc_get_obj() + * @obj_type: Object type as returned in dprc_get_obj() * @obj_id: Unique object instance as returned in dprc_get_obj() * @region_index: The specific region to query * @region_desc: Returns the requested region descriptor @@ -734,6 +875,7 @@ struct dprc_region_desc { * Return: '0' on Success; Error code otherwise. */ int dprc_get_obj_region(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, char *obj_type, int obj_id, @@ -741,57 +883,102 @@ int dprc_get_obj_region(struct fsl_mc_io *mc_io, struct dprc_region_desc *region_desc); /** + * dprc_set_obj_label() - Set object label. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPRC object + * @obj_type: Object's type + * @obj_id: Object's ID + * @label: The required label. The maximum length is 16 chars. + * + * Return: '0' on Success; Error code otherwise. + */ +int dprc_set_obj_label(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + char *obj_type, + int obj_id, + char *label); + +/** * struct dprc_endpoint - Endpoint description for link connect/disconnect * operations * @type: Endpoint object type: NULL terminated string * @id: Endpoint object ID - * @interface_id: Interface ID; should be set for endpoints with multiple + * @if_id: Interface ID; should be set for endpoints with multiple * interfaces ("dpsw", "dpdmux"); for others, always set to 0 */ struct dprc_endpoint { char type[16]; int id; - int interface_id; + int if_id; +}; + +/** + * struct dprc_connection_cfg - Connection configuration. + * Used for virtual connections only + * @committed_rate: Committed rate (Mbits/s) + * @max_rate: Maximum rate (Mbits/s) + */ +struct dprc_connection_cfg { + uint32_t committed_rate; + uint32_t max_rate; }; /** * dprc_connect() - Connect two endpoints to create a network link between them * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @endpoint1: Endpoint 1 configuration parameters * @endpoint2: Endpoint 2 configuration parameters + * @cfg: Connection configuration. The connection configuration is ignored for + * connections made to DPMAC objects, where rate is set according to + * MAC configuration. + * The committed rate is the guaranteed rate for the connection. + * The maximum rate is an upper limit allowed for the connection; it is + * expected to be equal or higher than the committed rate. + * When committed and maximum rates are both zero, the connection is set + * to "best effort" mode, having lower priority compared to connections + * with committed or maximum rates. * * Return: '0' on Success; Error code otherwise. */ -int dprc_connect(struct fsl_mc_io *mc_io, - uint16_t token, - const struct dprc_endpoint *endpoint1, - const struct dprc_endpoint *endpoint2); +int dprc_connect(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + const struct dprc_endpoint *endpoint1, + const struct dprc_endpoint *endpoint2, + const struct dprc_connection_cfg *cfg); /** * dprc_disconnect() - Disconnect one endpoint to remove its network connection * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' * @token: Token of DPRC object * @endpoint: Endpoint configuration parameters * * Return: '0' on Success; Error code otherwise. */ int dprc_disconnect(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, const struct dprc_endpoint *endpoint); /** * dprc_get_connection() - Get connected endpoint and link status if connection * exists. -* @mc_io Pointer to MC portal's I/O object -* @token Token of DPRC object -* @endpoint1 Endpoint 1 configuration parameters -* @endpoint2 Returned endpoint 2 configuration parameters +* @mc_io: Pointer to MC portal's I/O object +* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' +* @token: Token of DPRC object +* @endpoint1: Endpoint 1 configuration parameters +* @endpoint2: Returned endpoint 2 configuration parameters * @state: Returned link state: 1 - link is up, 0 - link is down * * Return: '0' on Success; -ENAVAIL if connection does not exist. */ int dprc_get_connection(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, uint16_t token, const struct dprc_endpoint *endpoint1, struct dprc_endpoint *endpoint2, diff --git a/drivers/staging/fsl-mc/include/mc-cmd.h b/drivers/staging/fsl-mc/include/mc-cmd.h index 32501e0..57fefd2 100644 --- a/drivers/staging/fsl-mc/include/mc-cmd.h +++ b/drivers/staging/fsl-mc/include/mc-cmd.h @@ -67,14 +67,29 @@ enum mc_cmd_status { MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */ }; +/* + * MC command flags + */ + +/* High priority flag */ +#define MC_CMD_FLAG_PRI 0x00008000 +/* Command completion flag */ +#define MC_CMD_FLAG_INTR_DIS 0x01000000 + +/* TODO Remove following two defines after completion of flib 8.0.0 +integration */ +#define MC_CMD_PRI_LOW 0 /*!< Low Priority command indication */ +#define MC_CMD_PRI_HIGH 1 /*!< High Priority command indication */ + #define MC_CMD_HDR_CMDID_O 52 /* Command ID field offset */ #define MC_CMD_HDR_CMDID_S 12 /* Command ID field size */ #define MC_CMD_HDR_TOKEN_O 38 /* Token field offset */ #define MC_CMD_HDR_TOKEN_S 10 /* Token field size */ #define MC_CMD_HDR_STATUS_O 16 /* Status field offset */ #define MC_CMD_HDR_STATUS_S 8 /* Status field size*/ -#define MC_CMD_HDR_PRI_O 15 /* Priority field offset */ -#define MC_CMD_HDR_PRI_S 1 /* Priority field size */ +#define MC_CMD_HDR_FLAGS_O 0 /* Flags field offset */ +#define MC_CMD_HDR_FLAGS_S 32 /* Flags field size*/ +#define MC_CMD_HDR_FLAGS_MASK 0xFF00FF00 /* Command flags mask */ #define MC_CMD_HDR_READ_STATUS(_hdr) \ ((enum mc_cmd_status)mc_dec((_hdr), \ @@ -83,8 +98,8 @@ enum mc_cmd_status { #define MC_CMD_HDR_READ_TOKEN(_hdr) \ ((uint16_t)mc_dec((_hdr), MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S)) -#define MC_CMD_PRI_LOW 0 /* Low Priority command indication */ -#define MC_CMD_PRI_HIGH 1 /* High Priority command indication */ +#define MC_CMD_HDR_READ_FLAGS(_hdr) \ + ((uint32_t)mc_dec((_hdr), MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S)) #define MC_EXT_OP(_ext, _param, _offset, _width, _type, _arg) \ ((_ext)[_param] |= mc_enc((_offset), (_width), _arg)) @@ -96,14 +111,15 @@ enum mc_cmd_status { (_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width))) static inline uint64_t mc_encode_cmd_header(uint16_t cmd_id, - uint8_t priority, + 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_PRI_O, MC_CMD_HDR_PRI_S, priority); hdr |= mc_enc(MC_CMD_HDR_STATUS_O, MC_CMD_HDR_STATUS_S, MC_CMD_STATUS_READY); diff --git a/drivers/staging/fsl-mc/include/mc-private.h b/drivers/staging/fsl-mc/include/mc-private.h index c045f49..03809d2 100644 --- a/drivers/staging/fsl-mc/include/mc-private.h +++ b/drivers/staging/fsl-mc/include/mc-private.h @@ -29,7 +29,8 @@ /** * struct fsl_mc - Private data of a "fsl,qoriq-mc" platform device * @root_mc_bus_dev: MC object device representing the root DPRC - * @addr_translation_ranges: array of bus to system address translation ranges + * @num_translation_ranges: number of entries in addr_translation_ranges + * @translation_ranges: array of bus to system address translation ranges */ struct fsl_mc { struct fsl_mc_device *root_mc_bus_dev; @@ -40,14 +41,16 @@ struct fsl_mc { /** * struct fsl_mc_addr_translation_range - bus to system address translation * range - * @start_mc_addr: Start MC address of the range being translated - * @end_mc_addr: MC address of the first byte after the range (last MC - * address of the range is end_mc_addr - 1) + * @mc_region_type: Type of MC region for the range being translated + * @start_mc_offset: Start MC offset of the range being translated + * @end_mc_offset: MC offset of the first byte after the range (last MC + * offset of the range is end_mc_offset - 1) * @start_phys_addr: system physical address corresponding to start_mc_addr */ struct fsl_mc_addr_translation_range { - uint64_t start_mc_addr; - uint64_t end_mc_addr; + enum dprc_region_type mc_region_type; + uint64_t start_mc_offset; + uint64_t end_mc_offset; phys_addr_t start_phys_addr; }; @@ -77,11 +80,13 @@ struct fsl_mc_resource_pool { * for this MC bus. These resources represent allocatable entities * from the physical DPRC. * @scan_mutex: Serializes bus scanning + * @dprc_attr: DPRC attributes */ 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 */ + struct dprc_attributes dprc_attr; }; #define to_fsl_mc_bus(_mc_dev) \ diff --git a/drivers/staging/fsl-mc/include/mc-sys.h b/drivers/staging/fsl-mc/include/mc-sys.h index cb3b5a2..f2a9214 100644 --- a/drivers/staging/fsl-mc/include/mc-sys.h +++ b/drivers/staging/fsl-mc/include/mc-sys.h @@ -39,6 +39,13 @@ #include #include #include +#include +#include + +/** + * Bit masks for a MC I/O object (struct fsl_mc_io) flags + */ +#define FSL_MC_IO_ATOMIC_CONTEXT_PORTAL 0x0001 struct fsl_mc_resource; struct mc_command; @@ -50,27 +57,57 @@ 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) + * @dpmcp_dev: pointer to the DPMCP device associated with the MC portal. + * + * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not + * set: + * @mutex: Mutex to serialize mc_send_command() calls that use the same MC + * portal, if the fsl_mc_io object was created with the + * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag off. mc_send_command() calls for this + * fsl_mc_io object must be made only from non-atomic context. + * + * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is + * set: + * @spinlock: Spinlock to serialize mc_send_command() calls that use the same MC + * portal, if the fsl_mc_io object was created with the + * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag on. mc_send_command() calls for this + * fsl_mc_io object can be made from atomic or non-atomic context. */ struct fsl_mc_io { struct device *dev; - uint32_t flags; - uint32_t portal_size; + uint16_t flags; + uint16_t portal_size; phys_addr_t portal_phys_addr; void __iomem *portal_virt_addr; - struct fsl_mc_resource *resource; + struct fsl_mc_device *dpmcp_dev; + union { + /* + * This field is only meaningful if the + * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not set + */ + struct mutex mutex; /* serializes mc_send_command() */ + + /* + * This field is only meaningful if the + * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is set + */ + spinlock_t spinlock; /* serializes mc_send_command() */ + }; }; 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, + struct fsl_mc_device *dpmcp_dev, uint32_t flags, struct fsl_mc_io **new_mc_io); void fsl_destroy_mc_io(struct fsl_mc_io *mc_io); +int fsl_mc_io_set_dpmcp(struct fsl_mc_io *mc_io, + struct fsl_mc_device *dpmcp_dev); + +void fsl_mc_io_unset_dpmcp(struct fsl_mc_io *mc_io); + int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd); #endif /* _FSL_MC_SYS_H */ -- 2.3.3 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/