From nobody Fri Sep 25 18:24:27 2026 Received: from GVXPR05CU001.outbound.protection.outlook.com (mail-swedencentralazon11013046.outbound.protection.outlook.com [52.101.83.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 10D5A581255; Wed, 9 Sep 2026 16:22:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=52.101.83.46 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970968; cv=fail; b=UkXSPgU6K3PEA0ULIswOUmKQT56m7Ax76yKion+71Ruunpe0zKeQBt2TezIG4wGqQHYV8eRQ5mPhsMqy408lahBDiV9ZvZFTcu8YsOxqVnArvRgkpjP4+gzflWYi/ZW3BMxdgfy3FCTriq/rJLkImAOlLu+OBXEc8vrzfBp40VM= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970968; c=relaxed/simple; bh=GwWfo0MsxKCelE2Xo0jbTOdPa28b2DtON2PxVX5DKdo=; h=From:Date:Subject:Content-Type:Message-Id:References:In-Reply-To: To:Cc:MIME-Version; b=ppQm9CPxf52e1Gzzv5tMq6LS+73f4XAVb5NETmLWq7YBVs5VknVMKwKSpRaH+zbggTOEAOBZw7zaDq9Y8ue35A1Vj3tz2tWWppXBARN+nxQPuzjqRS4wqYtSBwuLFBit73pzhPYw0dHgOsyO7Xc4hmCHrRR8mGKTeVZ7rZQCIWA= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com; spf=pass smtp.mailfrom=oss.nxp.com; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b=S/s73/fW; arc=fail smtp.client-ip=52.101.83.46 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="S/s73/fW" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=pVENk5hZrmc1IKk86oEQC/Mf6uQnKzVe8G4iQ3WyUGkMRWx4CHhM89/ShoJuJlBjR3etnfAK9AAIfBLmM0gJYP/VeAgxwwMsqc1Xv6eZy68HAlvCSSLUarER3sCJPF6infJvXb8N9wGNYXY/VjGVE03WbETUNkzWF/p2HoVqDtGbois7b9cnTHRJkpDsMerpKJQw0LXZ3t+FAoQi55Lr/OkiMTRqIOg1R3LXJNpJlApkJ/U+yvMjQiNI7Dt4vM09Z3BrXgqDHHLgdtVaYYpaggQAp097Mv7e0AN6bGJFZzlxXP3f/UUNZ1NdBjHuKVz47x744R5oreYIQGWqkPV82Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=L7qBuTb+KutPZrA5F9ZBIyplad8w+M0A0/guNzj9IsE=; b=jWd3YbIFoHPDCNfpmc8Dh6fvQocXq8Z2CuiUmbvsa9VPwjPdPhBRarsBtzR6v4dwj4/swaJUdcrgmydtZnJrPH7czOv+eVBR76FqFhLo+KQvngPSCibQU0wym4m736uVItWsXh32ZXQD82ILe23PvzxhMvQQFcTvnQaLDFpQyRge9vzgTOqAXXoDrO3hWlp2qQlF4mzEmzCELgY/LvYyMEZSysyoyqQ5ZHFts2I75O4CinVz2HaBsXE2f9pJMLiNhgBvVglH23bF8V3cU8JIWxDcipYXtlnIuomTTAALSeMKAN2izgYXDALiOEcYW2erFBcq6dfIeGwbOOq7ZQM3Qw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector1-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=L7qBuTb+KutPZrA5F9ZBIyplad8w+M0A0/guNzj9IsE=; b=S/s73/fWDPkZ+nrGFruiA1iAtJR/thYA/L2N/bTVP9z5hWpUo3sMbFNoZ53JF5c0tjK5ZydZ57XAlhGpjaDW5Do0DeZ1JW8ouxkjMXbehJFbknEdNF5vSu/R8iRxratBmOwBjvzacVQ5/D+sojAU/6WZowvyA2m/CHBqv7hWY89m+U5XojggMqYlRzfC2W1P1RfHE+2OSBxxYOI2bAZhO/bGsFZTjp80Al/3HPGwD0N3VSatjcNDiDaGwmenBVw3oBONE4IPhU9MteczhwbYlJ6RfXB77178LB32YJcRLqJxnThJ/dleK/61q2dwMGd9nNkVzsCE7qwY2o6J6IDwwg== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) by PAXPR04MB8272.eurprd04.prod.outlook.com (2603:10a6:102:1c1::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.406.7; Wed, 9 Sep 2026 16:22:41 +0000 Received: from GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c]) by GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c%7]) with mapi id 15.21.0406.005; Wed, 9 Sep 2026 16:22:41 +0000 From: Frank.Li@oss.nxp.com Date: Wed, 09 Sep 2026 12:22:28 -0400 Subject: [PATCH v4 1/4] dmaengine: vchan: add vchan_chan_name() to get channel device name Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260909-dma-chan_dev-rename-v4-1-d8fb6892a70f@nxp.com> References: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> In-Reply-To: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> To: Jacky Huang , Shan-Chun Hung , Vinod Koul , Frank Li , Paul Cercueil , Eugeniy Paltsev , Andy Shevchenko , Binbin Zhou , Patrice Chotard , =?utf-8?q?Am=C3=A9lie_Delaunay?= , Maxime Coquelin , Alexandre Torgue , Steven Rostedt , Masami Hiramatsu , Mathieu Desnoyers , Thierry Reding , Jonathan Hunter , Ludovic Desroches , Viresh Kumar , Keguang Zhang , =?utf-8?q?Andreas_F=C3=A4rber?= , Manivannan Sadhasivam , Daniel Mack , Haojian Zhuang , Robert Jarzmik , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Kelvin Cao , Logan Gunthorpe , Laxman Dewangan , Vignesh Raghavendra Cc: linux-arm-kernel@lists.infradead.org, dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mips@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-trace-kernel@vger.kernel.org, linux-tegra@vger.kernel.org, linux-actions@lists.infradead.org, linux-sunxi@lists.linux.dev, imx@lists.linux.dev, Frank Li X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1788970951; l=3885; i=Frank.Li@nxp.com; s=20240130; h=from:subject:message-id; bh=OFv0LLNCCFn9r7iFKLwYv5wjRFV6X9dhZp6lrtRjCLA=; b=/xbOuV+mCN1vKoP/BCG1Vy3EgbVc7ACsQDNCrhkp9R65ulDxvHpIYeuSBZ6uMYm1Gy7AgCJpo qnKCX+HYESdDGJNgYjGs9wDpHXTOyWL0R9AbDvIZbIvtemNF7XClPPv X-Developer-Key: i=Frank.Li@nxp.com; a=ed25519; pk=I0L1sDUfPxpAkRvPKy7MdauTuSENRq+DnA+G4qcS94Q= X-ClientProxiedBy: PH7P222CA0016.NAMP222.PROD.OUTLOOK.COM (2603:10b6:510:33a::7) To GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV2PR04MB11799:EE_|PAXPR04MB8272:EE_ X-MS-Office365-Filtering-Correlation-Id: fd764aea-98b9-4dba-ab33-08df0e8e926f X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|23010399003|1800799024|19092799006|7416014|376014|366016|10067099003|22082099003|18002099003|11063799006|56012099006|921020|41080700001; X-Microsoft-Antispam-Message-Info: tG9qTh2s1EHkMEn0ultP+cUMK9U9UDRO1N4Kc6LyhXdExsFgZVmKYHlvZU17ghV83E1G4ne0SV5FJWW+nArXb7tujbNWkCrAZl/RbCnAmXV3cMDrDIYZkHE+xBWrM9ZDpS3haT2S3fWS74S1FcKOQbHq0F0+8o5QTgO45srpIm9EmcCHFotdKfWvdGj1x31hY3yD4ICY+jkDp7rzpZ1eNZV5b5vWLjLCV64mIr+tG5ClvcmWKoqg00ZeIlCNYlBdgtbBZhTZ6cn5CHUBTmhxw3+8OIz00tpgXZtIsaLxnTslssrYq6TWRVeI1+zqBKhHUmxfbzFhkYTSCwiNpoHr7lIyl/ztgJa7O8U8gh7lmt0NuiEkH+iDKV73+DHGTbWyPk5pWWw3EJFWw5JG2pHvGHp6CqCjm5tIdTd33CapTxXeLoUi5wOSIwfJgXBSE3emJ9SoUGHsYxdWoNYzLLNCCIcovq3abqPPR5RQbrGdVWEmbYFbionljusIa9tef8/V89T1574fNtOtTE3BTs49pv2LOaotImPfhfH8KuzYAvPVsIrIWYTMid5hT1uTVN5QftOzwVs7LePT9JRH8O3D7q4x0S2SKHVy/5Vy73zJnm1MZfg7cy3n3RGMyj7EWtWSzJ+6p+1pyBV8YLyiU6C4r5SYr+JEb0P1kmELhVcbw60tVoHNxFKycAjiX5pV/jmqBHYUogDaxanxUKDNr+EgFYAZu+90GiO8Iz/fV96PkMuaGMJLmQuZHCASF2IWKfYX X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:GV2PR04MB11799.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(23010399003)(1800799024)(19092799006)(7416014)(376014)(366016)(10067099003)(22082099003)(18002099003)(11063799006)(56012099006)(921020)(41080700001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?YlJ4Ukp0TjhLOGI5SFlFWWNiYUI1dFRaSHVvR21hcEthcUt3ZTVocEluNEM3?= =?utf-8?B?V29JZ0RtUlJKbjU5VFRxc0RHTDVzWDRuOGphZGVBNWRhVWgyUEVzMjdWbzZY?= =?utf-8?B?d2pMUzh2Mk9QdHUwc25FUUQvRmpIck1BVUdoUjJ2Tmgyc0tKQkViUFJFZkxB?= =?utf-8?B?QnlIRG1PbzdHM1VZTFZEejA5MEtkNVVzZS9Ib1ZPbjZVbXZVdS9pTUdNNFlL?= =?utf-8?B?bjRxMnR1cDRhcUo4R0I1b0R4cTY2d0xuSGlnbTZCOVRqMUZLb2JrVGc1V0R3?= =?utf-8?B?bWxJYlMvRTE0ZzdSWlZZelVET2trMVBoYm1Ld3hNTlQyand5MWxIWFdsU1NF?= =?utf-8?B?aVQvZ3pJYy91bGFaT3JVMzZOVEVVdkIybDF2N2t2WXY0OENHamZnNHgwQlFj?= =?utf-8?B?a0ZOTmlpZzB1Sms3RmovVWhSSkhubnhPOFd6ejkxTGVzL3FHMmFySUV4VlF4?= =?utf-8?B?Z1JNdUhWVVBBS05nVmJyZFBVNW4xVmFQWTJTSXBQVWhycVRqaGduWENJR2gx?= =?utf-8?B?aFVLVVBHM2FiMUovZTMrdUdGTWVQVmFqOWw3dFo2Vm9IdklUUUwyOTJTRWVS?= =?utf-8?B?cWJJOWMzU0tVQWtURzVmUWNXdVZaWnB3NXE0WjhVUGlZN1pESTlIclN5b3N2?= =?utf-8?B?OGp2YlY0cElMMkQ0YlpJQXZWdUlEdW1laEVOZCtZQkpEU2F0VjZBUjY1czFp?= =?utf-8?B?OVh4TVJ5WUY4OEp0M3pnUTdodDA2ZUEzNjNmWTNNMFpsQ3pyVGhoL05vMkdr?= =?utf-8?B?UGFiUTBZOTZxSTYxQ0lGelpoZnJzY2haTjczM2VWamFpTU95b0JVTGlqaHV5?= =?utf-8?B?Y0xuRGluYTM5c0ZrZmxvZXdYTUZSSW9BVmI5TStJekptUzJoekNITGtQK04r?= =?utf-8?B?T1JKYk1nTFN2dDIybzc2ckVzRlI5aDJtZTVGeitHVHBxZjZkcjg3NVBUclhy?= =?utf-8?B?MlhWMGlEb0w0WWNHdUtpZnJXNmdMVmIwMlZoNlpaTU1Pbkhvd0JuTWhHYUJm?= =?utf-8?B?YjdFblVkbFdYZllhZGViSVU2a1FIamRHbDJBSElYbTN4MVNnM0UweWFUbi9Q?= =?utf-8?B?YkpCWkFJdzdwcmVBbXBrRWVIZjBtVGd3ZnhjUldKWjZ0TEVPYTIzMXlDK2Q2?= =?utf-8?B?bmdMVkN1RFB2MjV2ajFBejdHWG1PbHZvNGpJbFQrTmdwMWJZWmF2WXZPMVBD?= =?utf-8?B?c3k0TkRIME43K1FqOVRnUGdIR0ZnNWtRYjJVd2QxMjZPeFFVOVVNbldNOHkw?= =?utf-8?B?blRVd0xNL3A3TnRMQW5xc2pEN0lHMmd6TjFaNUh6SjFaZldqc2JZTkgyMXVj?= =?utf-8?B?Vzg0VGR4OEFhUk5kYTBadVlCQUtiNDMvb2pnNnhXQndKQldac283U1BySUJy?= =?utf-8?B?cTRlazJja3YyMEFWdWZDL0w3eVdVdGhxOGxnSEhsRFNPejdvc3p2RVdhRmUw?= =?utf-8?B?VEtJK2N3Sk9BU0tJdk1LTVdvZFJ6VlVmZGRSVGdRUytiZjFBLzZ2bDN6TVpY?= =?utf-8?B?ZlVHRzVCWWVibFIxbnF3ajV0ajB1WHVUVU5ueEU0SEUxWkd3bnhvWk10akYx?= =?utf-8?B?Qi8zWEFFN3pISjg4dXUvOFdMSXFIYngxY2RmZVNUTFY1QldRTUFQVlBiSU5G?= =?utf-8?B?K0pVaWtkdDIxMmM0eW03MWhJcG9yVlJNZWcyYUVvbDFJaDZpZllYbkNJT0lV?= =?utf-8?B?NTdjanY5ZkJMUUx4V1JZM1dlWXJjbTBsZXQ4NzlaNmNVb1E2c0dBam5vWUVm?= =?utf-8?B?dU9mNTFoWVpVQ3cxWmR2dm9kL00rdDBWQWJEamI3cVlYNU9HSFdrVTJ6bCt3?= =?utf-8?B?ZzV4Y3JvNjB1TnhDeWxjbDFudFFWT2c2UWZzT3gyQU1nRHU3cjBSeHdRVkg0?= =?utf-8?B?bHZMalFHTEdkL3NxWFdhWGRUNisrbGxlSWFPSGFDZFErTDV2TGw2cGdBcU91?= =?utf-8?B?dnlNeTdPdi9UWjAvVVNsbGZ3RkRrcDNuMjZYOGUwV1JaUFV3WTA1Ky9QQlkw?= =?utf-8?B?RS9sdDNORmJRRTJKNzlmakhPSHVMekJLcW5teDdZMnlLWDZmYU1MTVczcGE4?= =?utf-8?B?b3pwUkZZVFJTa0RXeUpzeWtYc0lCSEhKTzI2eEkyZVVmTnZvVGhabDdYNUtN?= =?utf-8?B?cktyTmFuNFNOQjcwQ3U4MVFLcFFhZUxtUXZhMUc1OSt4bE5qQjNiQ0lKcm9I?= =?utf-8?B?Qk02Wnk2N1Q3SWZhZ0JMVHNmVDZqcE9ReWN4WmliNDFOa0RhVWU5NEZXSW5F?= =?utf-8?B?U3o3aFRUcStjUlZOaldycHhKd2I1NWVteWYwRHJVays0Z3p5M3h5NE5BM2lY?= =?utf-8?B?RmkzeFREWkxISStEV0gxY29uWkJGalZ1UC80bEpBY0lhZG5QNy96MVJNY3ht?= =?utf-8?Q?k2Tx6gdle32k5xBc=3D?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: fd764aea-98b9-4dba-ab33-08df0e8e926f X-MS-Exchange-CrossTenant-AuthSource: GV2PR04MB11799.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Sep 2026 16:22:41.6984 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: YhPkKfaC1va+EcvvpcB4qKZ4GO0hYrieFTDbNRnEsObkaKSgo/e73QylIuLIug/rNcCcDFSOMlmcUq5Qx+zQdIE2sjLp/O7aZFXlmxc2M7eRcKp21kXoT/sT9LtudtBq X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR04MB8272 From: Frank Li Introduce vchan_chan_name() to obtain the DMA channel device name. Use a dedicated helper instead of directly accessing dma_chan::dev so callers remain unaffected by an upcoming rename of the struct member. Reviewed-by: Logan Gunthorpe Reviewed-by: Amelie Delaunay # For STM32 Reviewed-by: Andy Shevchenko Signed-off-by: Frank Li --- drivers/dma/arm-dma350.c | 2 +- drivers/dma/loongson/loongson2-apb-cmc-dma.c | 2 +- drivers/dma/stm32/stm32-dma.c | 2 +- drivers/dma/stm32/stm32-dma3.c | 4 ++-- drivers/dma/virt-dma.h | 11 +++++++++++ 5 files changed, 16 insertions(+), 5 deletions(-) diff --git a/drivers/dma/arm-dma350.c b/drivers/dma/arm-dma350.c index 09403aca8bb06..52f5242ea3327 100644 --- a/drivers/dma/arm-dma350.c +++ b/drivers/dma/arm-dma350.c @@ -512,7 +512,7 @@ static int d350_alloc_chan_resources(struct dma_chan *c= han) { struct d350_chan *dch =3D to_d350_chan(chan); int ret =3D request_irq(dch->irq, d350_irq, IRQF_SHARED, - dev_name(&dch->vc.chan.dev->device), dch); + vchan_chan_name(&dch->vc), dch); if (!ret) writel_relaxed(CH_INTREN_DONE | CH_INTREN_ERR, dch->base + CH_INTREN); =20 diff --git a/drivers/dma/loongson/loongson2-apb-cmc-dma.c b/drivers/dma/loo= ngson/loongson2-apb-cmc-dma.c index 1c9a542edc859..2f1c8c4fd0654 100644 --- a/drivers/dma/loongson/loongson2-apb-cmc-dma.c +++ b/drivers/dma/loongson/loongson2-apb-cmc-dma.c @@ -678,7 +678,7 @@ static int loongson2_cmc_dma_probe(struct platform_devi= ce *pdev) return lchan->irq; =20 ret =3D devm_request_irq(dev, lchan->irq, loongson2_cmc_dma_chan_irq, IR= QF_SHARED, - dev_name(chan2dev(lchan)), lchan); + vchan_chan_name(&lchan->vchan), lchan); if (ret) return ret; } diff --git a/drivers/dma/stm32/stm32-dma.c b/drivers/dma/stm32/stm32-dma.c index d3ad78562a140..3e8151e2ad75a 100644 --- a/drivers/dma/stm32/stm32-dma.c +++ b/drivers/dma/stm32/stm32-dma.c @@ -1668,7 +1668,7 @@ static int stm32_dma_probe(struct platform_device *pd= ev) =20 ret =3D devm_request_irq(&pdev->dev, chan->irq, stm32_dma_chan_irq, 0, - dev_name(chan2dev(chan)), chan); + vchan_chan_name(&chan->vchan), chan); if (ret) { dev_err(&pdev->dev, "request_irq failed with err %d channel %d\n", diff --git a/drivers/dma/stm32/stm32-dma3.c b/drivers/dma/stm32/stm32-dma3.c index 4724e7fa0008e..1ee1bd22703fb 100644 --- a/drivers/dma/stm32/stm32-dma3.c +++ b/drivers/dma/stm32/stm32-dma3.c @@ -1892,10 +1892,10 @@ static int stm32_dma3_probe(struct platform_device = *pdev) chan->irq =3D ret; =20 ret =3D devm_request_irq(&pdev->dev, chan->irq, stm32_dma3_chan_irq, 0, - dev_name(chan2dev(chan)), chan); + vchan_chan_name(&chan->vchan), chan); if (ret) { dev_err_probe(&pdev->dev, ret, "Failed to request channel %s IRQ\n", - dev_name(chan2dev(chan))); + vchan_chan_name(&chan->vchan)); goto err_clk_disable; } } diff --git a/drivers/dma/virt-dma.h b/drivers/dma/virt-dma.h index 59d9eabc8b674..dd023a3831209 100644 --- a/drivers/dma/virt-dma.h +++ b/drivers/dma/virt-dma.h @@ -209,6 +209,17 @@ static inline void vchan_free_chan_resources(struct vi= rt_dma_chan *vc) vchan_dma_desc_free_list(vc, &head); } =20 +/** + * vchan_chan_name - Return vchan DMA channel device name + * @vc: virtual channel + * + * Return: The name of the DMA channel device + */ +static inline const char *vchan_chan_name(struct virt_dma_chan *vc) +{ + return dma_chan_name(&vc->chan); +} + /** * vchan_synchronize() - synchronize callback execution to the current con= text * @vc: virtual channel to synchronize --=20 2.43.0 From nobody Fri Sep 25 18:24:27 2026 Received: from DU2PR03CU002.outbound.protection.outlook.com (mail-northeuropeazon11011063.outbound.protection.outlook.com [52.101.65.63]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 377FD582B8D; Wed, 9 Sep 2026 16:22:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=52.101.65.63 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970974; cv=fail; b=TL9g5FxhyCh0xC9/fPvye7HGo4vEinxOjzp6rsBkblYwa0rL2KVDWeZ5zDbnDW0GBGaokBuftaeZHfeW4iDoZTMvfEPKaC8OTcbgVTZOTZMCWoPUyAU+pP5K+wiNf/L5qog/SOVi1UDxsHONhjdCvwCEslzUomJKrt4tirqk7pM= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970974; c=relaxed/simple; bh=8Xsdhys+/ZI7muq9HWuoOgjlbFUMaoCLjHdb6P0rGxE=; h=From:Date:Subject:Content-Type:Message-Id:References:In-Reply-To: To:Cc:MIME-Version; b=RFzh41kF6kU20saNLvWBf2k0K0VynUKdi6BDmNXdbFj6MgaxZxGW8P9mHmxOR13jWH5sxJQ2OkNzh9ry3jB0jkj+rx8JXs2Afpl85IsNZgOlcnAsdW8HENHW0MCHJuennIdXEJ+UwNpT8+uss/r4m9mWz2jCr1AiWiN8+f+VwVg= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com; spf=pass smtp.mailfrom=oss.nxp.com; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b=I0mYjxPg; arc=fail smtp.client-ip=52.101.65.63 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="I0mYjxPg" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=FP2mMyFJI2S2lF33SOcd0voYh2YZM8tqKvayC1s1uI89h44ybB83b3cM55oryXJUdGEiW5UmQ0RYfooSpunWDKWuUv9N9glc7nckgH42/JCFDThJTWwUcLfi6bQNJ36HrEAMVnRoJqIfZdtn7VjNYTt+d68ITa0hPZga74P5eyFhOX5Ry0K1haWbfOd/kkonaoAIwBa6HsPhw9sre54l0RQsIfn5jzfZxUb5ij543AjQifzJQX1Ka9FxOXpikVTzcS0j/ZXDQauZ1/ky82rWJZTUZ+uAMNPBJYFsRd82LvgRiCgdifAIj2m1+AMQR6kgkGyGrflsn/vIEY8hWiWnBQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=riJbFukdlYUq9TPuXwu291/bikY5bgBBMl28zlk0YxU=; b=cJPwd4xf8MkmurG8YeYGrVvM9A7IZEprDFe1wAV5xojb6PE2BPXZZ/X6GTcE1wbT87Qqfplf97ubN2n/LMveWHvgGFwYqTpgQwhJGsP8gGzrWEAv/baZxOXWGxoHqajYe36Yvh3oltEZzieNl/oW2mcX+/P/IZEWmBC60rpcuROT6NPz129BjuRHrtO9VXwaVLNcqwXX4kF1RKdaeubDFdmu5CsxRbLEB3VrXamwyNYIs6wsTodkwZFK6JUZp8kpefJHjSaGyvZMb89/6vAr8V7QwjoUoaWfqaK0ZPif2iSel2GtnAb1GhwVm6WfAD/Dm0ZRcJPBUrDenbRBwgiepA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector1-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=riJbFukdlYUq9TPuXwu291/bikY5bgBBMl28zlk0YxU=; b=I0mYjxPgEUvoJ/4uJT6RXnoEdNK0x5WfgqoSdMmaCBkTzBcllnxcP6TY7p9PzzBt7hwFJ7hi8IgGBSG05m45kcn2m+6gqjNyMmf6LSE2oPm2hn82cf7nJU6muu7+BzTgMM2E+SoE6O+Y3yZM9h6qSS6dRpPKTtjCDhuwa3a0OrkntDoyrgLkVK2gWkyf7l5xwsMOxd23wwnKhL81MTvPijWfYIJ/5LhHfuCwwTmwhnTwlWfVk+APRNIYJtDwB20eLoCXkNxxxhGWTMya9E/mMQLFyxz30qv7Rw76lYU/JP2R83DE1dRA84JfqSCFTgWP0t18gUShNK7KV93RGymc5Q== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) by AM0PR04MB6786.eurprd04.prod.outlook.com (2603:10a6:208:184::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.406.7; Wed, 9 Sep 2026 16:22:47 +0000 Received: from GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c]) by GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c%7]) with mapi id 15.21.0406.005; Wed, 9 Sep 2026 16:22:47 +0000 From: Frank.Li@oss.nxp.com Date: Wed, 09 Sep 2026 12:22:29 -0400 Subject: [PATCH v4 2/4] dmaengine: use dma_chan_name() helper to get per-channel device name Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260909-dma-chan_dev-rename-v4-2-d8fb6892a70f@nxp.com> References: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> In-Reply-To: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> To: Jacky Huang , Shan-Chun Hung , Vinod Koul , Frank Li , Paul Cercueil , Eugeniy Paltsev , Andy Shevchenko , Binbin Zhou , Patrice Chotard , =?utf-8?q?Am=C3=A9lie_Delaunay?= , Maxime Coquelin , Alexandre Torgue , Steven Rostedt , Masami Hiramatsu , Mathieu Desnoyers , Thierry Reding , Jonathan Hunter , Ludovic Desroches , Viresh Kumar , Keguang Zhang , =?utf-8?q?Andreas_F=C3=A4rber?= , Manivannan Sadhasivam , Daniel Mack , Haojian Zhuang , Robert Jarzmik , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Kelvin Cao , Logan Gunthorpe , Laxman Dewangan , Vignesh Raghavendra Cc: linux-arm-kernel@lists.infradead.org, dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mips@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-trace-kernel@vger.kernel.org, linux-tegra@vger.kernel.org, linux-actions@lists.infradead.org, linux-sunxi@lists.linux.dev, imx@lists.linux.dev, Frank Li X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1788970951; l=7152; i=Frank.Li@nxp.com; s=20240130; h=from:subject:message-id; bh=kNbx0q8XX8sJ0EnveNvPwTp3PWp8c60u67QnuzKj1v0=; b=ss0So3AaFZNp7xpuLiL1I4qd28Dh7fLStR4suOFL08a+bz8uSjkTiC1qLqZzjcMSy8U09wFAC f3TcGbTnKLcBu4oM+QARad065C/poWAU7jvHXI6U4O3/vP8ul7SWzhP X-Developer-Key: i=Frank.Li@nxp.com; a=ed25519; pk=I0L1sDUfPxpAkRvPKy7MdauTuSENRq+DnA+G4qcS94Q= X-ClientProxiedBy: PH7P222CA0029.NAMP222.PROD.OUTLOOK.COM (2603:10b6:510:33a::31) To GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV2PR04MB11799:EE_|AM0PR04MB6786:EE_ X-MS-Office365-Filtering-Correlation-Id: 78ac09c3-34b2-4302-6a65-08df0e8e95a3 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|7416014|376014|19092799006|366016|23010399003|1800799024|921020|6133799003|10067099003|56012099006|11063799006|22082099003|18002099003|41080700001; X-Microsoft-Antispam-Message-Info: LeenUkqnRnUT8bB8o/6ygeb93dXUyeVP9/nn2j6FSO5aB0iclcPT8zcwd2CZV5RoVDHqO9+zEat3+fss1d6RYPkLo8cjVCXJOris2jwdHjjECIijQoJgys2v97T82uVs1FhwyDaobnHC7ePqz9NhdROP25GOmpd7YLyBAFbS9aAXqHMu1JHAIeSpBxpu/5sdrCfJlYG7CUBJeIT/FvtUTiUI41dchVyBRa2V6TgvmoEln1Huo8unIRrnGbyYb40p0yKuKCMBNnyZvOHV/vd+ed6hT5oWfFvDyzPIRtQye6phA+YangKUmTlqNHk25Z+huUyn1WSZCGN9dKMaw9a3baYEhIflbe+XrO7a7PI5HH4EG6ujjl1+rnyqfR3QnWAgiTmr/ZDWTHrxtOFtETL2immlqI+qfjASKT3bg8DfN62cBonB1vr6baFRY3yaasht8YZdHRKXXbrR/7n9+VFDtYDv3QDLRMbgPc5JlgNA4qKaNDjHDHZH/gGgL9FpL0/yswHXA2ALHhCBPA/BJrXDAQQ4ZnIHlI/IGAKpdI+LX21tmbd2mxYq/51YkpNe3vLfZuGdEze/0wIPRuLZo7S9b6iMd1cAKz9ft5iVhruVOrJm2lwXlghGKQaWFEE7lLGU3rF1ytqCGQqRcN34EdfVOQsSdQ+e8ob+AyXVlUmm0ayY4bWgqrUp59ZpuORwmu0wU6Z9eSSXjCiVHs8v6FZpus2w5Q0ZwL275d83qzeZX+Ax/slW0LFd8ED2N7mQTZl3 X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:GV2PR04MB11799.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(7416014)(376014)(19092799006)(366016)(23010399003)(1800799024)(921020)(6133799003)(10067099003)(56012099006)(11063799006)(22082099003)(18002099003)(41080700001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?anlLVXdUVEs1NWFkMmF4bmtCNDZvUGFBai83UFVoSnhUR05CcGhCaDBQVmJL?= =?utf-8?B?clJuZTlVbTBDb2UyL0tocmMwTWQ4YktxWEFRelFrUWdKT1lPemtodDFhZlJZ?= =?utf-8?B?Tkk2T0tWWWF6UmRmWTlzSVMwem1UMW1jRjNsdGlvZzR0M0p3Q3BvaE8yQ0lC?= =?utf-8?B?ZFp6ckgycllsUTJ1UGtnL01maDJJTnhVMjZjVFlZR1RHbUd5MXZidUt4UjlN?= =?utf-8?B?UzV3YmpReHhYbTlPOWFrMCtpMFIyV3lwalFudkx5bUZIQ2NBcnpheERaV2FQ?= =?utf-8?B?WXc4ZklDRFFKN042SkErUU4xdWt3Nk8zS1YvVVZLQUdVT2ZlSG53NS9kVTBy?= =?utf-8?B?L2dKQWpKRWlabTlkNVM2VERXd1ArMWdTd1FXUi9GTlZZK3RkcTZCamk1NjJS?= =?utf-8?B?V0dlVFNqaFppQUJKTmhFRkFnaEdMYlBCTzQ3Q3g5bFRRd1lhekNEUnNtNkN2?= =?utf-8?B?TWltOTlic00xWk04V0V2ZjhOVGxyVWdiMktjcWtUM29MYlpqbGlFL05pQjNx?= =?utf-8?B?QVNIOE1SYWRkSTdXZ3ZpamlMam9lOXNTYTJVZU1GOVRtdVNHdlF2a3pueFBO?= =?utf-8?B?RmtXemh0NkRMWW9zQVQwaGR1TkkzY1l1ek5wV1I5Z0JRajAxY3VyUjNUY1lT?= =?utf-8?B?ZGtQd2I4VjNna3huNURCNjZ5VmJ2V00rdVg5Qnk1aW1GMzUrbmoxc21uU1kx?= =?utf-8?B?LzA3NmU3NU1LeXN6L0x2ZGg4SnFsWWxacm5nVC8zK0lqYk9YTFNaOW9Oa2t6?= =?utf-8?B?QzBaSFBYc2pxaGludlNGVjdWQ2I4N0x6L2NNbkxsQmdBSEozZXp4Nmtma0dX?= =?utf-8?B?UnVBM2V4clpoRHRBS0RSQm9zSjZVOEMwb3hUQ1RWNk1SckNqS3lpQUdpOWhL?= =?utf-8?B?ZERxUTBrVTQwMlpYeTNBaGdMcHg3R0pkVEZCQlFMU2NsaU8xb2ZqL2x5UTBj?= =?utf-8?B?R3ZWV3JEakNscXBBRXBSdWhPK1NKQlZmMHJZb3FOQzZtbkYwZ3NCeUc4aElv?= =?utf-8?B?VW00T1Y2SDlBMlRLdWJJY0NsRkgxUEVOMGJ4cXJyaUNJd254bnBsMFhBdVp3?= =?utf-8?B?Z0h3RlBQSWpMZDZmWlo3cXU0aEU2M2FzeGJ4dWNVZkF5NHREbVZCWGJyaTI5?= =?utf-8?B?V0hRZldBemtGN0o3R0VqRFc4QnR0SmtKZ3ZRV0FUTlZJZHU4TEdSK0lpMnNN?= =?utf-8?B?a0tJUWxIS3FaOXhEWXFOKy9OOENRL2hMaEZVZjNEdjczdW1CL01rTlY1d3kx?= =?utf-8?B?YnB0M3dYSDFuOFl2YXV3RUtmT3VXSXBjWWNmTnNhVVdZSjFNWkRxeCszVWli?= =?utf-8?B?VS84UlpHeVJjSnFPeTBWOFpKc0ZBL3dGMjQvOGdNQWs3VERqelhaUWJMQnlE?= =?utf-8?B?SVZrNGpyNy96SnBtR3p1N1NrYWlPYmJiRDlNQ2FxdE9oT3Jsa2thRjc5c002?= =?utf-8?B?aTBLVWVpZm5mdS95cm92MGdtNm9OVlpsV1NjQm9rU3B6ZjJCTjhjaCt4ZWZw?= =?utf-8?B?MHZFMjMzNmR1RXcrVlJRUzIxOTQ3ZGRoTGloRkJLVW02b1RoaHB4MjAxOUVZ?= =?utf-8?B?aFQwK1RpN3gxaHFwSE5uNEExVTBsZmZUZU5YcUU2RGc0dlRZcUJFaVM2OUdH?= =?utf-8?B?d1FsUEl5N0xjd2luQ2R2eStpcHJYZXcyMDk1WlBCc1E5L1ZVM1VlMWZpNnRN?= =?utf-8?B?ZGZ2RjVQZGxVUVNFT25CLytIOW5iMjEzQUtrbGd2OFpaNEY5SzRvT254OXNv?= =?utf-8?B?R0p5WWtCYnBCZFJYZDU5WkNwcnJhV0F1aU5iNEI0emRoVTRxR20wTHpOUHF1?= =?utf-8?B?ZytKQ3lieG9nZTR0d0ExeUpUeWFZdDhoSDJLVDRIMGtSOXVpcEZxT3F6Z3dK?= =?utf-8?B?akt2QkJYVkcwL3paZCs1QTN0Yllza0NyeDRlZzdBZWttakVKVEozNmVWMzA0?= =?utf-8?B?M3c4bWZDSCsyb1g0U3IyZ2dUc2tuVnJjNng1RFJXUVpJcEQvZG5rNHBTWDZC?= =?utf-8?B?akFraTFDSGpMOUxHY0RWMkdFTm9yNmJDY0JRSEQyQkVFWjRueXk3TjBwMGxt?= =?utf-8?B?VWpQWXlJaHBoUDlZdEZXbngveDhTc0d6R0VOZUpjdWcwdnB1VUMwdGplWmla?= =?utf-8?B?NUpic2xXdnRLaDlMZkpTRzRYa0hrckpoY1ZTYXQ0d1JJdjFtc2FnSVJVVmhk?= =?utf-8?B?SEpZbUhaNWNjVi9UUWdGamV5QjNMcmxTb2ZBdFp5MmlORld6OUtYRDFPUVps?= =?utf-8?B?Wm1IWnFPclhRZlplKzRmNGxBTzR4NDc4RVpTVU1iS1YwcVp5WDN0SHEzTDly?= =?utf-8?B?N29Zc2UvVmE4QVkyMFlNNXNoOEVJTTgzZnBZZWlzVWRUUk1HOW5HNk1tV05P?= =?utf-8?Q?wv7bl12TJ+D6Gkis=3D?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 78ac09c3-34b2-4302-6a65-08df0e8e95a3 X-MS-Exchange-CrossTenant-AuthSource: GV2PR04MB11799.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Sep 2026 16:22:47.0984 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: F55Gk3gg3epOp9QNabFyr+rz2fUfi9SJuwUzOlz7BBBPEIHl4xkUTpJGXpgIklZbrogVxvYvRFcAH53qxg9EGEttCNq4jYP6q7vwyAW1FwtDLIbxDJS/wUVdkgexms+8 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR04MB6786 From: Frank Li Use the existing dma_chan_name() helper to obtain the per-channel device name instead of open-coding: dev_name(chan->dev->device) / dev_name(chan2dev()). Simplify the code, improve consistency and reduce line wrapping where possible. No functional change intended. Reviewed-by: Logan Gunthorpe Reviewed-by: Amelie Delaunay # For STM32 Reviewed-by: Andy Shevchenko Signed-off-by: Frank Li --- drivers/dma/dma-jz4780.c | 2 +- drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c | 3 +-- drivers/dma/idma64.c | 3 +-- drivers/dma/loongson/loongson2-apb-dma.c | 2 +- drivers/dma/mmp_pdma.c | 3 +-- drivers/dma/st_fdma.c | 2 +- drivers/dma/stm32/stm32-dma3.c | 2 +- drivers/dma/stm32/stm32-mdma.c | 3 +-- include/trace/events/tegra_apb_dma.h | 6 +++--- 9 files changed, 11 insertions(+), 15 deletions(-) diff --git a/drivers/dma/dma-jz4780.c b/drivers/dma/dma-jz4780.c index 6070dfdb7114c..194649811d02b 100644 --- a/drivers/dma/dma-jz4780.c +++ b/drivers/dma/dma-jz4780.c @@ -760,7 +760,7 @@ static int jz4780_dma_alloc_chan_resources(struct dma_c= han *chan) { struct jz4780_dma_chan *jzchan =3D to_jz4780_dma_chan(chan); =20 - jzchan->desc_pool =3D dma_pool_create(dev_name(&chan->dev->device), + jzchan->desc_pool =3D dma_pool_create(dma_chan_name(chan), chan->device->dev, JZ_DMA_DESC_BLOCK_SIZE, PAGE_SIZE, 0); diff --git a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c b/drivers/dma/d= w-axi-dmac/dw-axi-dmac-platform.c index 9c21a5479437d..a36b066c3c33c 100644 --- a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c +++ b/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c @@ -531,8 +531,7 @@ static int dma_chan_alloc_chan_resources(struct dma_cha= n *dchan) } =20 /* LLI address must be aligned to a 64-byte boundary */ - chan->desc_pool =3D dma_pool_create(dev_name(chan2dev(chan)), - chan->chip->dev, + chan->desc_pool =3D dma_pool_create(dma_chan_name(dchan), chan->chip->dev, sizeof(struct axi_dma_lli), 64, 0); if (!chan->desc_pool) { diff --git a/drivers/dma/idma64.c b/drivers/dma/idma64.c index 5fcd1befc92da..e1fcce07d1c10 100644 --- a/drivers/dma/idma64.c +++ b/drivers/dma/idma64.c @@ -507,8 +507,7 @@ static int idma64_alloc_chan_resources(struct dma_chan = *chan) struct idma64_chan *idma64c =3D to_idma64_chan(chan); =20 /* Create a pool of consistent memory blocks for hardware descriptors */ - idma64c->pool =3D dma_pool_create(dev_name(chan2dev(chan)), - chan->device->dev, + idma64c->pool =3D dma_pool_create(dma_chan_name(chan), chan->device->dev, sizeof(struct idma64_lli), 8, 0); if (!idma64c->pool) { dev_err(chan2dev(chan), "No memory for descriptors\n"); diff --git a/drivers/dma/loongson/loongson2-apb-dma.c b/drivers/dma/loongso= n/loongson2-apb-dma.c index aceb069e71fca..7c3d7c3273955 100644 --- a/drivers/dma/loongson/loongson2-apb-dma.c +++ b/drivers/dma/loongson/loongson2-apb-dma.c @@ -282,7 +282,7 @@ static int ls2x_dma_alloc_chan_resources(struct dma_cha= n *chan) struct ls2x_dma_chan *lchan =3D to_ldma_chan(chan); =20 /* Create a pool of consistent memory blocks for hardware descriptors */ - lchan->pool =3D dma_pool_create(dev_name(chan2dev(chan)), + lchan->pool =3D dma_pool_create(dma_chan_name(chan), chan->device->dev, PAGE_SIZE, __alignof__(struct ls2x_dma_hw_desc), 0); if (!lchan->pool) { diff --git a/drivers/dma/mmp_pdma.c b/drivers/dma/mmp_pdma.c index 386e85cd4882a..863160de3b7d5 100644 --- a/drivers/dma/mmp_pdma.c +++ b/drivers/dma/mmp_pdma.c @@ -565,8 +565,7 @@ static int mmp_pdma_alloc_chan_resources(struct dma_cha= n *dchan) if (chan->desc_pool) return 1; =20 - chan->desc_pool =3D dma_pool_create(dev_name(&dchan->dev->device), - chan->dev, + chan->desc_pool =3D dma_pool_create(dma_chan_name(dchan), chan->dev, sizeof(struct mmp_pdma_desc_sw), __alignof__(struct mmp_pdma_desc_sw), 0); diff --git a/drivers/dma/st_fdma.c b/drivers/dma/st_fdma.c index d9547017f3bd6..35dbff5f9f1ab 100644 --- a/drivers/dma/st_fdma.c +++ b/drivers/dma/st_fdma.c @@ -268,7 +268,7 @@ static int st_fdma_alloc_chan_res(struct dma_chan *chan) struct st_fdma_chan *fchan =3D to_st_fdma_chan(chan); =20 /* Create the dma pool for descriptor allocation */ - fchan->node_pool =3D dma_pool_create(dev_name(&chan->dev->device), + fchan->node_pool =3D dma_pool_create(dma_chan_name(chan), fchan->fdev->dev, sizeof(struct st_fdma_hw_node), __alignof__(struct st_fdma_hw_node), diff --git a/drivers/dma/stm32/stm32-dma3.c b/drivers/dma/stm32/stm32-dma3.c index 1ee1bd22703fb..6ee7a1435efb6 100644 --- a/drivers/dma/stm32/stm32-dma3.c +++ b/drivers/dma/stm32/stm32-dma3.c @@ -1126,7 +1126,7 @@ static int stm32_dma3_alloc_chan_resources(struct dma= _chan *c) goto err_put_sync; } =20 - chan->lli_pool =3D dmam_pool_create(dev_name(&c->dev->device), c->device-= >dev, + chan->lli_pool =3D dmam_pool_create(dma_chan_name(c), c->device->dev, sizeof(struct stm32_dma3_hwdesc), __alignof__(struct stm32_dma3_hwdesc), SZ_64K); if (!chan->lli_pool) { diff --git a/drivers/dma/stm32/stm32-mdma.c b/drivers/dma/stm32/stm32-mdma.c index e3bbdc9ee36ed..c6dc8a9a7a288 100644 --- a/drivers/dma/stm32/stm32-mdma.c +++ b/drivers/dma/stm32/stm32-mdma.c @@ -1484,8 +1484,7 @@ static int stm32_mdma_alloc_chan_resources(struct dma= _chan *c) struct stm32_mdma_device *dmadev =3D stm32_mdma_get_dev(chan); int ret; =20 - chan->desc_pool =3D dmam_pool_create(dev_name(&c->dev->device), - c->device->dev, + chan->desc_pool =3D dmam_pool_create(dma_chan_name(c), c->device->dev, sizeof(struct stm32_mdma_hwdesc), __alignof__(struct stm32_mdma_hwdesc), 0); diff --git a/include/trace/events/tegra_apb_dma.h b/include/trace/events/te= gra_apb_dma.h index 6d9f5075baa3e..c38117c127ef3 100644 --- a/include/trace/events/tegra_apb_dma.h +++ b/include/trace/events/tegra_apb_dma.h @@ -11,7 +11,7 @@ TRACE_EVENT(tegra_dma_tx_status, TP_PROTO(struct dma_chan *dc, dma_cookie_t cookie, struct dma_tx_state *s= tate), TP_ARGS(dc, cookie, state), TP_STRUCT__entry( - __string(chan, dev_name(&dc->dev->device)) + __string(chan, dma_chan_name(dc)) __field(dma_cookie_t, cookie) __field(__u32, residue) ), @@ -28,7 +28,7 @@ TRACE_EVENT(tegra_dma_complete_cb, TP_PROTO(struct dma_chan *dc, int count, void *ptr), TP_ARGS(dc, count, ptr), TP_STRUCT__entry( - __string(chan, dev_name(&dc->dev->device)) + __string(chan, dma_chan_name(dc)) __field(int, count) __field(void *, ptr) ), @@ -45,7 +45,7 @@ TRACE_EVENT(tegra_dma_isr, TP_PROTO(struct dma_chan *dc, int irq), TP_ARGS(dc, irq), TP_STRUCT__entry( - __string(chan, dev_name(&dc->dev->device)) + __string(chan, dma_chan_name(dc)) __field(int, irq) ), TP_fast_assign( --=20 2.43.0 From nobody Fri Sep 25 18:24:27 2026 Received: from AM0PR02CU008.outbound.protection.outlook.com (mail-westeuropeazon11013070.outbound.protection.outlook.com [52.101.72.70]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 55ECE582BA2; Wed, 9 Sep 2026 16:22:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=52.101.72.70 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970985; cv=fail; b=RWRC6ek30mr18IGxEOlHzRRWnnwC44ASegfUQfvg+mQhnpVHc+tWDn9+Tiugv0YF60neGkuC0k8yVTQrO9L+hY/a9C4tWxlbpBu/8UsBWpo5ww1EzouXFqEzFEPim/qYSSgMieKt/dJl46twwEQU5AlXbK4giiWqtD8TZDW+P6E= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970985; c=relaxed/simple; bh=px9TNhLJee67q4928tK76Zcc4AHjWLKdLSrvxqKM9rk=; h=From:Date:Subject:Content-Type:Message-Id:References:In-Reply-To: To:Cc:MIME-Version; b=PSueoaJfabXgzhmNYB8qOqe6fbdrzUforO6Olo6rn4h8U7u25P3oOoUk79qDbR2a3rYWrSFiODpm+EEANb1wNW3lgI1OifCN6JwAI5JKGvq6P9FXcat5qRLTXFUTppIc0e027efLj6CP/RozvtV47UmQa6VuwhKJeu1tUTwcPHE= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com; spf=pass smtp.mailfrom=oss.nxp.com; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b=JjGvQNm8; arc=fail smtp.client-ip=52.101.72.70 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="JjGvQNm8" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=lmXQjuAaLMu7yZIheLfTZJIf/JRnAddIO0thUeee/JIAHexV6JWKLi5ZNjBnGK8BV8LlI15w9Tz166m+/8f8gqY9kIbsDKzLQKIJTB+Ykrq+MhmdxVOPC79WUbAf8NkFkBE9yRd/W0MCigjFho+LrgbtWtTbfvstZIwDItXq0vUfjWium4/VhYF2Y9B8h8PZZqHna3jCasLi5UICYtS00KHmAyv4oiE577OuYTsX949T+1Ef85N6p0rgMbZgGrrALFzGTFPahIFD6gqtCDQXk42rmQCSToIggflqd4LIpZ3rYvh628gwgBC7qyAFy+NkhulV5V+/Ou3emVXWqhc6zg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=bD3VuV8PSqNCW6q1gda7/sLhQreEjh9RKnDiVYhvKdo=; b=HuikEaJ5+NqC9vkdlP3a493sK2u0hly0h73by0yzyMoG/HC1RmyAlMYBDbuySVjoMr7C74ISuU92jeUQ9tAJTs4LGvLBnQxGAuGQUh9mvSQ4ut8JBHWDaaVUpuq8AY30Fpkm/VH/B7DCBAzCMinN+aHQjAwbVuzciuNIeLR904mOYVf8s21StmlvJzBG2Q9xs8sGrNUFzqJBaMtUiCvQ62nnVJnh0fM6Z5SxSnFU1w8w4p807H8yOzaQmNd2uP0Hmennh+DK/2hViD4YSv+Z26y7TwHvg2Nh7TRiPQWeuM8Vj244kRwuau9KSrwoW4Ygh/2cXYIPfVyazzO2cOLmTg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector1-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=bD3VuV8PSqNCW6q1gda7/sLhQreEjh9RKnDiVYhvKdo=; b=JjGvQNm8GnfTZyQauuTTPry1Kg7sKVUjKmhEgv1aAE4mr5n0QzE7AXFW59PjC3ljIj8v2coHHCccqXproNmozpg//6ngtn6RiCPwPuYyHy5hiXaWRFZ2OMYRD5tR0nQDsrzGdSMpZF90IdB4v0Z8hPcoRbiZ6AugqYwz9ZcIxHAAg87sqXomgKf0ZYqFJQWTadUR/TId3DzJ34l56hN3EZnfsr8ZHiqyqhVR6Dsu0T184aKfu0aWrenbFJ7kuYMTbohIxkt0wbkFoMTXZSO+KOAzZB27E46fi5tfwH/BnmOZRwNoZf7p7BFiSrzJ+H5cyS3W4VCu//qxkznxE17+fg== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) by AM0PR04MB6786.eurprd04.prod.outlook.com (2603:10a6:208:184::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.406.7; Wed, 9 Sep 2026 16:22:53 +0000 Received: from GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c]) by GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c%7]) with mapi id 15.21.0406.005; Wed, 9 Sep 2026 16:22:53 +0000 From: Frank.Li@oss.nxp.com Date: Wed, 09 Sep 2026 12:22:30 -0400 Subject: [PATCH v4 3/4] dmaengine: add (dmaengine|vchan)_chan_dev() helper Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260909-dma-chan_dev-rename-v4-3-d8fb6892a70f@nxp.com> References: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> In-Reply-To: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> To: Jacky Huang , Shan-Chun Hung , Vinod Koul , Frank Li , Paul Cercueil , Eugeniy Paltsev , Andy Shevchenko , Binbin Zhou , Patrice Chotard , =?utf-8?q?Am=C3=A9lie_Delaunay?= , Maxime Coquelin , Alexandre Torgue , Steven Rostedt , Masami Hiramatsu , Mathieu Desnoyers , Thierry Reding , Jonathan Hunter , Ludovic Desroches , Viresh Kumar , Keguang Zhang , =?utf-8?q?Andreas_F=C3=A4rber?= , Manivannan Sadhasivam , Daniel Mack , Haojian Zhuang , Robert Jarzmik , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Kelvin Cao , Logan Gunthorpe , Laxman Dewangan , Vignesh Raghavendra Cc: linux-arm-kernel@lists.infradead.org, dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mips@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-trace-kernel@vger.kernel.org, linux-tegra@vger.kernel.org, linux-actions@lists.infradead.org, linux-sunxi@lists.linux.dev, imx@lists.linux.dev, Frank Li X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1788970951; l=166390; i=Frank.Li@nxp.com; s=20240130; h=from:subject:message-id; bh=NeYBiUVs0Vuo4fgyczBfo2CbhYZkt/8RMsCu9MsWOJQ=; b=1cLMyuOzP82u/fJzxMMiaU2LtU8+sCLvq83RoMvmkoEa+OH6PqufFZUER1lS1BqgFWa9S+lha unjDSc4WC/XCz3+GHVOFwThuZUoqU2om8QWX20LzbJsJYk1uCIzXJ5r X-Developer-Key: i=Frank.Li@nxp.com; a=ed25519; pk=I0L1sDUfPxpAkRvPKy7MdauTuSENRq+DnA+G4qcS94Q= X-ClientProxiedBy: PH3PEPF000040A3.namprd05.prod.outlook.com (2603:10b6:518:1::57) To GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV2PR04MB11799:EE_|AM0PR04MB6786:EE_ X-MS-Office365-Filtering-Correlation-Id: dba944ea-72ef-41b1-b4e5-08df0e8e98f1 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|7416014|376014|19092799006|366016|23010399003|1800799024|921020|6133799003|3023799007|10067099003|5023799004|56012099006|11063799006|22082099003|18002099003|41080700001; X-Microsoft-Antispam-Message-Info: +UQtOwBe4vxWS2Cgr/aquPaEHwWxEQhsBeYVSWCOaHyxsd7NuS6PA6Vsl/PzNd5Y2UT469uH+j9LhSjU0d1Ndpbph3WWyUAmZVzLn0cIyY3hUN+AkyvbewcaLrb4uETs24Z6g5UZXtMF1dACjwwYPgd+H9xZnH+6TGNvvR5x/2ixKD/rZ/m8i4O9RCi5Qjx4xKCl8laFG9mZwS9e6BbcW6wxlgUODAUHwGEdoTCxAxXymA1xsm+Qd4xxfHUNPlTJIXL9Af0UjFaW+vV1q4JYVicF/McGX7g3s0XkcmcfT2bxKmYbkcPkjco+APWM9NvGaHED7Vm1jivvcK0ggDOfhvfEKKHHGlxChdd8dpNKczJRrEkaAguam8sSbrmP8jz3UtxM5z2+i6vBcktW6qm8odv7qQCjdj/xg3DseTv4QoTPTNi6xmS057UJ2pX7SZM5odE3/jVvDmTfhvoSkCviQm19Mw0ezXKVs1pL5/ZQRxrhK/QjF/DTAD6TTKsvazgsW0NBbnu79ck5JQ3mNCpFOL7iLZDnLG8MlneQgQMYnKvU9cLwGYJvPqqtgrOvHZxSC/61oAX9RynxdAhTXz7/m9yqjeQQkjtU80mH+/1cebces0DpNiIPUFGZHW4jno/SSdY5pK8gahkSaE5vzn3YDm8DaPwWwCKLG8c7kPHjz6pim1Zskzzdkikhswzo7YasfA/j4yi9zj6cmvpdi9wEt/nf/q7yQnNEQl9pVJOfdtg= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:GV2PR04MB11799.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(7416014)(376014)(19092799006)(366016)(23010399003)(1800799024)(921020)(6133799003)(3023799007)(10067099003)(5023799004)(56012099006)(11063799006)(22082099003)(18002099003)(41080700001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?Qm44eGxUeFFiRHRCTy9tMTlxY3UvZDE3Y09JK1Y5OFVBc3hwNHBQZHh5Wndw?= =?utf-8?B?OFJ3eHRzMnNuOG1TcHQ3bWEycW5yMHg2WkFpZVUxNmRoVFpJeWRNK3RQelBL?= =?utf-8?B?eGhwaEZxVFRFUUxIVzVvZTRpR1ZSR2t3OS9MeUlpVmZYMDY2RXR1bG5jSEZP?= =?utf-8?B?MHM0OFZVYTBSY3U3VXRzb2oycjBCdXdhNWJQU1ZJZTN0czd1NWhSSXNXazAw?= =?utf-8?B?VkRYM21iWGpaMUtieG9jT0RTNDRXOVlkTVZzaGRkc0Z5RzVyS25Fb2tGVnJS?= =?utf-8?B?RWJuNEptVEoySG9vVzAzMTVpb1lUUDFwY0hzN2U4cDh1c3ZwRHhtRGF2QXc4?= =?utf-8?B?akVpc0xlYjNiMWltV0dzSmJPSVlReU1RT3lTcENHRDZuUFlZRmFWMlFHWmhZ?= =?utf-8?B?Y2I0cGlqRExleHkxTnNJaUNBa0Q3dVY4YVFPTkFPR1V2b2F1TkpVMFZVOE4v?= =?utf-8?B?ZEZQTmVHNXBPRU5qUVZleXR2Ulh5MFZRT3FuaWxhaVMxT2xBaXFtaUFHblg2?= =?utf-8?B?cFZhLzVYcUVuemVRNjJ6MG9CU1BsdGxBVGxMVTl1bUszWEpiWkdLZndGSTBj?= =?utf-8?B?MDdNVUdtWVlBVVViQ0p3ZGJiQzIzZGErT09Yb1plVW1Ua1ZhMkpoSHJkWFNr?= =?utf-8?B?OE9JTWVTT09vWTZid2NaZXFnU1ZCNFFtd2NJV3ZPek9LdjM0d0pKeW1YSWhW?= =?utf-8?B?M3Azdmw4Zzlncm1ncEJYQWQxWStEcWhqeGlmbDBtNjkyYmFYNXhoWEdhMHZC?= =?utf-8?B?NHdsQ1BrZy9Ba3drYjZ4Ly9Bdm9CSFpwYWkrcDJVNnlUOWZPdEVuWlpodXdP?= =?utf-8?B?NkQwem1YdXBOcXBRdk54TUlqRVFCSnJJYWxTZWpaZUR0ZWV2MVlpM2pDQUlU?= =?utf-8?B?T2hybCtzSm1PT21FZkNUVVE5SFdUaEhyc0o2cktlTjhmRjQ3OEdyT3pld1Na?= =?utf-8?B?eG52YUg3T1JKUm01SDB3dlB2TDZnc0JkMjZURGJ4L2tlM2twNlh4WVl2Q3o2?= =?utf-8?B?cUFEWUNQZXFNUzFiUktVeTJabzlBN2xkdmlkZjZZaFE5dkhJd2l6OENHdG56?= =?utf-8?B?WDg5c0JwWmc1NmFGVzJycThNeTNmOHcyQ0xzQjNtanB1T1pNV1p1VFhGWHVz?= =?utf-8?B?bUNMa21rcEh1WlRaV3FFZi9aaU4ybHZhRlRGdkpCTFovYlpuVG53aVJTdUNw?= =?utf-8?B?dlRGMkREbnJNbXlaWWtHdG85ZUxKb01ZdkNzN21QZ1hEWW9WWCsvc29sTGxQ?= =?utf-8?B?WXJWZGs3QXZDcmVSejFleVYxbkdYVjhHWU92dWxmWlo4eFBBKzdBREVqUGds?= =?utf-8?B?WXF6UjZYWUNuYlBNYjBrS0k2T25Fc0dWRHVPdzdZZWVGNFhIQzhOL1VvZHhr?= =?utf-8?B?OGJzbVAyTVZsTFcrek9jMFZheVN2QnFmSVYxa3B1amN1cCs0UzdUTjgrNlpk?= =?utf-8?B?cFM2dWxnY2FVSkVPa1I1Q3o1RE9IUThkeE5MM20wcHdScDBsREJMVkFzaGhl?= =?utf-8?B?SFdDNU5KcnpvYVRDeXpVWHYwM0JVd29Ldk5YRWxFTWw1YmNKVzdJdFV4MnVJ?= =?utf-8?B?dFJHRG5NMXhzTU1tK0NRV1JlL2NGSWJLRk4xMFNFd2RwcnF0KzhBT2FCaWY3?= =?utf-8?B?SWtJZ3BYc0hsenFNd29UVEZSUHh0RjhxY3p2VzNWVHlQVDFPMldPTzgzOHpq?= =?utf-8?B?aHJ0ckdjZ0RuWmFxZkZmNzVaM2dxb000ZVRJbUZCZmZ3dFVqcS92b3JYazBz?= =?utf-8?B?SHdBQVJjdzhWOEFhZklKN2JCT1ZYU2VDZnhoZ05CaEpLQVEzMDNneUlCMlpv?= =?utf-8?B?WC9LZ09UVmZWaExUaDdlNFVsK1cwNUdLdDNmNDhUNWJpTDlSdlpveUk3TUpr?= =?utf-8?B?KzA0UkZFU01nM3VHSDdDZklRQ0QwVEpVc2xpS3Q3TjNIUDNuVHRmUXNSSzVq?= =?utf-8?B?TzhwYmN3ODB5cVJUZjhCeHYvalZwWUN5M2VHOE02Q3d0MlNMTy9LTW5pMno1?= =?utf-8?B?c1Z0Wnk5Z0ZxMWFadHk3VXREbHR1Ukt4MUhCeU0vb3dVWWVXeGs5KzRkZUgv?= =?utf-8?B?b3VWWUJuQnBmL04rVjQvNzV2akhxMVBPY1YvOUx0aGVQTkpLaFUyMzdsaUNx?= =?utf-8?B?cWgwVHBwdkkvNmN5OVpONFNhU1ExT2Z0cCszSUlmaFNSWXl5aGxHT3ByNXVY?= =?utf-8?B?MmlDR0V4SWRvTmNoZXdsWWxlckNxdGNxV0M0YjdRMHZ1NWhnVUx0bkhDWnI5?= =?utf-8?B?eCs2dTZOUkxvNGtDTEMwbTlzenpQSkhQNWJsK0NBMVNwckZQS2xxa2pkckFH?= =?utf-8?B?b1dycHB1a2Q1WmxrSmFQOXVrdVpMazAvVGJ5MWp1em9DV25JemVSWDNBWEFw?= =?utf-8?Q?Zulod8g/RH6xm8k02RZgcaFEkYkT7T8N/6eN4?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: dba944ea-72ef-41b1-b4e5-08df0e8e98f1 X-MS-Exchange-CrossTenant-AuthSource: GV2PR04MB11799.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Sep 2026 16:22:53.1380 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 5OL/yZh9vtDiCIJ/D+6Br3kItYaFVAtIXlSGp9O3LXRDoXBuPx/02edNqj8ZJrEfQyhtCqvOM+j0X+iKRqslz8sVEKlfIdbERqgji8rP7Zm+g8OjkflkvZkYDoFUHoY7 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR04MB6786 From: Frank Li Add a new helper function (dmaengine|vchan)_chan_dev() to access the DMA channel device embedded in struct dma_chan_dev (chan->dev->device). This provides a cleaner API instead of open-coding &chan->dev->device throughout the drivers. Replay private chan2dev() and dchan2dev() with this new common APIs in indivial DMA engine drivers. Prepare rename dma_chan::dev field. Reviewed-by: Andy Shevchenko Signed-off-by: Frank Li --- drivers/dma/at_hdmac.c | 81 ++++++------- drivers/dma/at_xdmac.c | 159 ++++++++++++---------= ---- drivers/dma/dma-jz4780.c | 8 +- drivers/dma/dmaengine.c | 20 ++-- drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c | 36 +++--- drivers/dma/dw-axi-dmac/dw-axi-dmac.h | 10 -- drivers/dma/dw/core.c | 47 ++++---- drivers/dma/ep93xx_dma.c | 37 +++--- drivers/dma/idma64.c | 7 +- drivers/dma/loongson/loongson1-apb-dma.c | 23 ++-- drivers/dma/loongson/loongson2-apb-cmc-dma.c | 15 +-- drivers/dma/loongson/loongson2-apb-dma.c | 7 +- drivers/dma/moxart-dma.c | 23 ++-- drivers/dma/nbpfaxi.c | 2 +- drivers/dma/owl-dma.c | 21 ++-- drivers/dma/pch_dma.c | 41 +++---- drivers/dma/pxa_dma.c | 52 ++++---- drivers/dma/ste_dma40.c | 15 +-- drivers/dma/stm32/stm32-dma.c | 67 +++++------ drivers/dma/stm32/stm32-dma3.c | 93 +++++++-------- drivers/dma/stm32/stm32-mdma.c | 93 +++++++-------- drivers/dma/sun4i-dma.c | 17 +-- drivers/dma/sun6i-dma.c | 31 ++--- drivers/dma/switchtec_dma.c | 14 +-- drivers/dma/tegra186-gpc-dma.c | 2 +- drivers/dma/tegra20-apb-dma.c | 2 +- drivers/dma/ti/k3-udma.c | 2 +- drivers/dma/timb_dma.c | 63 +++++----- drivers/dma/txx9dmac.c | 73 ++++++------ drivers/dma/virt-dma.h | 5 + include/linux/dmaengine.h | 7 +- 31 files changed, 489 insertions(+), 584 deletions(-) diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c index f4d0c72787d13..9991452286850 100644 --- a/drivers/dma/at_hdmac.c +++ b/drivers/dma/at_hdmac.c @@ -381,23 +381,18 @@ static inline struct at_dma *to_at_dma(struct dma_dev= ice *ddev) =20 /*-- Helper functions ------------------------------------------------*/ =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - #if defined(VERBOSE_DEBUG) static void vdbg_dump_regs(struct at_dma_chan *atchan) { struct at_dma *atdma =3D to_at_dma(atchan->vc.chan.device); =20 - dev_err(chan2dev(&atchan->vc.chan), + dev_err(vchan_chan_dev(&atchan->vc), " channel %d : imr =3D 0x%x, chsr =3D 0x%x\n", atchan->vc.chan.chan_id, dma_readl(atdma, EBCIMR), dma_readl(atdma, CHSR)); =20 - dev_err(chan2dev(&atchan->vc.chan), + dev_err(vchan_chan_dev(&atchan->vc), " channel: s0x%x d0x%x ctrl0x%x:0x%x cfg0x%x l0x%x\n", channel_readl(atchan, SADDR), channel_readl(atchan, DADDR), @@ -412,7 +407,7 @@ static void vdbg_dump_regs(struct at_dma_chan *atchan) = {} =20 static void atc_dump_lli(struct at_dma_chan *atchan, struct at_lli *lli) { - dev_crit(chan2dev(&atchan->vc.chan), + dev_crit(vchan_chan_dev(&atchan->vc), "desc: s%pad d%pad ctrl0x%x:0x%x l%pad\n", &lli->saddr, &lli->daddr, lli->ctrla, lli->ctrlb, &lli->dscr); @@ -790,8 +785,8 @@ static void atc_handle_error(struct at_dma_chan *atchan= , unsigned int i) * controller flagged an error instead of scribbling over * random memory locations. */ - dev_crit(chan2dev(&atchan->vc.chan), "Bad descriptor submitted for DMA!\n= "); - dev_crit(chan2dev(&atchan->vc.chan), "cookie: %d\n", + dev_crit(vchan_chan_dev(&atchan->vc), "Bad descriptor submitted for DMA!\= n"); + dev_crit(vchan_chan_dev(&atchan->vc), "cookie: %d\n", desc->vd.tx.cookie); for (i =3D 0; i < desc->sglen; i++) atc_dump_lli(atchan, desc->sg[i].lli); @@ -886,7 +881,7 @@ atc_prep_dma_interleaved(struct dma_chan *chan, =20 first =3D xt->sgl; =20 - dev_info(chan2dev(chan), + dev_info(dmaengine_chan_dev(chan), "%s: src=3D%pad, dest=3D%pad, numf=3D%zu, frame_size=3D%zu, flags=3D0x%= lx\n", __func__, &xt->src_start, &xt->dst_start, xt->numf, xt->frame_size, flags); @@ -903,7 +898,7 @@ atc_prep_dma_interleaved(struct dma_chan *chan, if ((chunk->size !=3D xt->sgl->size) || (dmaengine_get_dst_icg(xt, chunk) !=3D dmaengine_get_dst_icg(xt, fir= st)) || (dmaengine_get_src_icg(xt, chunk) !=3D dmaengine_get_src_icg(xt, fir= st))) { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "%s: the controller can transfer only identical chunks\n", __func__); return NULL; @@ -916,7 +911,7 @@ atc_prep_dma_interleaved(struct dma_chan *chan, =20 xfer_count =3D len >> dwidth; if (xfer_count > ATC_BTSIZE_MAX) { - dev_err(chan2dev(chan), "%s: buffer is too big\n", __func__); + dev_err(dmaengine_chan_dev(chan), "%s: buffer is too big\n", __func__); return NULL; } =20 @@ -983,11 +978,11 @@ atc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t= dest, dma_addr_t src, u32 ctrla; u32 ctrlb; =20 - dev_dbg(chan2dev(chan), "prep_dma_memcpy: d%pad s%pad l0x%zx f0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "prep_dma_memcpy: d%pad s%pad l0x%zx f0= x%lx\n", &dest, &src, len, flags); =20 if (unlikely(!len)) { - dev_err(chan2dev(chan), "prep_dma_memcpy: length is zero!\n"); + dev_err(dmaengine_chan_dev(chan), "prep_dma_memcpy: length is zero!\n"); return NULL; } =20 @@ -1062,7 +1057,7 @@ static int atdma_create_memset_lli(struct dma_chan *c= han, =20 xfer_count =3D len >> 2; if (xfer_count > ATC_BTSIZE_MAX) { - dev_err(chan2dev(chan), "%s: buffer is too big\n", __func__); + dev_err(dmaengine_chan_dev(chan), "%s: buffer is too big\n", __func__); return -EINVAL; } =20 @@ -1102,23 +1097,23 @@ atc_prep_dma_memset(struct dma_chan *chan, dma_addr= _t dest, int value, char fill_pattern; int ret; =20 - dev_vdbg(chan2dev(chan), "%s: d%pad v0x%x l0x%zx f0x%lx\n", __func__, + dev_vdbg(dmaengine_chan_dev(chan), "%s: d%pad v0x%x l0x%zx f0x%lx\n", __f= unc__, &dest, value, len, flags); =20 if (unlikely(!len)) { - dev_dbg(chan2dev(chan), "%s: length is zero!\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: length is zero!\n", __func__); return NULL; } =20 if (!is_dma_fill_aligned(chan->device, dest, 0, len)) { - dev_dbg(chan2dev(chan), "%s: buffer is not aligned\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: buffer is not aligned\n", __func__); return NULL; } =20 vaddr =3D dma_pool_alloc(atdma->memset_pool, GFP_NOWAIT, &paddr); if (!vaddr) { - dev_err(chan2dev(chan), "%s: couldn't allocate buffer\n", + dev_err(dmaengine_chan_dev(chan), "%s: couldn't allocate buffer\n", __func__); return NULL; } @@ -1174,18 +1169,18 @@ atc_prep_dma_memset_sg(struct dma_chan *chan, int i; int ret; =20 - dev_vdbg(chan2dev(chan), "%s: v0x%x l0x%x f0x%lx\n", __func__, + dev_vdbg(dmaengine_chan_dev(chan), "%s: v0x%x l0x%x f0x%lx\n", __func__, value, sg_len, flags); =20 if (unlikely(!sgl || !sg_len)) { - dev_dbg(chan2dev(chan), "%s: scatterlist is empty!\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: scatterlist is empty!\n", __func__); return NULL; } =20 vaddr =3D dma_pool_alloc(atdma->memset_pool, GFP_NOWAIT, &paddr); if (!vaddr) { - dev_err(chan2dev(chan), "%s: couldn't allocate buffer\n", + dev_err(dmaengine_chan_dev(chan), "%s: couldn't allocate buffer\n", __func__); return NULL; } @@ -1200,11 +1195,11 @@ atc_prep_dma_memset_sg(struct dma_chan *chan, dma_addr_t dest =3D sg_dma_address(sg); size_t len =3D sg_dma_len(sg); =20 - dev_vdbg(chan2dev(chan), "%s: d%pad, l0x%zx\n", + dev_vdbg(dmaengine_chan_dev(chan), "%s: d%pad, l0x%zx\n", __func__, &dest, len); =20 if (!is_dma_fill_aligned(chan->device, dest, 0, len)) { - dev_err(chan2dev(chan), "%s: buffer is not aligned\n", + dev_err(dmaengine_chan_dev(chan), "%s: buffer is not aligned\n", __func__); goto err_free_desc; } @@ -1264,13 +1259,13 @@ atc_prep_slave_sg(struct dma_chan *chan, struct sca= tterlist *sgl, struct scatterlist *sg; size_t total_len =3D 0; =20 - dev_vdbg(chan2dev(chan), "prep_slave_sg (%d): %s f0x%lx\n", + dev_vdbg(dmaengine_chan_dev(chan), "prep_slave_sg (%d): %s f0x%lx\n", sg_len, direction =3D=3D DMA_MEM_TO_DEV ? "TO DEVICE" : "FROM DEVICE", flags); =20 if (unlikely(!atslave || !sg_len)) { - dev_dbg(chan2dev(chan), "prep_slave_sg: sg length is zero!\n"); + dev_dbg(dmaengine_chan_dev(chan), "prep_slave_sg: sg length is zero!\n"); return NULL; } =20 @@ -1310,7 +1305,7 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatt= erlist *sgl, mem =3D sg_dma_address(sg); len =3D sg_dma_len(sg); if (unlikely(!len)) { - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "prep_slave_sg: sg(%d) data length is zero\n", i); goto err; } @@ -1359,7 +1354,7 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatt= erlist *sgl, mem =3D sg_dma_address(sg); len =3D sg_dma_len(sg); if (unlikely(!len)) { - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "prep_slave_sg: sg(%d) data length is zero\n", i); goto err; } @@ -1392,7 +1387,7 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatt= erlist *sgl, return vchan_tx_prep(&atchan->vc, &desc->vd, flags); =20 err_desc_get: - dev_err(chan2dev(chan), "not enough descriptors available\n"); + dev_err(dmaengine_chan_dev(chan), "not enough descriptors available\n"); err: atdma_desc_free(&desc->vd); return NULL; @@ -1503,19 +1498,19 @@ atc_prep_dma_cyclic(struct dma_chan *chan, dma_addr= _t buf_addr, size_t buf_len, unsigned int periods =3D buf_len / period_len; unsigned int i; =20 - dev_vdbg(chan2dev(chan), "prep_dma_cyclic: %s buf@%pad - %d (%zu/%zu)\n", + dev_vdbg(dmaengine_chan_dev(chan), "prep_dma_cyclic: %s buf@%pad - %d (%z= u/%zu)\n", direction =3D=3D DMA_MEM_TO_DEV ? "TO DEVICE" : "FROM DEVICE", &buf_addr, periods, buf_len, period_len); =20 if (unlikely(!atslave || !buf_len || !period_len)) { - dev_dbg(chan2dev(chan), "prep_dma_cyclic: length is zero!\n"); + dev_dbg(dmaengine_chan_dev(chan), "prep_dma_cyclic: length is zero!\n"); return NULL; } =20 was_cyclic =3D test_and_set_bit(ATC_IS_CYCLIC, &atchan->status); if (was_cyclic) { - dev_dbg(chan2dev(chan), "prep_dma_cyclic: channel in use!\n"); + dev_dbg(dmaengine_chan_dev(chan), "prep_dma_cyclic: channel in use!\n"); return NULL; } =20 @@ -1561,7 +1556,7 @@ static int atc_config(struct dma_chan *chan, { struct at_dma_chan *atchan =3D to_at_dma_chan(chan); =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 /* Check if it is chan is configured for slave transfers */ if (!chan->private) @@ -1582,7 +1577,7 @@ static int atc_pause(struct dma_chan *chan) int chan_id =3D atchan->vc.chan.chan_id; unsigned long flags; =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 spin_lock_irqsave(&atchan->vc.lock, flags); =20 @@ -1601,7 +1596,7 @@ static int atc_resume(struct dma_chan *chan) int chan_id =3D atchan->vc.chan.chan_id; unsigned long flags; =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 if (!atc_chan_is_paused(atchan)) return 0; @@ -1625,7 +1620,7 @@ static int atc_terminate_all(struct dma_chan *chan) =20 LIST_HEAD(list); =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 /* * This is only called when something went wrong elsewhere, so @@ -1691,13 +1686,13 @@ atc_tx_status(struct dma_chan *chan, spin_unlock_irqrestore(&atchan->vc.lock, flags); =20 if (unlikely(ret < 0)) { - dev_vdbg(chan2dev(chan), "get residual bytes error\n"); + dev_vdbg(dmaengine_chan_dev(chan), "get residual bytes error\n"); return DMA_ERROR; } else { dma_set_residue(txstate, residue); } =20 - dev_vdbg(chan2dev(chan), "tx_status %d: cookie =3D %d residue =3D %u\n", + dev_vdbg(dmaengine_chan_dev(chan), "tx_status %d: cookie =3D %d residue = =3D %u\n", dma_status, cookie, residue); =20 return dma_status; @@ -1729,11 +1724,11 @@ static int atc_alloc_chan_resources(struct dma_chan= *chan) struct at_dma_slave *atslave; u32 cfg; =20 - dev_vdbg(chan2dev(chan), "alloc_chan_resources\n"); + dev_vdbg(dmaengine_chan_dev(chan), "alloc_chan_resources\n"); =20 /* ASSERT: channel is idle */ if (atc_chan_is_enabled(atchan)) { - dev_dbg(chan2dev(chan), "DMA channel not idle ?\n"); + dev_dbg(dmaengine_chan_dev(chan), "DMA channel not idle ?\n"); return -EIO; } =20 @@ -1782,7 +1777,7 @@ static void atc_free_chan_resources(struct dma_chan *= chan) chan->private =3D NULL; } =20 - dev_vdbg(chan2dev(chan), "free_chan_resources: done\n"); + dev_vdbg(dmaengine_chan_dev(chan), "free_chan_resources: done\n"); } =20 #ifdef CONFIG_OF @@ -2179,7 +2174,7 @@ static void atc_suspend_cyclic(struct at_dma_chan *at= chan) /* Channel should be paused by user * do it anyway even if it is not done already */ if (!atc_chan_is_paused(atchan)) { - dev_warn(chan2dev(chan), + dev_warn(dmaengine_chan_dev(chan), "cyclic channel not paused, should be done by channel user\n"); atc_pause(chan); } diff --git a/drivers/dma/at_xdmac.c b/drivers/dma/at_xdmac.c index 901971e8bae69..d40a8b40dddc3 100644 --- a/drivers/dma/at_xdmac.c +++ b/drivers/dma/at_xdmac.c @@ -324,11 +324,6 @@ static inline struct at_xdmac_chan *to_at_xdmac_chan(s= truct dma_chan *dchan) return container_of(dchan, struct at_xdmac_chan, chan); } =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline struct at_xdmac *to_at_xdmac(struct dma_device *ddev) { return container_of(ddev, struct at_xdmac, dma); @@ -459,7 +454,7 @@ static void at_xdmac_start_xfer(struct at_xdmac_chan *a= tchan, if (ret < 0) return; =20 - dev_vdbg(chan2dev(&atchan->chan), "%s: desc 0x%p\n", __func__, first); + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: desc 0x%p\n", __func__, = first); =20 /* Set transfer as active to not try to start it again. */ first->active_xfer =3D true; @@ -496,7 +491,7 @@ static void at_xdmac_start_xfer(struct at_xdmac_chan *a= tchan, | AT_XDMAC_CNDC_NDE; at_xdmac_chan_write(atchan, AT_XDMAC_CNDC, reg); =20 - dev_vdbg(chan2dev(&atchan->chan), + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: CC=3D0x%08x CNDA=3D0x%08x, CNDC=3D0x%08x, CSA=3D0x%08x, CDA=3D0x%0= 8x, CUBC=3D0x%08x\n", __func__, at_xdmac_chan_read(atchan, AT_XDMAC_CC), at_xdmac_chan_read(atchan, AT_XDMAC_CNDA), @@ -524,12 +519,12 @@ static void at_xdmac_start_xfer(struct at_xdmac_chan = *atchan, at_xdmac_chan_write(atchan, AT_XDMAC_CIE, reg | AT_XDMAC_CIE_LIE); at_xdmac_write(atxdmac, AT_XDMAC_GIE, atchan->mask); - dev_vdbg(chan2dev(&atchan->chan), + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: enable channel (0x%08x)\n", __func__, atchan->mask); wmb(); at_xdmac_write(atxdmac, AT_XDMAC_GE, atchan->mask); =20 - dev_vdbg(chan2dev(&atchan->chan), + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: CC=3D0x%08x CNDA=3D0x%08x, CNDC=3D0x%08x, CSA=3D0x%08x, CDA=3D0x%0= 8x, CUBC=3D0x%08x\n", __func__, at_xdmac_chan_read(atchan, AT_XDMAC_CC), at_xdmac_chan_read(atchan, AT_XDMAC_CNDA), @@ -552,7 +547,7 @@ static dma_cookie_t at_xdmac_tx_submit(struct dma_async= _tx_descriptor *tx) list_add_tail(&desc->xfer_node, &atchan->xfers_list); spin_unlock_irqrestore(&atchan->lock, irqflags); =20 - dev_vdbg(chan2dev(tx->chan), "%s: atchan 0x%p, add desc 0x%p to xfers_lis= t\n", + dev_vdbg(dmaengine_chan_dev(tx->chan), "%s: atchan 0x%p, add desc 0x%p to= xfers_list\n", __func__, atchan, desc); =20 return cookie; @@ -612,7 +607,7 @@ static void at_xdmac_queue_desc(struct dma_chan *chan, prev->lld.mbr_nda =3D desc->tx_dma_desc.phys; prev->lld.mbr_ubc |=3D AT_XDMAC_MBR_UBC_NDE; =20 - dev_dbg(chan2dev(chan), "%s: chain lld: prev=3D0x%p, mbr_nda=3D%pad\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: chain lld: prev=3D0x%p, mbr_nda=3D= %pad\n", __func__, prev, &prev->lld.mbr_nda); } =20 @@ -624,7 +619,7 @@ static inline void at_xdmac_increment_block_count(struc= t dma_chan *chan, =20 desc->lld.mbr_bc++; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: incrementing the block count of the desc 0x%p\n", __func__, desc); } @@ -680,13 +675,13 @@ static int at_xdmac_compute_chan_conf(struct dma_chan= *chan, =20 csize =3D ffs(atchan->sconfig.src_maxburst) - 1; if (csize < 0) { - dev_err(chan2dev(chan), "invalid src maxburst value\n"); + dev_err(dmaengine_chan_dev(chan), "invalid src maxburst value\n"); return -EINVAL; } atchan->cfg |=3D AT_XDMAC_CC_CSIZE(csize); dwidth =3D ffs(atchan->sconfig.src_addr_width) - 1; if (dwidth < 0) { - dev_err(chan2dev(chan), "invalid src addr width value\n"); + dev_err(dmaengine_chan_dev(chan), "invalid src addr width value\n"); return -EINVAL; } atchan->cfg |=3D AT_XDMAC_CC_DWIDTH(dwidth); @@ -705,19 +700,19 @@ static int at_xdmac_compute_chan_conf(struct dma_chan= *chan, =20 csize =3D ffs(atchan->sconfig.dst_maxburst) - 1; if (csize < 0) { - dev_err(chan2dev(chan), "invalid src maxburst value\n"); + dev_err(dmaengine_chan_dev(chan), "invalid src maxburst value\n"); return -EINVAL; } atchan->cfg |=3D AT_XDMAC_CC_CSIZE(csize); dwidth =3D ffs(atchan->sconfig.dst_addr_width) - 1; if (dwidth < 0) { - dev_err(chan2dev(chan), "invalid dst addr width value\n"); + dev_err(dmaengine_chan_dev(chan), "invalid dst addr width value\n"); return -EINVAL; } atchan->cfg |=3D AT_XDMAC_CC_DWIDTH(dwidth); } =20 - dev_dbg(chan2dev(chan), "%s: cfg=3D0x%08x\n", __func__, atchan->cfg); + dev_dbg(dmaengine_chan_dev(chan), "%s: cfg=3D0x%08x\n", __func__, atchan-= >cfg); =20 return 0; } @@ -746,7 +741,7 @@ static int at_xdmac_set_slave_config(struct dma_chan *c= han, struct at_xdmac_chan *atchan =3D to_at_xdmac_chan(chan); =20 if (at_xdmac_check_slave_config(sconfig)) { - dev_err(chan2dev(chan), "invalid slave configuration\n"); + dev_err(dmaengine_chan_dev(chan), "invalid slave configuration\n"); return -EINVAL; } =20 @@ -772,11 +767,11 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct = scatterlist *sgl, return NULL; =20 if (!is_slave_direction(direction)) { - dev_err(chan2dev(chan), "invalid DMA direction\n"); + dev_err(dmaengine_chan_dev(chan), "invalid DMA direction\n"); return NULL; } =20 - dev_dbg(chan2dev(chan), "%s: sg_len=3D%d, dir=3D%s, flags=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: sg_len=3D%d, dir=3D%s, flags=3D0x%= lx\n", __func__, sg_len, direction =3D=3D DMA_MEM_TO_DEV ? "to device" : "from device", flags); @@ -795,15 +790,15 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct = scatterlist *sgl, len =3D sg_dma_len(sg); mem =3D sg_dma_address(sg); if (unlikely(!len)) { - dev_err(chan2dev(chan), "sg data length is zero\n"); + dev_err(dmaengine_chan_dev(chan), "sg data length is zero\n"); goto spin_unlock; } - dev_dbg(chan2dev(chan), "%s: * sg%d len=3D%u, mem=3D0x%08x\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: * sg%d len=3D%u, mem=3D0x%08x\n", __func__, i, len, mem); =20 desc =3D at_xdmac_get_desc(atchan); if (!desc) { - dev_err(chan2dev(chan), "can't get descriptor\n"); + dev_err(dmaengine_chan_dev(chan), "can't get descriptor\n"); if (first) list_splice_tail_init(&first->descs_list, &atchan->free_descs_list); @@ -828,7 +823,7 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct sc= atterlist *sgl, | (len >> fixed_dwidth); /* microblock length */ desc->lld.mbr_cfg =3D (atchan->cfg & ~AT_XDMAC_CC_DWIDTH_MASK) | AT_XDMAC_CC_DWIDTH(fixed_dwidth); - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: lld: mbr_sa=3D%pad, mbr_da=3D%pad, mbr_ubc=3D0x%08x\n", __func__, &desc->lld.mbr_sa, &desc->lld.mbr_da, desc->lld.mbr_ubc); =20 @@ -840,7 +835,7 @@ at_xdmac_prep_slave_sg(struct dma_chan *chan, struct sc= atterlist *sgl, if (!first) first =3D desc; =20 - dev_dbg(chan2dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p\= n", __func__, desc, first); list_add_tail(&desc->desc_node, &first->descs_list); xfer_size +=3D len; @@ -869,17 +864,17 @@ at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_a= ddr_t buf_addr, int i; unsigned long irqflags; =20 - dev_dbg(chan2dev(chan), "%s: buf_addr=3D%pad, buf_len=3D%zd, period_len= =3D%zd, dir=3D%s, flags=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: buf_addr=3D%pad, buf_len=3D%zd, pe= riod_len=3D%zd, dir=3D%s, flags=3D0x%lx\n", __func__, &buf_addr, buf_len, period_len, direction =3D=3D DMA_MEM_TO_DEV ? "mem2per" : "per2mem", flags); =20 if (!is_slave_direction(direction)) { - dev_err(chan2dev(chan), "invalid DMA direction\n"); + dev_err(dmaengine_chan_dev(chan), "invalid DMA direction\n"); return NULL; } =20 if (test_and_set_bit(AT_XDMAC_CHAN_IS_CYCLIC, &atchan->status)) { - dev_err(chan2dev(chan), "channel currently used\n"); + dev_err(dmaengine_chan_dev(chan), "channel currently used\n"); return NULL; } =20 @@ -892,7 +887,7 @@ at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_add= r_t buf_addr, spin_lock_irqsave(&atchan->lock, irqflags); desc =3D at_xdmac_get_desc(atchan); if (!desc) { - dev_err(chan2dev(chan), "can't get descriptor\n"); + dev_err(dmaengine_chan_dev(chan), "can't get descriptor\n"); if (first) list_splice_tail_init(&first->descs_list, &atchan->free_descs_list); @@ -900,7 +895,7 @@ at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_add= r_t buf_addr, return NULL; } spin_unlock_irqrestore(&atchan->lock, irqflags); - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: desc=3D0x%p, tx_dma_desc.phys=3D%pad\n", __func__, desc, &desc->tx_dma_desc.phys); =20 @@ -917,7 +912,7 @@ at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_add= r_t buf_addr, | AT_XDMAC_MBR_UBC_NSEN | period_len >> at_xdmac_get_dwidth(desc->lld.mbr_cfg); =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: lld: mbr_sa=3D%pad, mbr_da=3D%pad, mbr_ubc=3D0x%08x\n", __func__, &desc->lld.mbr_sa, &desc->lld.mbr_da, desc->lld.mbr_ubc); =20 @@ -929,7 +924,7 @@ at_xdmac_prep_dma_cyclic(struct dma_chan *chan, dma_add= r_t buf_addr, if (!first) first =3D desc; =20 - dev_dbg(chan2dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p\= n", __func__, desc, first); list_add_tail(&desc->desc_node, &first->descs_list); } @@ -956,16 +951,16 @@ static inline u32 at_xdmac_align_width(struct dma_cha= n *chan, dma_addr_t addr) */ if (!(addr & 7)) { width =3D AT_XDMAC_CC_DWIDTH_DWORD; - dev_dbg(chan2dev(chan), "%s: dwidth: double word\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: dwidth: double word\n", __func__); } else if (!(addr & 3)) { width =3D AT_XDMAC_CC_DWIDTH_WORD; - dev_dbg(chan2dev(chan), "%s: dwidth: word\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: dwidth: word\n", __func__); } else if (!(addr & 1)) { width =3D AT_XDMAC_CC_DWIDTH_HALFWORD; - dev_dbg(chan2dev(chan), "%s: dwidth: half word\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: dwidth: half word\n", __func__); } else { width =3D AT_XDMAC_CC_DWIDTH_BYTE; - dev_dbg(chan2dev(chan), "%s: dwidth: byte\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: dwidth: byte\n", __func__); } =20 return width; @@ -1005,7 +1000,7 @@ at_xdmac_interleaved_queue_desc(struct dma_chan *chan, =20 dwidth =3D at_xdmac_align_width(chan, src | dst | chunk->size); if (chunk->size >=3D (AT_XDMAC_MBR_UBC_UBLEN_MAX << dwidth)) { - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: chunk too big (%zu, max size %lu)...\n", __func__, chunk->size, AT_XDMAC_MBR_UBC_UBLEN_MAX << dwidth); @@ -1013,7 +1008,7 @@ at_xdmac_interleaved_queue_desc(struct dma_chan *chan, } =20 if (prev) - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "Adding items at the end of desc 0x%p\n", prev); =20 if (xt->src_inc) { @@ -1034,7 +1029,7 @@ at_xdmac_interleaved_queue_desc(struct dma_chan *chan, desc =3D at_xdmac_get_desc(atchan); spin_unlock_irqrestore(&atchan->lock, flags); if (!desc) { - dev_err(chan2dev(chan), "can't get descriptor\n"); + dev_err(dmaengine_chan_dev(chan), "can't get descriptor\n"); return NULL; } =20 @@ -1053,7 +1048,7 @@ at_xdmac_interleaved_queue_desc(struct dma_chan *chan, | ublen; desc->lld.mbr_cfg =3D chan_cc; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: lld: mbr_sa=3D%pad, mbr_da=3D%pad, mbr_ubc=3D0x%08x, mbr_cfg=3D0x%0= 8x\n", __func__, &desc->lld.mbr_sa, &desc->lld.mbr_da, desc->lld.mbr_ubc, desc->lld.mbr_cfg); @@ -1087,7 +1082,7 @@ at_xdmac_prep_interleaved(struct dma_chan *chan, if ((xt->numf > 1) && (xt->frame_size > 1)) return NULL; =20 - dev_dbg(chan2dev(chan), "%s: src=3D%pad, dest=3D%pad, numf=3D%zu, frame_s= ize=3D%zu, flags=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: src=3D%pad, dest=3D%pad, numf=3D%z= u, frame_size=3D%zu, flags=3D0x%lx\n", __func__, &xt->src_start, &xt->dst_start, xt->numf, xt->frame_size, flags); =20 @@ -1106,7 +1101,7 @@ at_xdmac_prep_interleaved(struct dma_chan *chan, for (i =3D 0; i < xt->numf - 1; i++) at_xdmac_increment_block_count(chan, first); =20 - dev_dbg(chan2dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p\= n", __func__, first, first); list_add_tail(&first->desc_node, &first->descs_list); } else { @@ -1122,7 +1117,7 @@ at_xdmac_prep_interleaved(struct dma_chan *chan, src_skip =3D chunk->size + src_icg; dst_skip =3D chunk->size + dst_icg; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: chunk size=3D%zu, src icg=3D%zu, dst icg=3D%zu\n", __func__, chunk->size, src_icg, dst_icg); =20 @@ -1140,7 +1135,7 @@ at_xdmac_prep_interleaved(struct dma_chan *chan, if (!first) first =3D desc; =20 - dev_dbg(chan2dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p= \n", __func__, desc, first); list_add_tail(&desc->desc_node, &first->descs_list); =20 @@ -1193,7 +1188,7 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_a= ddr_t dest, dma_addr_t src, | AT_XDMAC_CC_TYPE_MEM_TRAN; unsigned long irqflags; =20 - dev_dbg(chan2dev(chan), "%s: src=3D%pad, dest=3D%pad, len=3D%zd, flags=3D= 0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: src=3D%pad, dest=3D%pad, len=3D%zd= , flags=3D0x%lx\n", __func__, &src, &dest, len, flags); =20 if (unlikely(!len)) @@ -1205,13 +1200,13 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma= _addr_t dest, dma_addr_t src, while (remaining_size) { struct at_xdmac_desc *desc =3D NULL; =20 - dev_dbg(chan2dev(chan), "%s: remaining_size=3D%zu\n", __func__, remainin= g_size); + dev_dbg(dmaengine_chan_dev(chan), "%s: remaining_size=3D%zu\n", __func__= , remaining_size); =20 spin_lock_irqsave(&atchan->lock, irqflags); desc =3D at_xdmac_get_desc(atchan); spin_unlock_irqrestore(&atchan->lock, irqflags); if (!desc) { - dev_err(chan2dev(chan), "can't get descriptor\n"); + dev_err(dmaengine_chan_dev(chan), "can't get descriptor\n"); if (first) list_splice_tail_init(&first->descs_list, &atchan->free_descs_list); @@ -1227,7 +1222,7 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_a= ddr_t dest, dma_addr_t src, else xfer_size =3D remaining_size; =20 - dev_dbg(chan2dev(chan), "%s: xfer_size=3D%zu\n", __func__, xfer_size); + dev_dbg(dmaengine_chan_dev(chan), "%s: xfer_size=3D%zu\n", __func__, xfe= r_size); =20 /* Check remaining length and change data width if needed. */ dwidth =3D at_xdmac_align_width(chan, @@ -1246,7 +1241,7 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_a= ddr_t dest, dma_addr_t src, | ublen; desc->lld.mbr_cfg =3D chan_cc; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: lld: mbr_sa=3D%pad, mbr_da=3D%pad, mbr_ubc=3D0x%08x, mbr_cfg=3D0x= %08x\n", __func__, &desc->lld.mbr_sa, &desc->lld.mbr_da, desc->lld.mbr_ubc, des= c->lld.mbr_cfg); =20 @@ -1258,7 +1253,7 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_a= ddr_t dest, dma_addr_t src, if (!first) first =3D desc; =20 - dev_dbg(chan2dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p\= n", __func__, desc, first); list_add_tail(&desc->desc_node, &first->descs_list); } @@ -1306,7 +1301,7 @@ static struct at_xdmac_desc *at_xdmac_memset_create_d= esc(struct dma_chan *chan, dwidth =3D at_xdmac_align_width(chan, dst_addr); =20 if (len >=3D (AT_XDMAC_MBR_UBC_UBLEN_MAX << dwidth)) { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "%s: Transfer too large, aborting...\n", __func__); return NULL; @@ -1316,7 +1311,7 @@ static struct at_xdmac_desc *at_xdmac_memset_create_d= esc(struct dma_chan *chan, desc =3D at_xdmac_get_desc(atchan); spin_unlock_irqrestore(&atchan->lock, flags); if (!desc) { - dev_err(chan2dev(chan), "can't get descriptor\n"); + dev_err(dmaengine_chan_dev(chan), "can't get descriptor\n"); return NULL; } =20 @@ -1338,7 +1333,7 @@ static struct at_xdmac_desc *at_xdmac_memset_create_d= esc(struct dma_chan *chan, | ublen; desc->lld.mbr_cfg =3D chan_cc; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: lld: mbr_da=3D%pad, mbr_ds=3D0x%08x, mbr_ubc=3D0x%08x, mbr_cfg=3D0x= %08x\n", __func__, &desc->lld.mbr_da, desc->lld.mbr_ds, desc->lld.mbr_ubc, desc->lld.mbr_cfg); @@ -1353,7 +1348,7 @@ at_xdmac_prep_dma_memset(struct dma_chan *chan, dma_a= ddr_t dest, int value, struct at_xdmac_chan *atchan =3D to_at_xdmac_chan(chan); struct at_xdmac_desc *desc; =20 - dev_dbg(chan2dev(chan), "%s: dest=3D%pad, len=3D%zu, pattern=3D0x%x, flag= s=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: dest=3D%pad, len=3D%zu, pattern=3D= 0x%x, flags=3D0x%lx\n", __func__, &dest, len, value, flags); =20 if (unlikely(!len)) @@ -1386,12 +1381,12 @@ at_xdmac_prep_dma_memset_sg(struct dma_chan *chan, = struct scatterlist *sgl, if (!sgl) return NULL; =20 - dev_dbg(chan2dev(chan), "%s: sg_len=3D%d, value=3D0x%x, flags=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: sg_len=3D%d, value=3D0x%x, flags= =3D0x%lx\n", __func__, sg_len, value, flags); =20 /* Prepare descriptors. */ for_each_sg(sgl, sg, sg_len, i) { - dev_dbg(chan2dev(chan), "%s: dest=3D%pad, len=3D%d, pattern=3D0x%x, flag= s=3D0x%lx\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: dest=3D%pad, len=3D%d, pattern=3D= 0x%x, flags=3D0x%lx\n", __func__, &sg_dma_address(sg), sg_dma_len(sg), value, flags); desc =3D at_xdmac_memset_create_desc(chan, atchan, @@ -1433,7 +1428,7 @@ at_xdmac_prep_dma_memset_sg(struct dma_chan *chan, st= ruct scatterlist *sgl, if (ppdesc && pdesc) { if ((stride =3D=3D pstride) && (sg_dma_len(ppsg) =3D=3D sg_dma_len(psg))) { - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: desc 0x%p can be merged with desc 0x%p\n", __func__, pdesc, ppdesc); =20 @@ -1481,7 +1476,7 @@ at_xdmac_prep_dma_memset_sg(struct dma_chan *chan, st= ruct scatterlist *sgl, */ list_add_tail(&desc->desc_node, &first->descs_list); - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: add desc 0x%p to descs_list 0x%p\n", __func__, desc, first); } @@ -1496,7 +1491,7 @@ at_xdmac_prep_dma_memset_sg(struct dma_chan *chan, st= ruct scatterlist *sgl, */ if ((i =3D=3D (sg_len - 1)) && sg_dma_len(psg) =3D=3D sg_dma_len(sg)) { - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: desc 0x%p can be merged with desc 0x%p\n", __func__, desc, pdesc); =20 @@ -1667,7 +1662,7 @@ at_xdmac_tx_status(struct dma_chan *chan, dma_cookie_= t cookie, =20 dma_set_residue(txstate, residue); =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s: desc=3D0x%p, tx_dma_desc.phys=3D%pad, tx_status=3D%d, cookie=3D%d,= residue=3D%d\n", __func__, desc, &desc->tx_dma_desc.phys, ret, cookie, residue); =20 @@ -1690,7 +1685,7 @@ static void at_xdmac_advance_work(struct at_xdmac_cha= n *atchan) =20 desc =3D list_first_entry(&atchan->xfers_list, struct at_xdmac_desc, xfer_node); - dev_vdbg(chan2dev(&atchan->chan), "%s: desc 0x%p\n", __func__, desc); + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: desc 0x%p\n", __func__, = desc); if (!desc->active_xfer) at_xdmac_start_xfer(atchan, desc); } @@ -1701,7 +1696,7 @@ static void at_xdmac_handle_cyclic(struct at_xdmac_ch= an *atchan) struct dma_async_tx_descriptor *txd; =20 spin_lock_irq(&atchan->lock); - dev_dbg(chan2dev(&atchan->chan), "%s: status=3D0x%08x\n", + dev_dbg(dmaengine_chan_dev(&atchan->chan), "%s: status=3D0x%08x\n", __func__, atchan->irq_status); if (list_empty(&atchan->xfers_list)) { spin_unlock_irq(&atchan->lock); @@ -1733,11 +1728,11 @@ static void at_xdmac_handle_error(struct at_xdmac_c= han *atchan) * descriptors queued (if any). */ if (atchan->irq_status & AT_XDMAC_CIS_RBEIS) - dev_err(chan2dev(&atchan->chan), "read bus error!!!"); + dev_err(dmaengine_chan_dev(&atchan->chan), "read bus error!!!"); if (atchan->irq_status & AT_XDMAC_CIS_WBEIS) - dev_err(chan2dev(&atchan->chan), "write bus error!!!"); + dev_err(dmaengine_chan_dev(&atchan->chan), "write bus error!!!"); if (atchan->irq_status & AT_XDMAC_CIS_ROIS) - dev_err(chan2dev(&atchan->chan), "request overflow error!!!"); + dev_err(dmaengine_chan_dev(&atchan->chan), "request overflow error!!!"); =20 /* Channel must be disabled first as it's not done automatically */ at_xdmac_write(atxdmac, AT_XDMAC_GD, atchan->mask); @@ -1749,7 +1744,7 @@ static void at_xdmac_handle_error(struct at_xdmac_cha= n *atchan) xfer_node); =20 /* Print bad descriptor's details if needed */ - dev_dbg(chan2dev(&atchan->chan), + dev_dbg(dmaengine_chan_dev(&atchan->chan), "%s: lld: mbr_sa=3D%pad, mbr_da=3D%pad, mbr_ubc=3D0x%08x\n", __func__, &bad_desc->lld.mbr_sa, &bad_desc->lld.mbr_da, bad_desc->lld.mbr_ubc); @@ -1775,7 +1770,7 @@ static void at_xdmac_tasklet(struct tasklet_struct *t) =20 spin_lock_irq(&atchan->lock); =20 - dev_dbg(chan2dev(&atchan->chan), "%s: status=3D0x%08x\n", + dev_dbg(dmaengine_chan_dev(&atchan->chan), "%s: status=3D0x%08x\n", __func__, atchan->irq_status); =20 if (!(atchan->irq_status & AT_XDMAC_CIS_LIS) && @@ -1789,9 +1784,9 @@ static void at_xdmac_tasklet(struct tasklet_struct *t) =20 desc =3D list_first_entry(&atchan->xfers_list, struct at_xdmac_desc, xfer_node); - dev_vdbg(chan2dev(&atchan->chan), "%s: desc 0x%p\n", __func__, desc); + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: desc 0x%p\n", __func__, = desc); if (!desc->active_xfer) { - dev_err(chan2dev(&atchan->chan), "Xfer not active: exiting"); + dev_err(dmaengine_chan_dev(&atchan->chan), "Xfer not active: exiting"); spin_unlock_irq(&atchan->lock); return; } @@ -1852,7 +1847,7 @@ static irqreturn_t at_xdmac_interrupt(int irq, void *= dev_id) dev_vdbg(atxdmac->dma.dev, "%s: chan%d: imr=3D0x%x, status=3D0x%x\n", __func__, i, chan_imr, chan_status); - dev_vdbg(chan2dev(&atchan->chan), + dev_vdbg(dmaengine_chan_dev(&atchan->chan), "%s: CC=3D0x%08x CNDA=3D0x%08x, CNDC=3D0x%08x, CSA=3D0x%08x, CDA=3D0x= %08x, CUBC=3D0x%08x\n", __func__, at_xdmac_chan_read(atchan, AT_XDMAC_CC), @@ -1879,7 +1874,7 @@ static void at_xdmac_issue_pending(struct dma_chan *c= han) struct at_xdmac_chan *atchan =3D to_at_xdmac_chan(chan); unsigned long flags; =20 - dev_dbg(chan2dev(&atchan->chan), "%s\n", __func__); + dev_dbg(dmaengine_chan_dev(&atchan->chan), "%s\n", __func__); =20 spin_lock_irqsave(&atchan->lock, flags); at_xdmac_advance_work(atchan); @@ -1895,7 +1890,7 @@ static int at_xdmac_device_config(struct dma_chan *ch= an, int ret; unsigned long flags; =20 - dev_dbg(chan2dev(chan), "%s\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 spin_lock_irqsave(&atchan->lock, flags); ret =3D at_xdmac_set_slave_config(chan, config); @@ -1931,7 +1926,7 @@ static int at_xdmac_device_pause(struct dma_chan *cha= n) unsigned long flags; int ret; =20 - dev_dbg(chan2dev(chan), "%s\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 if (test_and_set_bit(AT_XDMAC_CHAN_IS_PAUSED, &atchan->status)) return 0; @@ -1971,7 +1966,7 @@ static int at_xdmac_device_resume(struct dma_chan *ch= an) unsigned long flags; int ret; =20 - dev_dbg(chan2dev(chan), "%s\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 ret =3D pm_runtime_resume_and_get(atxdmac->dev); if (ret < 0) @@ -2004,7 +1999,7 @@ static int at_xdmac_device_terminate_all(struct dma_c= han *chan) unsigned long flags; int ret; =20 - dev_dbg(chan2dev(chan), "%s\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 ret =3D pm_runtime_resume_and_get(atxdmac->dev); if (ret < 0) @@ -2045,13 +2040,13 @@ static int at_xdmac_alloc_chan_resources(struct dma= _chan *chan) int i; =20 if (at_xdmac_chan_is_enabled(atchan)) { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "can't allocate channel resources (channel enabled)\n"); return -EIO; } =20 if (!list_empty(&atchan->free_descs_list)) { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "can't allocate channel resources (channel not free from a previous use= )\n"); return -EIO; } @@ -2060,11 +2055,11 @@ static int at_xdmac_alloc_chan_resources(struct dma= _chan *chan) desc =3D at_xdmac_alloc_desc(chan, GFP_KERNEL); if (!desc) { if (i =3D=3D 0) { - dev_warn(chan2dev(chan), + dev_warn(dmaengine_chan_dev(chan), "can't allocate any descriptors\n"); return -EIO; } - dev_warn(chan2dev(chan), + dev_warn(dmaengine_chan_dev(chan), "only %d descriptors have been allocated\n", i); break; } @@ -2073,7 +2068,7 @@ static int at_xdmac_alloc_chan_resources(struct dma_c= han *chan) =20 dma_cookie_init(chan); =20 - dev_dbg(chan2dev(chan), "%s: allocated %d descriptors\n", __func__, i); + dev_dbg(dmaengine_chan_dev(chan), "%s: allocated %d descriptors\n", __fun= c__, i); =20 return i; } @@ -2085,7 +2080,7 @@ static void at_xdmac_free_chan_resources(struct dma_c= han *chan) struct at_xdmac_desc *desc, *_desc; =20 list_for_each_entry_safe(desc, _desc, &atchan->free_descs_list, desc_node= ) { - dev_dbg(chan2dev(chan), "%s: freeing descriptor %p\n", __func__, desc); + dev_dbg(dmaengine_chan_dev(chan), "%s: freeing descriptor %p\n", __func_= _, desc); list_del(&desc->desc_node); dma_pool_free(atxdmac->at_xdmac_desc_pool, desc, desc->tx_dma_desc.phys); } @@ -2148,7 +2143,7 @@ static int __maybe_unused atmel_xdmac_suspend(struct = device *dev) atchan->save_cc =3D at_xdmac_chan_read(atchan, AT_XDMAC_CC); if (at_xdmac_chan_is_cyclic(atchan)) { if (!at_xdmac_chan_is_paused(atchan)) { - dev_warn(chan2dev(chan), "%s: channel %d not paused\n", + dev_warn(dmaengine_chan_dev(chan), "%s: channel %d not paused\n", __func__, chan->chan_id); at_xdmac_device_pause_internal(atchan); at_xdmac_runtime_suspend_descriptors(atchan); diff --git a/drivers/dma/dma-jz4780.c b/drivers/dma/dma-jz4780.c index 194649811d02b..ac2094e65ecf3 100644 --- a/drivers/dma/dma-jz4780.c +++ b/drivers/dma/dma-jz4780.c @@ -687,12 +687,12 @@ static bool jz4780_dma_chan_irq(struct jz4780_dma_dev= *jzdma, jz4780_dma_chn_writel(jzdma, jzchan->id, JZ_DMA_REG_DCS, 0); =20 if (dcs & JZ_DMA_DCS_AR) { - dev_warn(&jzchan->vchan.chan.dev->device, + dev_warn(vchan_chan_dev(&jzchan->vchan), "address error (DCS=3D0x%x)\n", dcs); } =20 if (dcs & JZ_DMA_DCS_HLT) { - dev_warn(&jzchan->vchan.chan.dev->device, + dev_warn(vchan_chan_dev(&jzchan->vchan), "channel halt (DCS=3D0x%x)\n", dcs); } =20 @@ -721,7 +721,7 @@ static bool jz4780_dma_chan_irq(struct jz4780_dma_dev *= jzdma, } } } else { - dev_err(&jzchan->vchan.chan.dev->device, + dev_err(vchan_chan_dev(&jzchan->vchan), "channel IRQ with no active transfer\n"); } =20 @@ -765,7 +765,7 @@ static int jz4780_dma_alloc_chan_resources(struct dma_c= han *chan) JZ_DMA_DESC_BLOCK_SIZE, PAGE_SIZE, 0); if (!jzchan->desc_pool) { - dev_err(&chan->dev->device, + dev_err(dmaengine_chan_dev(chan), "failed to allocate descriptor pool\n"); return -ENOMEM; } diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c index 6ffd8bd82154a..a7ac2729e4d9d 100644 --- a/drivers/dma/dmaengine.c +++ b/drivers/dma/dmaengine.c @@ -868,10 +868,10 @@ struct dma_chan *dma_request_chan(struct device *dev,= const char *name) return chan; chan->slave =3D dev; =20 - if (sysfs_create_link(&chan->dev->device.kobj, &dev->kobj, + if (sysfs_create_link(&dmaengine_chan_dev(chan)->kobj, &dev->kobj, DMA_SLAVE_NAME)) dev_warn(dev, "Cannot create DMA %s symlink\n", DMA_SLAVE_NAME); - if (sysfs_create_link(&dev->kobj, &chan->dev->device.kobj, chan->name)) + if (sysfs_create_link(&dev->kobj, &dmaengine_chan_dev(chan)->kobj, chan->= name)) dev_warn(dev, "Cannot create DMA %s symlink\n", chan->name); =20 return chan; @@ -917,7 +917,7 @@ void dma_release_channel(struct dma_chan *chan) dma_chan_put(chan); =20 if (chan->slave) { - sysfs_remove_link(&chan->dev->device.kobj, DMA_SLAVE_NAME); + sysfs_remove_link(&dmaengine_chan_dev(chan)->kobj, DMA_SLAVE_NAME); sysfs_remove_link(&chan->slave->kobj, chan->name); kfree(chan->name); chan->name =3D NULL; @@ -1101,17 +1101,17 @@ static int __dma_async_device_channel_register(stru= ct dma_device *device, goto err_free_dev; } =20 - chan->dev->device.class =3D &dma_devclass; - chan->dev->device.parent =3D device->dev; + dmaengine_chan_dev(chan)->class =3D &dma_devclass; + dmaengine_chan_dev(chan)->parent =3D device->dev; chan->dev->chan =3D chan; chan->dev->dev_id =3D device->dev_id; spin_lock_init(&chan->lock); =20 if (!name) - dev_set_name(&chan->dev->device, "dma%dchan%d", device->dev_id, chan->ch= an_id); + dev_set_name(dmaengine_chan_dev(chan), "dma%dchan%d", device->dev_id, ch= an->chan_id); else - dev_set_name(&chan->dev->device, "%s", name); - rc =3D device_register(&chan->dev->device); + dev_set_name(dmaengine_chan_dev(chan), "%s", name); + rc =3D device_register(dmaengine_chan_dev(chan)); if (rc) goto err_out_ida; chan->client_count =3D 0; @@ -1158,7 +1158,7 @@ static void __dma_async_device_channel_unregister(str= uct dma_device *device, chan->dev->chan =3D NULL; mutex_unlock(&dma_list_mutex); ida_free(&device->chan_ida, chan->chan_id); - device_unregister(&chan->dev->device); + device_unregister(dmaengine_chan_dev(chan)); free_percpu(chan->local); } =20 @@ -1292,7 +1292,7 @@ int dma_async_device_register(struct dma_device *devi= ce) mutex_lock(&dma_list_mutex); chan->dev->chan =3D NULL; mutex_unlock(&dma_list_mutex); - device_unregister(&chan->dev->device); + device_unregister(dmaengine_chan_dev(chan)); free_percpu(chan->local); } return rc; diff --git a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c b/drivers/dma/d= w-axi-dmac/dw-axi-dmac-platform.c index a36b066c3c33c..42ef5c11032ee 100644 --- a/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c +++ b/drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c @@ -316,7 +316,7 @@ static struct axi_dma_lli *axi_desc_get(struct axi_dma_= chan *chan, =20 lli =3D dma_pool_zalloc(chan->desc_pool, GFP_NOWAIT, &phys); if (unlikely(!lli)) { - dev_err(chan2dev(chan), "%s: not enough descriptors available\n", + dev_err(vchan_chan_dev(&chan->vc), "%s: not enough descriptors available= \n", axi_chan_name(chan)); return NULL; } @@ -342,7 +342,7 @@ static void axi_desc_put(struct axi_dma_desc *desc) kfree(desc->hw_desc); kfree(desc); atomic_sub(descs_put, &chan->descs_allocated); - dev_vdbg(chan2dev(chan), "%s: %d descs put, %d still allocated\n", + dev_vdbg(vchan_chan_dev(&chan->vc), "%s: %d descs put, %d still allocated= \n", axi_chan_name(chan), descs_put, atomic_read(&chan->descs_allocated)); } @@ -431,7 +431,7 @@ static void axi_chan_block_xfer_start(struct axi_dma_ch= an *chan, u8 lms =3D 0; /* Select AXI0 master for LLI fetching */ =20 if (unlikely(axi_chan_is_hw_enable(chan))) { - dev_err(chan2dev(chan), "%s is non-idle!\n", + dev_err(vchan_chan_dev(&chan->vc), "%s is non-idle!\n", axi_chan_name(chan)); =20 return; @@ -490,7 +490,7 @@ static void axi_chan_start_first_queued(struct axi_dma_= chan *chan) return; =20 desc =3D vd_to_axi_desc(vd); - dev_vdbg(chan2dev(chan), "%s: started %u\n", axi_chan_name(chan), + dev_vdbg(vchan_chan_dev(&chan->vc), "%s: started %u\n", axi_chan_name(cha= n), vd->tx.cookie); axi_chan_block_xfer_start(chan, desc); } @@ -524,7 +524,7 @@ static int dma_chan_alloc_chan_resources(struct dma_cha= n *dchan) =20 /* ASSERT: channel is idle */ if (axi_chan_is_hw_enable(chan)) { - dev_err(chan2dev(chan), "%s is non-idle!\n", + dev_err(vchan_chan_dev(&chan->vc), "%s is non-idle!\n", axi_chan_name(chan)); pm_runtime_put(chan->chip->dev); return -EBUSY; @@ -535,11 +535,11 @@ static int dma_chan_alloc_chan_resources(struct dma_c= han *dchan) sizeof(struct axi_dma_lli), 64, 0); if (!chan->desc_pool) { - dev_err(chan2dev(chan), "No memory for descriptors\n"); + dev_err(vchan_chan_dev(&chan->vc), "No memory for descriptors\n"); pm_runtime_put(chan->chip->dev); return -ENOMEM; } - dev_vdbg(dchan2dev(dchan), "%s: allocating\n", axi_chan_name(chan)); + dev_vdbg(dmaengine_chan_dev(dchan), "%s: allocating\n", axi_chan_name(cha= n)); =20 return 0; } @@ -550,7 +550,7 @@ static void dma_chan_free_chan_resources(struct dma_cha= n *dchan) =20 /* ASSERT: channel is idle */ if (axi_chan_is_hw_enable(chan)) - dev_err(dchan2dev(dchan), "%s is non-idle!\n", + dev_err(dmaengine_chan_dev(dchan), "%s is non-idle!\n", axi_chan_name(chan)); =20 axi_chan_disable(chan); @@ -560,7 +560,7 @@ static void dma_chan_free_chan_resources(struct dma_cha= n *dchan) =20 dma_pool_destroy(chan->desc_pool); chan->desc_pool =3D NULL; - dev_vdbg(dchan2dev(dchan), + dev_vdbg(dmaengine_chan_dev(dchan), "%s: free resources, descriptor still allocated: %u\n", axi_chan_name(chan), atomic_read(&chan->descs_allocated)); =20 @@ -929,7 +929,7 @@ dma_chan_prep_dma_memcpy(struct dma_chan *dchan, dma_ad= dr_t dst_adr, u64 llp =3D 0; u8 lms =3D 0; /* Select AXI0 master for LLI fetching */ =20 - dev_dbg(chan2dev(chan), "%s: memcpy: src: %pad dst: %pad length: %zd flag= s: %#lx", + dev_dbg(vchan_chan_dev(&chan->vc), "%s: memcpy: src: %pad dst: %pad lengt= h: %zd flags: %#lx", axi_chan_name(chan), &src_adr, &dst_adr, len, flags); =20 max_block_ts =3D chan->chip->dw->hdata->block_size[chan->id]; @@ -1034,11 +1034,11 @@ static void axi_chan_dump_lli(struct axi_dma_chan *= chan, struct axi_dma_hw_desc *desc) { if (!desc->lli) { - dev_err(dchan2dev(&chan->vc.chan), "NULL LLI\n"); + dev_err(vchan_chan_dev(&chan->vc), "NULL LLI\n"); return; } =20 - dev_err(dchan2dev(&chan->vc.chan), + dev_err(vchan_chan_dev(&chan->vc), "SAR: 0x%llx DAR: 0x%llx LLP: 0x%llx BTS 0x%x CTL: 0x%x:%08x", le64_to_cpu(desc->lli->sar), le64_to_cpu(desc->lli->dar), @@ -1070,7 +1070,7 @@ static noinline void axi_chan_handle_err(struct axi_d= ma_chan *chan, u32 status) /* The bad descriptor currently is in the head of vc list */ vd =3D vchan_next_desc(&chan->vc); if (!vd) { - dev_err(chan2dev(chan), "BUG: %s, IRQ with no descriptors\n", + dev_err(vchan_chan_dev(&chan->vc), "BUG: %s, IRQ with no descriptors\n", axi_chan_name(chan)); goto out; } @@ -1078,7 +1078,7 @@ static noinline void axi_chan_handle_err(struct axi_d= ma_chan *chan, u32 status) list_del(&vd->node); =20 /* WARN about bad descriptor */ - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vc), "Bad descriptor submitted for %s, cookie: %d, irq: 0x%08x\n", axi_chan_name(chan), vd->tx.cookie, status); axi_chan_list_dump_lli(chan, vd_to_axi_desc(vd)); @@ -1104,7 +1104,7 @@ static void axi_chan_block_xfer_complete(struct axi_d= ma_chan *chan) =20 spin_lock_irqsave(&chan->vc.lock, flags); if (unlikely(axi_chan_is_hw_enable(chan))) { - dev_err(chan2dev(chan), "BUG: %s caught DWAXIDMAC_IRQ_DMA_TRF, but chann= el not idle!\n", + dev_err(vchan_chan_dev(&chan->vc), "BUG: %s caught DWAXIDMAC_IRQ_DMA_TRF= , but channel not idle!\n", axi_chan_name(chan)); axi_chan_disable(chan); } @@ -1112,7 +1112,7 @@ static void axi_chan_block_xfer_complete(struct axi_d= ma_chan *chan) /* The completed descriptor currently is in the head of vc list */ vd =3D vchan_next_desc(&chan->vc); if (!vd) { - dev_err(chan2dev(chan), "BUG: %s, IRQ with no descriptors\n", + dev_err(vchan_chan_dev(&chan->vc), "BUG: %s, IRQ with no descriptors\n", axi_chan_name(chan)); goto out; } @@ -1192,7 +1192,7 @@ static int dma_chan_terminate_all(struct dma_chan *dc= han) ret =3D readl_poll_timeout_atomic(chan->chip->regs + DMAC_CHEN, val, !(val & chan_active), 1000, 50000); if (ret =3D=3D -ETIMEDOUT) - dev_warn(dchan2dev(dchan), + dev_warn(dmaengine_chan_dev(dchan), "%s failed to stop\n", axi_chan_name(chan)); =20 if (chan->direction !=3D DMA_MEM_TO_MEM) @@ -1209,7 +1209,7 @@ static int dma_chan_terminate_all(struct dma_chan *dc= han) =20 vchan_dma_desc_free_list(&chan->vc, &head); =20 - dev_vdbg(dchan2dev(dchan), "terminated: %s\n", axi_chan_name(chan)); + dev_vdbg(dmaengine_chan_dev(dchan), "terminated: %s\n", axi_chan_name(cha= n)); =20 return 0; } diff --git a/drivers/dma/dw-axi-dmac/dw-axi-dmac.h b/drivers/dma/dw-axi-dma= c/dw-axi-dmac.h index 039316c42f059..e3e200a058623 100644 --- a/drivers/dma/dw-axi-dmac/dw-axi-dmac.h +++ b/drivers/dma/dw-axi-dmac/dw-axi-dmac.h @@ -118,16 +118,6 @@ struct axi_dma_chan_config { u8 hs_sel_src; }; =20 -static inline struct device *dchan2dev(struct dma_chan *dchan) -{ - return &dchan->dev->device; -} - -static inline struct device *chan2dev(struct axi_dma_chan *chan) -{ - return &chan->vc.chan.dev->device; -} - static inline struct axi_dma_desc *vd_to_axi_desc(struct virt_dma_desc *vd) { return container_of(vd, struct axi_dma_desc, vd); diff --git a/drivers/dma/dw/core.c b/drivers/dma/dw/core.c index dd75f97a33b3d..575b7bb6af9a0 100644 --- a/drivers/dma/dw/core.c +++ b/drivers/dma/dw/core.c @@ -41,11 +41,6 @@ =20 /*----------------------------------------------------------------------*/ =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static struct dw_desc *dwc_first_active(struct dw_dma_chan *dwc) { return to_dw_desc(dwc->active_list.next); @@ -69,7 +64,7 @@ static dma_cookie_t dwc_tx_submit(struct dma_async_tx_des= criptor *tx) =20 list_add_tail(&desc->desc_node, &dwc->queue); spin_unlock_irqrestore(&dwc->lock, flags); - dev_vdbg(chan2dev(tx->chan), "%s: queued %u\n", + dev_vdbg(dmaengine_chan_dev(tx->chan), "%s: queued %u\n", __func__, desc->txd.cookie); =20 return cookie; @@ -127,7 +122,7 @@ static void dwc_initialize(struct dw_dma_chan *dwc) =20 static inline void dwc_dump_chan_regs(struct dw_dma_chan *dwc) { - dev_err(chan2dev(&dwc->chan), + dev_err(dmaengine_chan_dev(&dwc->chan), " SAR: 0x%x DAR: 0x%x LLP: 0x%x CTL: 0x%x:%08x\n", channel_readl(dwc, SAR), channel_readl(dwc, DAR), @@ -177,7 +172,7 @@ static void dwc_dostart(struct dw_dma_chan *dwc, struct= dw_desc *first) =20 /* ASSERT: channel is idle */ if (dma_readl(dw, CH_EN) & dwc->mask) { - dev_err(chan2dev(&dwc->chan), + dev_err(dmaengine_chan_dev(&dwc->chan), "%s: BUG: Attempted to start non-idle channel\n", __func__); dwc_dump_chan_regs(dwc); @@ -190,7 +185,7 @@ static void dwc_dostart(struct dw_dma_chan *dwc, struct= dw_desc *first) was_soft_llp =3D test_and_set_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags); if (was_soft_llp) { - dev_err(chan2dev(&dwc->chan), + dev_err(dmaengine_chan_dev(&dwc->chan), "BUG: Attempted to start new LLP transfer inside ongoing one\n"); return; } @@ -223,7 +218,7 @@ static void dwc_dostart_first_queued(struct dw_dma_chan= *dwc) =20 list_move(dwc->queue.next, &dwc->active_list); desc =3D dwc_first_active(dwc); - dev_vdbg(chan2dev(&dwc->chan), "%s: started %u\n", __func__, desc->txd.co= okie); + dev_vdbg(dmaengine_chan_dev(&dwc->chan), "%s: started %u\n", __func__, de= sc->txd.cookie); dwc_dostart(dwc, desc); } =20 @@ -238,7 +233,7 @@ dwc_descriptor_complete(struct dw_dma_chan *dwc, struct= dw_desc *desc, unsigned long flags; struct dmaengine_desc_callback cb; =20 - dev_vdbg(chan2dev(&dwc->chan), "descriptor %u complete\n", txd->cookie); + dev_vdbg(dmaengine_chan_dev(&dwc->chan), "descriptor %u complete\n", txd-= >cookie); =20 spin_lock_irqsave(&dwc->lock, flags); dma_cookie_complete(txd); @@ -265,7 +260,7 @@ static void dwc_complete_all(struct dw_dma *dw, struct = dw_dma_chan *dwc) =20 spin_lock_irqsave(&dwc->lock, flags); if (dma_readl(dw, CH_EN) & dwc->mask) { - dev_err(chan2dev(&dwc->chan), + dev_err(dmaengine_chan_dev(&dwc->chan), "BUG: XFER bit set, but channel not idle!\n"); =20 /* Try to continue after resetting the channel... */ @@ -353,12 +348,12 @@ static void dwc_scan_descriptors(struct dw_dma *dw, s= truct dw_dma_chan *dwc) } =20 if (test_bit(DW_DMA_IS_SOFT_LLP, &dwc->flags)) { - dev_vdbg(chan2dev(&dwc->chan), "%s: soft LLP mode\n", __func__); + dev_vdbg(dmaengine_chan_dev(&dwc->chan), "%s: soft LLP mode\n", __func__= ); spin_unlock_irqrestore(&dwc->lock, flags); return; } =20 - dev_vdbg(chan2dev(&dwc->chan), "%s: llp=3D%pad\n", __func__, &llp); + dev_vdbg(dmaengine_chan_dev(&dwc->chan), "%s: llp=3D%pad\n", __func__, &l= lp); =20 list_for_each_entry_safe(desc, _desc, &dwc->active_list, desc_node) { /* Initial residue value */ @@ -398,7 +393,7 @@ static void dwc_scan_descriptors(struct dw_dma *dw, str= uct dw_dma_chan *dwc) spin_lock_irqsave(&dwc->lock, flags); } =20 - dev_err(chan2dev(&dwc->chan), + dev_err(dmaengine_chan_dev(&dwc->chan), "BUG: All descriptors done, but channel not idle!\n"); =20 /* Try to continue after resetting the channel... */ @@ -410,7 +405,7 @@ static void dwc_scan_descriptors(struct dw_dma *dw, str= uct dw_dma_chan *dwc) =20 static inline void dwc_dump_lli(struct dw_dma_chan *dwc, struct dw_desc *d= esc) { - dev_crit(chan2dev(&dwc->chan), " desc: s0x%x d0x%x l0x%x c0x%x:%x\n", + dev_crit(dmaengine_chan_dev(&dwc->chan), " desc: s0x%x d0x%x l0x%x c0x%x= :%x\n", lli_read(desc, sar), lli_read(desc, dar), lli_read(desc, llp), @@ -449,7 +444,7 @@ static void dwc_handle_error(struct dw_dma *dw, struct = dw_dma_chan *dwc) * controller flagged an error instead of scribbling over * random memory locations. */ - dev_WARN(chan2dev(&dwc->chan), "Bad descriptor submitted for DMA!\n" + dev_WARN(dmaengine_chan_dev(&dwc->chan), "Bad descriptor submitted for DM= A!\n" " cookie: %d\n", bad_desc->txd.cookie); dwc_dump_lli(dwc, bad_desc); list_for_each_entry(child, &bad_desc->tx_list, desc_node) @@ -552,12 +547,12 @@ dwc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t= dest, dma_addr_t src, u32 ctllo, ctlhi; u8 lms =3D DWC_LLP_LMS(m_master); =20 - dev_vdbg(chan2dev(chan), + dev_vdbg(dmaengine_chan_dev(chan), "%s: d%pad s%pad l0x%zx f0x%lx\n", __func__, &dest, &src, len, flags); =20 if (unlikely(!len)) { - dev_dbg(chan2dev(chan), "%s: length is zero!\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: length is zero!\n", __func__); return NULL; } =20 @@ -630,7 +625,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatter= list *sgl, struct scatterlist *sg; size_t total_len =3D 0; =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 if (unlikely(!is_slave_direction(direction) || !sg_len)) return NULL; @@ -754,7 +749,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatter= list *sgl, return &first->txd; =20 err_desc_get: - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "not enough descriptors available. Direction %d\n", direction); dwc_desc_put(dwc, first); return NULL; @@ -1063,11 +1058,11 @@ static int dwc_alloc_chan_resources(struct dma_chan= *chan) struct dw_dma_chan *dwc =3D to_dw_dma_chan(chan); struct dw_dma *dw =3D to_dw_dma(chan->device); =20 - dev_vdbg(chan2dev(chan), "%s\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s\n", __func__); =20 /* ASSERT: channel is idle */ if (dma_readl(dw, CH_EN) & dwc->mask) { - dev_dbg(chan2dev(chan), "DMA channel not idle?\n"); + dev_dbg(dmaengine_chan_dev(chan), "DMA channel not idle?\n"); return -EIO; } =20 @@ -1083,7 +1078,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *= chan) * We need controller-specific data to set up slave transfers. */ if (chan->private && !dw_dma_filter(chan, chan->private)) { - dev_warn(chan2dev(chan), "Wrong controller-specific data\n"); + dev_warn(dmaengine_chan_dev(chan), "Wrong controller-specific data\n"); return -EINVAL; } =20 @@ -1101,7 +1096,7 @@ static void dwc_free_chan_resources(struct dma_chan *= chan) struct dw_dma *dw =3D to_dw_dma(chan->device); unsigned long flags; =20 - dev_dbg(chan2dev(chan), "%s: descs allocated=3D%u\n", __func__, + dev_dbg(dmaengine_chan_dev(chan), "%s: descs allocated=3D%u\n", __func__, dwc->descs_allocated); =20 /* ASSERT: channel is idle */ @@ -1126,7 +1121,7 @@ static void dwc_free_chan_resources(struct dma_chan *= chan) if (!dw->in_use) do_dw_dma_off(dw); =20 - dev_vdbg(chan2dev(chan), "%s: done\n", __func__); + dev_vdbg(dmaengine_chan_dev(chan), "%s: done\n", __func__); } =20 static void dwc_caps(struct dma_chan *chan, struct dma_slave_caps *caps) diff --git a/drivers/dma/ep93xx_dma.c b/drivers/dma/ep93xx_dma.c index 311e55a97ba9f..cbfe74fc8d71e 100644 --- a/drivers/dma/ep93xx_dma.c +++ b/drivers/dma/ep93xx_dma.c @@ -250,11 +250,6 @@ struct ep93xx_edma_data { size_t num_channels; }; =20 -static inline struct device *chan2dev(struct ep93xx_dma_chan *edmac) -{ - return &edmac->chan.dev->device; -} - static struct ep93xx_dma_chan *to_ep93xx_dma_chan(struct dma_chan *chan) { return container_of(chan, struct ep93xx_dma_chan, chan); @@ -415,7 +410,7 @@ static void m2p_hw_shutdown(struct ep93xx_dma_chan *edm= ac) m2p_set_control(edmac, 0); =20 while (m2p_channel_state(edmac) !=3D M2P_STATE_IDLE) - dev_warn(chan2dev(edmac), "M2P: Not yet IDLE\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "M2P: Not yet IDLE\n"); } =20 static void m2p_fill_desc(struct ep93xx_dma_chan *edmac) @@ -425,7 +420,7 @@ static void m2p_fill_desc(struct ep93xx_dma_chan *edmac) =20 desc =3D ep93xx_dma_get_active(edmac); if (!desc) { - dev_warn(chan2dev(edmac), "M2P: empty descriptor list\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "M2P: empty descriptor list\n= "); return; } =20 @@ -479,7 +474,7 @@ static int m2p_hw_interrupt(struct ep93xx_dma_chan *edm= ac) * Revisit this when there is a mechanism to report back the * errors. */ - dev_err(chan2dev(edmac), + dev_err(dmaengine_chan_dev(&edmac->chan), "DMA transfer failed! Details:\n" "\tcookie : %d\n" "\tsrc_addr : 0x%08x\n" @@ -586,7 +581,7 @@ static void m2m_fill_desc(struct ep93xx_dma_chan *edmac) =20 desc =3D ep93xx_dma_get_active(edmac); if (!desc) { - dev_warn(chan2dev(edmac), "M2M: empty descriptor list\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "M2M: empty descriptor list\n= "); return; } =20 @@ -849,7 +844,7 @@ static irqreturn_t ep93xx_dma_interrupt(int irq, void *= dev_id) =20 desc =3D ep93xx_dma_get_active(edmac); if (!desc) { - dev_warn(chan2dev(edmac), + dev_warn(dmaengine_chan_dev(&edmac->chan), "got interrupt while active list is empty\n"); spin_unlock(&edmac->lock); return IRQ_NONE; @@ -867,7 +862,7 @@ static irqreturn_t ep93xx_dma_interrupt(int irq, void *= dev_id) break; =20 default: - dev_warn(chan2dev(edmac), "unknown interrupt!\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "unknown interrupt!\n"); ret =3D IRQ_NONE; break; } @@ -967,7 +962,7 @@ static int ep93xx_dma_alloc_chan_resources(struct dma_c= han *chan) =20 desc =3D kzalloc_obj(*desc); if (!desc) { - dev_warn(chan2dev(edmac), "not enough descriptors\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "not enough descriptors\n"); break; } =20 @@ -1044,7 +1039,7 @@ ep93xx_dma_prep_dma_memcpy(struct dma_chan *chan, dma= _addr_t dest, for (offset =3D 0; offset < len; offset +=3D bytes) { desc =3D ep93xx_dma_desc_get(edmac); if (!desc) { - dev_warn(chan2dev(edmac), "couldn't get descriptor\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "couldn't get descriptor\n"); goto fail; } =20 @@ -1091,13 +1086,13 @@ ep93xx_dma_prep_slave_sg(struct dma_chan *chan, str= uct scatterlist *sgl, int i; =20 if (!edmac->edma->m2m && dir !=3D ep93xx_dma_chan_direction(chan)) { - dev_warn(chan2dev(edmac), + dev_warn(dmaengine_chan_dev(&edmac->chan), "channel was configured with different direction\n"); return NULL; } =20 if (test_bit(EP93XX_DMA_IS_CYCLIC, &edmac->flags)) { - dev_warn(chan2dev(edmac), + dev_warn(dmaengine_chan_dev(&edmac->chan), "channel is already used for cyclic transfers\n"); return NULL; } @@ -1109,14 +1104,14 @@ ep93xx_dma_prep_slave_sg(struct dma_chan *chan, str= uct scatterlist *sgl, size_t len =3D sg_dma_len(sg); =20 if (len > DMA_MAX_CHAN_BYTES) { - dev_warn(chan2dev(edmac), "too big transfer size %zu\n", + dev_warn(dmaengine_chan_dev(&edmac->chan), "too big transfer size %zu\n= ", len); goto fail; } =20 desc =3D ep93xx_dma_desc_get(edmac); if (!desc) { - dev_warn(chan2dev(edmac), "couldn't get descriptor\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "couldn't get descriptor\n"); goto fail; } =20 @@ -1172,19 +1167,19 @@ ep93xx_dma_prep_dma_cyclic(struct dma_chan *chan, d= ma_addr_t dma_addr, size_t offset =3D 0; =20 if (!edmac->edma->m2m && dir !=3D ep93xx_dma_chan_direction(chan)) { - dev_warn(chan2dev(edmac), + dev_warn(dmaengine_chan_dev(&edmac->chan), "channel was configured with different direction\n"); return NULL; } =20 if (test_and_set_bit(EP93XX_DMA_IS_CYCLIC, &edmac->flags)) { - dev_warn(chan2dev(edmac), + dev_warn(dmaengine_chan_dev(&edmac->chan), "channel is already used for cyclic transfers\n"); return NULL; } =20 if (period_len > DMA_MAX_CHAN_BYTES) { - dev_warn(chan2dev(edmac), "too big period length %zu\n", + dev_warn(dmaengine_chan_dev(&edmac->chan), "too big period length %zu\n", period_len); return NULL; } @@ -1196,7 +1191,7 @@ ep93xx_dma_prep_dma_cyclic(struct dma_chan *chan, dma= _addr_t dma_addr, for (offset =3D 0; offset < buf_len; offset +=3D period_len) { desc =3D ep93xx_dma_desc_get(edmac); if (!desc) { - dev_warn(chan2dev(edmac), "couldn't get descriptor\n"); + dev_warn(dmaengine_chan_dev(&edmac->chan), "couldn't get descriptor\n"); goto fail; } =20 diff --git a/drivers/dma/idma64.c b/drivers/dma/idma64.c index e1fcce07d1c10..657629b100fa9 100644 --- a/drivers/dma/idma64.c +++ b/drivers/dma/idma64.c @@ -25,11 +25,6 @@ =20 /* ---------------------------------------------------------------------- = */ =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - /* ---------------------------------------------------------------------- = */ =20 static void idma64_off(struct idma64 *idma64) @@ -510,7 +505,7 @@ static int idma64_alloc_chan_resources(struct dma_chan = *chan) idma64c->pool =3D dma_pool_create(dma_chan_name(chan), chan->device->dev, sizeof(struct idma64_lli), 8, 0); if (!idma64c->pool) { - dev_err(chan2dev(chan), "No memory for descriptors\n"); + dev_err(dmaengine_chan_dev(chan), "No memory for descriptors\n"); return -ENOMEM; } =20 diff --git a/drivers/dma/loongson/loongson1-apb-dma.c b/drivers/dma/loongso= n/loongson1-apb-dma.c index 89786cbd20ab5..46b4bfef45e26 100644 --- a/drivers/dma/loongson/loongson1-apb-dma.c +++ b/drivers/dma/loongson/loongson1-apb-dma.c @@ -89,11 +89,6 @@ static irqreturn_t ls1x_dma_irq_handler(int irq, void *d= ata); #define to_ls1x_dma_desc(d) \ container_of(d, struct ls1x_dma_desc, vd) =20 -static inline struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline int ls1x_dma_query(struct ls1x_dma_chan *chan, dma_addr_t *lli_phys) { @@ -107,7 +102,7 @@ static inline int ls1x_dma_query(struct ls1x_dma_chan *= chan, ret =3D readl_poll_timeout_atomic(chan->reg_base + LS1X_DMA_CTRL, val, !(val & LS1X_DMA_ASK_VALID), 0, 3000); if (ret) - dev_err(chan2dev(dchan), "failed to query DMA\n"); + dev_err(dmaengine_chan_dev(dchan), "failed to query DMA\n"); =20 return ret; } @@ -116,7 +111,7 @@ static inline int ls1x_dma_start(struct ls1x_dma_chan *= chan, dma_addr_t *lli_phys) { struct dma_chan *dchan =3D &chan->vc.chan; - struct device *dev =3D chan2dev(dchan); + struct device *dev =3D dmaengine_chan_dev(dchan); int val, ret; =20 val =3D *lli_phys & LS1X_DMA_LLI_ADDR_MASK; @@ -143,7 +138,7 @@ static inline void ls1x_dma_stop(struct ls1x_dma_chan *= chan) static void ls1x_dma_free_chan_resources(struct dma_chan *dchan) { struct ls1x_dma_chan *chan =3D to_ls1x_dma_chan(dchan); - struct device *dev =3D chan2dev(dchan); + struct device *dev =3D dmaengine_chan_dev(dchan); =20 dma_free_coherent(dev, sizeof(struct ls1x_dma_lli), chan->curr_lli, chan->curr_lli->phys); @@ -156,7 +151,7 @@ static void ls1x_dma_free_chan_resources(struct dma_cha= n *dchan) static int ls1x_dma_alloc_chan_resources(struct dma_chan *dchan) { struct ls1x_dma_chan *chan =3D to_ls1x_dma_chan(dchan); - struct device *dev =3D chan2dev(dchan); + struct device *dev =3D dmaengine_chan_dev(dchan); dma_addr_t phys; int ret; =20 @@ -219,7 +214,7 @@ static int ls1x_dma_prep_lli(struct dma_chan *dchan, st= ruct ls1x_dma_desc *desc, { struct ls1x_dma_chan *chan =3D to_ls1x_dma_chan(dchan); struct ls1x_dma_lli *lli, *prev =3D NULL, *first =3D NULL; - struct device *dev =3D chan2dev(dchan); + struct device *dev =3D dmaengine_chan_dev(dchan); struct list_head *pos =3D NULL; struct scatterlist *sg; unsigned int dev_addr, cmd, i; @@ -299,7 +294,7 @@ ls1x_dma_prep_slave_sg(struct dma_chan *dchan, struct s= catterlist *sgl, { struct ls1x_dma_desc *desc; =20 - dev_dbg(chan2dev(dchan), "sg_len=3D%u flags=3D0x%lx dir=3D%s\n", + dev_dbg(dmaengine_chan_dev(dchan), "sg_len=3D%u flags=3D0x%lx dir=3D%s\n", sg_len, flags, dmaengine_get_direction_text(dir)); =20 desc =3D ls1x_dma_alloc_desc(); @@ -325,7 +320,7 @@ ls1x_dma_prep_dma_cyclic(struct dma_chan *dchan, dma_ad= dr_t buf_addr, unsigned int i; int ret; =20 - dev_dbg(chan2dev(dchan), + dev_dbg(dmaengine_chan_dev(dchan), "buf_len=3D%zu period_len=3D%zu flags=3D0x%lx dir=3D%s\n", buf_len, period_len, flags, dmaengine_get_direction_text(dir)); =20 @@ -450,7 +445,7 @@ static enum dma_status ls1x_dma_tx_status(struct dma_ch= an *dchan, if (lli->hw[LS1X_DMADESC_NEXT] =3D=3D next_phys) break; =20 - dev_dbg(chan2dev(dchan), "current lli_phys=3D%pad", + dev_dbg(dmaengine_chan_dev(dchan), "current lli_phys=3D%pad", &lli->phys); =20 /* count the residues */ @@ -489,7 +484,7 @@ static irqreturn_t ls1x_dma_irq_handler(int irq, void *= data) { struct ls1x_dma_chan *chan =3D data; struct dma_chan *dchan =3D &chan->vc.chan; - struct device *dev =3D chan2dev(dchan); + struct device *dev =3D dmaengine_chan_dev(dchan); struct virt_dma_desc *vd; =20 scoped_guard(spinlock, &chan->vc.lock) { diff --git a/drivers/dma/loongson/loongson2-apb-cmc-dma.c b/drivers/dma/loo= ngson/loongson2-apb-cmc-dma.c index 2f1c8c4fd0654..755363f4bfa2c 100644 --- a/drivers/dma/loongson/loongson2-apb-cmc-dma.c +++ b/drivers/dma/loongson/loongson2-apb-cmc-dma.c @@ -134,11 +134,6 @@ static struct loongson2_cmc_dma_desc *to_lmdma_desc(st= ruct virt_dma_desc *vdesc) return container_of(vdesc, struct loongson2_cmc_dma_desc, vdesc); } =20 -static struct device *chan2dev(struct loongson2_cmc_dma_chan *lchan) -{ - return &lchan->vchan.chan.dev->device; -} - static u32 loongson2_cmc_dma_read(struct loongson2_cmc_dma_dev *lddev, u32= reg, u32 id) { return readl(lddev->base + (reg + lddev->chan_reg_offset * id)); @@ -302,7 +297,7 @@ static irqreturn_t loongson2_cmc_dma_chan_irq(int irq, = void *devid) { struct loongson2_cmc_dma_chan *lchan =3D devid; struct loongson2_cmc_dma_dev *lddev =3D lmdma_get_dev(lchan); - struct device *dev =3D chan2dev(lchan); + struct device *dev =3D vchan_chan_dev(&lchan->vchan); u32 ists, status, ccr; =20 scoped_guard(spinlock, &lchan->vchan.lock) { @@ -337,7 +332,7 @@ static void loongson2_cmc_dma_issue_pending(struct dma_= chan *chan) guard(spinlock_irqsave)(&lchan->vchan.lock); =20 if (vchan_issue_pending(&lchan->vchan) && !lchan->desc) { - dev_dbg(chan2dev(lchan), "vchan %pK: issued\n", &lchan->vchan); + dev_dbg(vchan_chan_dev(&lchan->vchan), "vchan %pK: issued\n", &lchan->vc= han); loongson2_cmc_dma_start_transfer(lchan); } } @@ -347,7 +342,7 @@ static int loongson2_cmc_dma_set_xfer_param(struct loon= gson2_cmc_dma_chan *lchan enum dma_slave_buswidth *buswidth, u32 buf_len) { struct dma_slave_config sconfig =3D lchan->dma_sconfig; - struct device *dev =3D chan2dev(lchan); + struct device *dev =3D vchan_chan_dev(&lchan->vchan); int dev_width; u32 ccr; =20 @@ -409,7 +404,7 @@ loongson2_cmc_dma_prep_slave_sg(struct dma_chan *chan, = struct scatterlist *sgl, =20 num_items =3D DIV_ROUND_UP(sg_dma_len(sg), buswidth); if (num_items >=3D LOONSON2_CMCDMA_MAX_DATA_ITEMS) { - dev_err(chan2dev(lchan), "Number of items not supported\n"); + dev_err(vchan_chan_dev(&lchan->vchan), "Number of items not supported\n= "); kfree(desc); return ERR_PTR(-EINVAL); } @@ -447,7 +442,7 @@ loongson2_cmc_dma_prep_dma_cyclic(struct dma_chan *chan= , dma_addr_t buf_addr, si =20 num_items =3D DIV_ROUND_UP(period_len, buswidth); if (num_items >=3D LOONSON2_CMCDMA_MAX_DATA_ITEMS) { - dev_err(chan2dev(lchan), "Number of items not supported\n"); + dev_err(vchan_chan_dev(&lchan->vchan), "Number of items not supported\n"= ); return ERR_PTR(-EINVAL); } =20 diff --git a/drivers/dma/loongson/loongson2-apb-dma.c b/drivers/dma/loongso= n/loongson2-apb-dma.c index 7c3d7c3273955..16a0c1c60d59a 100644 --- a/drivers/dma/loongson/loongson2-apb-dma.c +++ b/drivers/dma/loongson/loongson2-apb-dma.c @@ -161,11 +161,6 @@ static inline struct ls2x_dma_priv *to_ldma_priv(struc= t dma_device *ddev) return container_of(ddev, struct ls2x_dma_priv, ddev); } =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static void ls2x_dma_desc_free(struct virt_dma_desc *vdesc) { struct ls2x_dma_chan *lchan =3D to_ldma_chan(vdesc->tx.chan); @@ -286,7 +281,7 @@ static int ls2x_dma_alloc_chan_resources(struct dma_cha= n *chan) chan->device->dev, PAGE_SIZE, __alignof__(struct ls2x_dma_hw_desc), 0); if (!lchan->pool) { - dev_err(chan2dev(chan), "No memory for descriptors\n"); + dev_err(dmaengine_chan_dev(chan), "No memory for descriptors\n"); return -ENOMEM; } =20 diff --git a/drivers/dma/moxart-dma.c b/drivers/dma/moxart-dma.c index 442f5aa16031f..28be93eed4cce 100644 --- a/drivers/dma/moxart-dma.c +++ b/drivers/dma/moxart-dma.c @@ -154,11 +154,6 @@ static const unsigned int es_bytes[] =3D { [MOXART_DMA_DATA_TYPE_S32] =3D 4, }; =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline struct moxart_chan *to_moxart_dma_chan(struct dma_chan *c) { return container_of(c, struct moxart_chan, vc.chan); @@ -182,7 +177,7 @@ static int moxart_terminate_all(struct dma_chan *chan) LIST_HEAD(head); u32 ctrl; =20 - dev_dbg(chan2dev(chan), "%s: ch=3D%p\n", __func__, ch); + dev_dbg(dmaengine_chan_dev(chan), "%s: ch=3D%p\n", __func__, ch); =20 spin_lock_irqsave(&ch->vc.lock, flags); =20 @@ -272,7 +267,7 @@ static struct dma_async_tx_descriptor *moxart_prep_slav= e_sg( unsigned int i; =20 if (!is_slave_direction(dir)) { - dev_err(chan2dev(chan), "%s: invalid DMA direction\n", + dev_err(dmaengine_chan_dev(chan), "%s: invalid DMA direction\n", __func__); return NULL; } @@ -296,7 +291,7 @@ static struct dma_async_tx_descriptor *moxart_prep_slav= e_sg( es =3D MOXART_DMA_DATA_TYPE_S32; break; default: - dev_err(chan2dev(chan), "%s: unsupported data width (%u)\n", + dev_err(dmaengine_chan_dev(chan), "%s: unsupported data width (%u)\n", __func__, dev_width); return NULL; } @@ -341,7 +336,7 @@ static int moxart_alloc_chan_resources(struct dma_chan = *chan) { struct moxart_chan *ch =3D to_moxart_dma_chan(chan); =20 - dev_dbg(chan2dev(chan), "%s: allocating channel #%u\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: allocating channel #%u\n", __func__, ch->ch_num); ch->allocated =3D 1; =20 @@ -354,7 +349,7 @@ static void moxart_free_chan_resources(struct dma_chan = *chan) =20 vchan_free_chan_resources(&ch->vc); =20 - dev_dbg(chan2dev(chan), "%s: freeing channel #%u\n", + dev_dbg(dmaengine_chan_dev(chan), "%s: freeing channel #%u\n", __func__, ch->ch_num); ch->allocated =3D 0; } @@ -379,7 +374,7 @@ static void moxart_set_transfer_params(struct moxart_ch= an *ch, unsigned int len) */ writel(d->dma_cycles, ch->base + REG_OFF_CYCLES); =20 - dev_dbg(chan2dev(&ch->vc.chan), "%s: set %u DMA cycles (len=3D%u)\n", + dev_dbg(vchan_chan_dev(&ch->vc), "%s: set %u DMA cycles (len=3D%u)\n", __func__, d->dma_cycles, len); } =20 @@ -460,7 +455,7 @@ static size_t moxart_dma_desc_size_in_flight(struct mox= art_chan *ch) completed_cycles =3D (ch->desc->dma_cycles - cycles); size -=3D completed_cycles << es_bytes[ch->desc->es]; =20 - dev_dbg(chan2dev(&ch->vc.chan), "%s: size=3D%zu\n", __func__, size); + dev_dbg(vchan_chan_dev(&ch->vc), "%s: size=3D%zu\n", __func__, size); =20 return size; } @@ -517,7 +512,7 @@ static irqreturn_t moxart_dma_interrupt(int irq, void *= devid) unsigned int i; u32 ctrl; =20 - dev_dbg(chan2dev(&ch->vc.chan), "%s\n", __func__); + dev_dbg(vchan_chan_dev(&ch->vc), "%s\n", __func__); =20 for (i =3D 0; i < APB_DMA_MAX_CHANNEL; i++, ch++) { if (!ch->allocated) @@ -525,7 +520,7 @@ static irqreturn_t moxart_dma_interrupt(int irq, void *= devid) =20 ctrl =3D readl(ch->base + REG_OFF_CTRL); =20 - dev_dbg(chan2dev(&ch->vc.chan), "%s: ch=3D%p ch->base=3D%p ctrl=3D%x\n", + dev_dbg(vchan_chan_dev(&ch->vc), "%s: ch=3D%p ch->base=3D%p ctrl=3D%x\n", __func__, ch, ch->base, ctrl); =20 if (ctrl & APB_DMA_FIN_INT_STS) { diff --git a/drivers/dma/nbpfaxi.c b/drivers/dma/nbpfaxi.c index 05d7321629cc8..744cd14d78725 100644 --- a/drivers/dma/nbpfaxi.c +++ b/drivers/dma/nbpfaxi.c @@ -1202,7 +1202,7 @@ static irqreturn_t nbpf_chan_irq(int irq, void *dev) =20 nbpf_status_ack(chan); =20 - dev_dbg(&chan->dma_chan.dev->device, "%s()\n", __func__); + dev_dbg(dmaengine_chan_dev(&chan->dma_chan), "%s()\n", __func__); =20 spin_lock(&chan->lock); desc =3D chan->running; diff --git a/drivers/dma/owl-dma.c b/drivers/dma/owl-dma.c index 7c80572fc71d1..9dc88d804a2e4 100644 --- a/drivers/dma/owl-dma.c +++ b/drivers/dma/owl-dma.c @@ -292,11 +292,6 @@ static inline struct owl_dma *to_owl_dma(struct dma_de= vice *dd) return container_of(dd, struct owl_dma, dma); } =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline struct owl_dma_vchan *to_owl_vchan(struct dma_chan *chan) { return container_of(chan, struct owl_dma_vchan, vc.chan); @@ -573,7 +568,7 @@ static int owl_dma_start_next_txd(struct owl_dma_vchan = *vchan) =20 spin_unlock_irqrestore(&od->lock, flags); =20 - dev_dbg(chan2dev(&vchan->vc.chan), "starting pchan %d\n", pchan->id); + dev_dbg(vchan_chan_dev(&vchan->vc), "starting pchan %d\n", pchan->id); =20 /* Start DMA transfer for this pchan */ pchan_writel(pchan, OWL_DMAX_START, 0x1); @@ -757,7 +752,7 @@ static int owl_dma_resume(struct dma_chan *chan) if (!vchan->pchan && !vchan->txd) return 0; =20 - dev_dbg(chan2dev(chan), "vchan %p: resume\n", &vchan->vc); + dev_dbg(dmaengine_chan_dev(chan), "vchan %p: resume\n", &vchan->vc); =20 spin_lock_irqsave(&vchan->vc.lock, flags); =20 @@ -888,7 +883,7 @@ static struct dma_async_tx_descriptor for (offset =3D 0; offset < len; offset +=3D bytes) { lli =3D owl_dma_alloc_lli(od); if (!lli) { - dev_warn(chan2dev(chan), "failed to allocate lli\n"); + dev_warn(dmaengine_chan_dev(chan), "failed to allocate lli\n"); goto err_txd_free; } =20 @@ -898,7 +893,7 @@ static struct dma_async_tx_descriptor bytes, DMA_MEM_TO_MEM, &vchan->cfg, txd->cyclic); if (ret) { - dev_warn(chan2dev(chan), "failed to config lli\n"); + dev_warn(dmaengine_chan_dev(chan), "failed to config lli\n"); goto err_txd_free; } =20 @@ -947,7 +942,7 @@ static struct dma_async_tx_descriptor =20 lli =3D owl_dma_alloc_lli(od); if (!lli) { - dev_err(chan2dev(chan), "failed to allocate lli"); + dev_err(dmaengine_chan_dev(chan), "failed to allocate lli"); goto err_txd_free; } =20 @@ -962,7 +957,7 @@ static struct dma_async_tx_descriptor ret =3D owl_dma_cfg_lli(vchan, lli, src, dst, len, dir, sconfig, txd->cyclic); if (ret) { - dev_warn(chan2dev(chan), "failed to config lli"); + dev_warn(dmaengine_chan_dev(chan), "failed to config lli"); goto err_txd_free; } =20 @@ -1003,7 +998,7 @@ static struct dma_async_tx_descriptor for (i =3D 0; i < periods; i++) { lli =3D owl_dma_alloc_lli(od); if (!lli) { - dev_warn(chan2dev(chan), "failed to allocate lli"); + dev_warn(dmaengine_chan_dev(chan), "failed to allocate lli"); goto err_txd_free; } =20 @@ -1018,7 +1013,7 @@ static struct dma_async_tx_descriptor ret =3D owl_dma_cfg_lli(vchan, lli, src, dst, period_len, dir, sconfig, txd->cyclic); if (ret) { - dev_warn(chan2dev(chan), "failed to config lli"); + dev_warn(dmaengine_chan_dev(chan), "failed to config lli"); goto err_txd_free; } =20 diff --git a/drivers/dma/pch_dma.c b/drivers/dma/pch_dma.c index bf805f1024f64..88baf7ffec375 100644 --- a/drivers/dma/pch_dma.c +++ b/drivers/dma/pch_dma.c @@ -150,11 +150,6 @@ static inline struct pch_dma *to_pd(struct dma_device = *ddev) return container_of(ddev, struct pch_dma, dma); } =20 -static inline struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline struct pch_dma_desc *pdc_first_active(struct pch_dma_chan *pd_chan) { @@ -189,7 +184,7 @@ static void pdc_enable_irq(struct dma_chan *chan, int e= nable) =20 dma_writel(pd, CTL2, val); =20 - dev_dbg(chan2dev(chan), "pdc_enable_irq: chan %d -> %x\n", + dev_dbg(dmaengine_chan_dev(chan), "pdc_enable_irq: chan %d -> %x\n", chan->chan_id, val); } =20 @@ -237,7 +232,7 @@ static void pdc_set_dir(struct dma_chan *chan) dma_writel(pd, CTL3, val); } =20 - dev_dbg(chan2dev(chan), "pdc_set_dir: chan %d -> %x\n", + dev_dbg(dmaengine_chan_dev(chan), "pdc_set_dir: chan %d -> %x\n", chan->chan_id, val); } =20 @@ -271,7 +266,7 @@ static void pdc_set_mode(struct dma_chan *chan, u32 mod= e) dma_writel(pd, CTL3, val); } =20 - dev_dbg(chan2dev(chan), "pdc_set_mode: chan %d -> %x\n", + dev_dbg(dmaengine_chan_dev(chan), "pdc_set_mode: chan %d -> %x\n", chan->chan_id, val); } =20 @@ -314,18 +309,18 @@ static bool pdc_is_idle(struct pch_dma_chan *pd_chan) static void pdc_dostart(struct pch_dma_chan *pd_chan, struct pch_dma_desc*= desc) { if (!pdc_is_idle(pd_chan)) { - dev_err(chan2dev(&pd_chan->chan), + dev_err(dmaengine_chan_dev(&pd_chan->chan), "BUG: Attempt to start non-idle channel\n"); return; } =20 - dev_dbg(chan2dev(&pd_chan->chan), "chan %d -> dev_addr: %x\n", + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "chan %d -> dev_addr: %x\n", pd_chan->chan.chan_id, desc->regs.dev_addr); - dev_dbg(chan2dev(&pd_chan->chan), "chan %d -> mem_addr: %x\n", + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "chan %d -> mem_addr: %x\n", pd_chan->chan.chan_id, desc->regs.mem_addr); - dev_dbg(chan2dev(&pd_chan->chan), "chan %d -> size: %x\n", + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "chan %d -> size: %x\n", pd_chan->chan.chan_id, desc->regs.size); - dev_dbg(chan2dev(&pd_chan->chan), "chan %d -> next: %x\n", + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "chan %d -> next: %x\n", pd_chan->chan.chan_id, desc->regs.next); =20 if (list_empty(&desc->tx_list)) { @@ -382,8 +377,8 @@ static void pdc_handle_error(struct pch_dma_chan *pd_ch= an) if (!list_empty(&pd_chan->active_list)) pdc_dostart(pd_chan, pdc_first_active(pd_chan)); =20 - dev_crit(chan2dev(&pd_chan->chan), "Bad descriptor submitted\n"); - dev_crit(chan2dev(&pd_chan->chan), "descriptor cookie: %d\n", + dev_crit(dmaengine_chan_dev(&pd_chan->chan), "Bad descriptor submitted\n"= ); + dev_crit(dmaengine_chan_dev(&pd_chan->chan), "descriptor cookie: %d\n", bad_desc->txd.cookie); =20 pdc_chain_complete(pd_chan, bad_desc); @@ -450,10 +445,10 @@ static struct pch_dma_desc *pdc_desc_get(struct pch_d= ma_chan *pd_chan) ret =3D desc; break; } - dev_dbg(chan2dev(&pd_chan->chan), "desc %p not ACKed\n", desc); + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "desc %p not ACKed\n", desc); } spin_unlock(&pd_chan->lock); - dev_dbg(chan2dev(&pd_chan->chan), "scanned %d descriptors\n", i); + dev_dbg(dmaengine_chan_dev(&pd_chan->chan), "scanned %d descriptors\n", i= ); =20 if (!ret) { ret =3D pdc_alloc_desc(&pd_chan->chan, GFP_ATOMIC); @@ -462,7 +457,7 @@ static struct pch_dma_desc *pdc_desc_get(struct pch_dma= _chan *pd_chan) pd_chan->descs_allocated++; spin_unlock(&pd_chan->lock); } else { - dev_err(chan2dev(&pd_chan->chan), + dev_err(dmaengine_chan_dev(&pd_chan->chan), "failed to alloc desc\n"); } } @@ -489,7 +484,7 @@ static int pd_alloc_chan_resources(struct dma_chan *cha= n) int i; =20 if (!pdc_is_idle(pd_chan)) { - dev_dbg(chan2dev(chan), "DMA channel not idle ?\n"); + dev_dbg(dmaengine_chan_dev(chan), "DMA channel not idle ?\n"); return -EIO; } =20 @@ -500,7 +495,7 @@ static int pd_alloc_chan_resources(struct dma_chan *cha= n) desc =3D pdc_alloc_desc(chan, GFP_KERNEL); =20 if (!desc) { - dev_warn(chan2dev(chan), + dev_warn(dmaengine_chan_dev(chan), "Only allocated %d initial descriptors\n", i); break; } @@ -573,7 +568,7 @@ static struct dma_async_tx_descriptor *pd_prep_slave_sg= (struct dma_chan *chan, int i; =20 if (unlikely(!sg_len)) { - dev_info(chan2dev(chan), "prep_slave_sg: length is zero!\n"); + dev_info(dmaengine_chan_dev(chan), "prep_slave_sg: length is zero!\n"); return NULL; } =20 @@ -639,7 +634,7 @@ static struct dma_async_tx_descriptor *pd_prep_slave_sg= (struct dma_chan *chan, return &first->txd; =20 err_desc_get: - dev_err(chan2dev(chan), "failed to get desc or wrong parameters\n"); + dev_err(dmaengine_chan_dev(chan), "failed to get desc or wrong parameters= \n"); pdc_desc_put(pd_chan, first); return NULL; } @@ -671,7 +666,7 @@ static void pdc_tasklet(struct tasklet_struct *t) unsigned long flags; =20 if (!pdc_is_idle(pd_chan)) { - dev_err(chan2dev(&pd_chan->chan), + dev_err(dmaengine_chan_dev(&pd_chan->chan), "BUG: handle non-idle channel in tasklet\n"); return; } diff --git a/drivers/dma/pxa_dma.c b/drivers/dma/pxa_dma.c index fa2ee0b3e09f8..b552b34f2a672 100644 --- a/drivers/dma/pxa_dma.c +++ b/drivers/dma/pxa_dma.c @@ -149,7 +149,7 @@ struct pxad_device { ({ \ u32 _v; \ _v =3D readl_relaxed((phy)->base + _reg((phy)->idx)); \ - dev_vdbg(&phy->vchan->vc.chan.dev->device, \ + dev_vdbg(vchan_chan_dev(&phy->vchan->vc), \ "%s(): readl(%s): 0x%08x\n", __func__, #_reg, \ _v); \ _v; \ @@ -157,14 +157,14 @@ struct pxad_device { #define phy_writel(phy, val, _reg) \ do { \ writel((val), (phy)->base + _reg((phy)->idx)); \ - dev_vdbg(&phy->vchan->vc.chan.dev->device, \ + dev_vdbg(vchan_chan_dev(&phy->vchan->vc), \ "%s(): writel(0x%08x, %s)\n", \ __func__, (u32)(val), #_reg); \ } while (0) #define phy_writel_relaxed(phy, val, _reg) \ do { \ writel_relaxed((val), (phy)->base + _reg((phy)->idx)); \ - dev_vdbg(&phy->vchan->vc.chan.dev->device, \ + dev_vdbg(vchan_chan_dev(&phy->vchan->vc), \ "%s(): writel_relaxed(0x%08x, %s)\n", \ __func__, (u32)(val), #_reg); \ } while (0) @@ -396,7 +396,7 @@ static struct pxad_phy *lookup_phy(struct pxad_chan *pc= han) =20 out_unlock: spin_unlock_irqrestore(&pdev->phy_lock, flags); - dev_dbg(&pchan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&pchan->vc), "%s(): phy=3D%p(%d)\n", __func__, found, found ? found->idx : -1); =20 @@ -409,7 +409,7 @@ static void pxad_free_phy(struct pxad_chan *chan) unsigned long flags; u32 reg; =20 - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): freeing\n", __func__); if (!chan->phy) return; @@ -454,7 +454,7 @@ static void phy_enable(struct pxad_phy *phy, bool misal= igned) if (!phy->vchan) return; =20 - dev_dbg(&phy->vchan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&phy->vchan->vc), "%s(); phy=3D%p(%d) misaligned=3D%d\n", __func__, phy, phy->idx, misaligned); =20 @@ -483,7 +483,7 @@ static void phy_disable(struct pxad_phy *phy) return; =20 dcsr =3D phy_readl_relaxed(phy, DCSR); - dev_dbg(&phy->vchan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&phy->vchan->vc), "%s(): phy=3D%p(%d)\n", __func__, phy, phy->idx); phy_writel(phy, dcsr & ~PXA_DCSR_RUN & ~PXA_DCSR_STOPIRQEN, DCSR); } @@ -491,12 +491,12 @@ static void phy_disable(struct pxad_phy *phy) static void pxad_launch_chan(struct pxad_chan *chan, struct pxad_desc_sw *desc) { - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): desc=3D%p\n", __func__, desc); if (!chan->phy) { chan->phy =3D lookup_phy(chan); if (!chan->phy) { - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): no free dma channel\n", __func__); return; } @@ -592,7 +592,7 @@ static unsigned int clear_chan_irq(struct pxad_phy *phy) dcsr =3D phy_readl_relaxed(phy, DCSR); phy_writel(phy, dcsr, DCSR); if ((dcsr & PXA_DCSR_BUSERR) && (phy->vchan)) - dev_warn(&phy->vchan->vc.chan.dev->device, + dev_warn(vchan_chan_dev(&phy->vchan->vc), "%s(chan=3D%p): PXA_DCSR_BUSERR\n", __func__, &phy->vchan); =20 @@ -617,7 +617,7 @@ static irqreturn_t pxad_chan_handler(int irq, void *dev= _id) spin_lock(&chan->vc.lock); list_for_each_entry_safe(vd, tmp, &chan->vc.desc_issued, node) { vd_completed =3D is_desc_completed(vd); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): checking txd %p[%x]: completed=3D%d dcsr=3D0x%x\n", __func__, vd, vd->tx.cookie, vd_completed, dcsr); @@ -640,7 +640,7 @@ static irqreturn_t pxad_chan_handler(int irq, void *dev= _id) } =20 if (!chan->bus_error && dcsr & PXA_DCSR_STOPSTATE) { - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): channel stopped, submitted_empty=3D%d issued_empty=3D%d", __func__, list_empty(&chan->vc.desc_submitted), @@ -694,7 +694,7 @@ static int pxad_alloc_chan_resources(struct dma_chan *d= chan) __alignof__(struct pxad_desc_hw), 0); if (!chan->desc_pool) { - dev_err(&chan->vc.chan.dev->device, + dev_err(vchan_chan_dev(&chan->vc), "%s(): unable to allocate descriptor pool\n", __func__); return -ENOMEM; @@ -749,7 +749,7 @@ pxad_alloc_desc(struct pxad_chan *chan, unsigned int nb= _hw_desc) for (i =3D 0; i < nb_hw_desc; i++) { desc =3D dma_pool_alloc(sw_desc->desc_pool, GFP_NOWAIT, &dma); if (!desc) { - dev_err(&chan->vc.chan.dev->device, + dev_err(vchan_chan_dev(&chan->vc), "%s(): Couldn't allocate the %dth hw_desc from dma_pool %p\n", __func__, i, sw_desc->desc_pool); goto err; @@ -786,7 +786,7 @@ static dma_cookie_t pxad_tx_submit(struct dma_async_tx_= descriptor *tx) =20 if (list_empty(&vc->desc_submitted) && pxad_try_hotchain(vc, vd)) { list_move_tail(&vd->node, &vc->desc_issued); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): txd %p[%x]: submitted (hot linked)\n", __func__, vd, cookie); goto out; @@ -809,7 +809,7 @@ static dma_cookie_t pxad_tx_submit(struct dma_async_tx_= descriptor *tx) else vd_chained =3D NULL; } - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): txd %p[%x]: submitted (%s linked)\n", __func__, vd, cookie, vd_chained ? "cold" : "not"); list_move_tail(&vd->node, &vc->desc_submitted); @@ -832,7 +832,7 @@ static void pxad_issue_pending(struct dma_chan *dchan) =20 vd_first =3D list_first_entry(&chan->vc.desc_submitted, struct virt_dma_desc, node); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): txd %p[%x]", __func__, vd_first, vd_first->tx.cookie); =20 vchan_issue_pending(&chan->vc); @@ -852,7 +852,7 @@ pxad_tx_prep(struct virt_dma_chan *vc, struct virt_dma_= desc *vd, INIT_LIST_HEAD(&vd->node); tx =3D vchan_tx_prep(vc, vd, tx_flags); tx->tx_submit =3D pxad_tx_submit; - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): vc=3D%p txd=3D%p[%x] flags=3D0x%lx\n", __func__, vc, vd, vd->tx.cookie, tx_flags); @@ -891,7 +891,7 @@ static void pxad_get_config(struct pxad_chan *chan, *dcmd |=3D PXA_DCMD_BURST32 | PXA_DCMD_INCTRGADDR | PXA_DCMD_INCSRCADDR; =20 - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): dev_addr=3D0x%x maxburst=3D%d width=3D%d dir=3D%d\n", __func__, dev_addr, maxburst, width, dir); =20 @@ -925,7 +925,7 @@ pxad_prep_memcpy(struct dma_chan *dchan, if (!dchan || !len) return NULL; =20 - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): dma_dst=3D0x%lx dma_src=3D0x%lx len=3D%zu flags=3D%lx\n", __func__, (unsigned long)dma_dst, (unsigned long)dma_src, len, flags); @@ -974,7 +974,7 @@ pxad_prep_slave_sg(struct dma_chan *dchan, struct scatt= erlist *sgl, return NULL; =20 pxad_get_config(chan, dir, &dcmd, &dsadr, &dtadr); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): dir=3D%d flags=3D%lx\n", __func__, dir, flags); =20 nb_desc =3D sg_nents_for_dma(sgl, sg_len, PDMA_MAX_DESC_BYTES); @@ -1021,7 +1021,7 @@ pxad_prep_dma_cyclic(struct dma_chan *dchan, if (!dchan || !len || !period_len) return NULL; if ((dir !=3D DMA_DEV_TO_MEM) && (dir !=3D DMA_MEM_TO_DEV)) { - dev_err(&chan->vc.chan.dev->device, + dev_err(vchan_chan_dev(&chan->vc), "Unsupported direction for cyclic DMA\n"); return NULL; } @@ -1032,7 +1032,7 @@ pxad_prep_dma_cyclic(struct dma_chan *dchan, =20 pxad_get_config(chan, dir, &dcmd, &dsadr, &dtadr); dcmd |=3D PXA_DCMD_ENDIRQEN | (PXA_DCMD_LENGTH & period_len); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): buf_addr=3D0x%lx len=3D%zu period=3D%zu dir=3D%d flags=3D%lx\n", __func__, (unsigned long)buf_addr, len, period_len, dir, flags); =20 @@ -1080,14 +1080,14 @@ static int pxad_terminate_all(struct dma_chan *dcha= n) struct pxad_phy *phy; LIST_HEAD(head); =20 - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): vchan %p: terminate all\n", __func__, &chan->vc); =20 spin_lock_irqsave(&chan->vc.lock, flags); vchan_get_all_descriptors(&chan->vc, &head); =20 list_for_each_entry(vd, &head, node) { - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): cancelling txd %p[%x] (completed=3D%d)", __func__, vd, vd->tx.cookie, is_desc_completed(vd)); } @@ -1177,7 +1177,7 @@ static unsigned int pxad_residue(struct pxad_chan *ch= an, =20 out: spin_unlock_irqrestore(&chan->vc.lock, flags); - dev_dbg(&chan->vc.chan.dev->device, + dev_dbg(vchan_chan_dev(&chan->vc), "%s(): txd %p[%x] sw_desc=3D%p: %d\n", __func__, vd, cookie, sw_desc, residue); return residue; diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c index 0d9ffa3e26639..05e797496cae7 100644 --- a/drivers/dma/ste_dma40.c +++ b/drivers/dma/ste_dma40.c @@ -623,11 +623,6 @@ struct d40_base { struct d40_chan phy_chans[]; }; =20 -static struct device *chan2dev(struct d40_chan *d40c) -{ - return &d40c->chan.dev->device; -} - static bool chan_is_physical(struct d40_chan *chan) { return chan->log_num =3D=3D D40_PHY_CHAN; @@ -648,7 +643,7 @@ static void __iomem *chan_base(struct d40_chan *chan) dev_err(dev, "[%s] " format, __func__, ## arg) =20 #define chan_err(d40c, format, arg...) \ - d40_err(chan2dev(d40c), format, ## arg) + d40_err(dmaengine_chan_dev(&d40c->chan), format, ## arg) =20 static int d40_set_runtime_config_write(struct dma_chan *chan, struct dma_slave_config *config, @@ -1243,7 +1238,7 @@ static void __d40_config_set_event(struct d40_chan *d= 40c, } =20 if (tries !=3D 99) - dev_dbg(chan2dev(d40c), + dev_dbg(dmaengine_chan_dev(&d40c->chan), "[%s] workaround enable S%cLNK (%d tries)\n", __func__, reg =3D=3D D40_CHAN_REG_SSLNK ? 'S' : 'D', 100 - tries); @@ -1924,7 +1919,7 @@ static int d40_allocate_channel(struct d40_chan *d40c= , bool *first_phy_user) i =3D d40c->dma_cfg.phy_channel; =20 if ((i !=3D phy_num) && (i !=3D phy_num + 1)) { - dev_err(chan2dev(d40c), + dev_err(dmaengine_chan_dev(&d40c->chan), "invalid fixed phy channel %d\n", i); return -EINVAL; } @@ -1933,7 +1928,7 @@ static int d40_allocate_channel(struct d40_chan *d40c= , bool *first_phy_user) is_log, first_phy_user)) goto found_log; =20 - dev_err(chan2dev(d40c), + dev_err(dmaengine_chan_dev(&d40c->chan), "could not allocate fixed phy channel %d\n", i); return -EINVAL; } @@ -2446,7 +2441,7 @@ static int d40_alloc_chan_resources(struct dma_chan *= chan) d40c->dst_def_cfg |=3D BIT(D40_SREG_CFG_LOG_GIM_POS); } =20 - dev_dbg(chan2dev(d40c), "allocated %s channel (phy %d%s)\n", + dev_dbg(dmaengine_chan_dev(&d40c->chan), "allocated %s channel (phy %d%s)= \n", chan_is_logical(d40c) ? "logical" : "physical", d40c->phy_chan->num, d40c->dma_cfg.use_fixed_channel ? ", fixed" : ""); diff --git a/drivers/dma/stm32/stm32-dma.c b/drivers/dma/stm32/stm32-dma.c index 3e8151e2ad75a..4688cebaf7f7a 100644 --- a/drivers/dma/stm32/stm32-dma.c +++ b/drivers/dma/stm32/stm32-dma.c @@ -248,11 +248,6 @@ static struct stm32_dma_desc *to_stm32_dma_desc(struct= virt_dma_desc *vdesc) return container_of(vdesc, struct stm32_dma_desc, vdesc); } =20 -static struct device *chan2dev(struct stm32_dma_chan *chan) -{ - return &chan->vchan.chan.dev->device; -} - static u32 stm32_dma_read(struct stm32_dma_device *dmadev, u32 reg) { return readl_relaxed(dmadev->base + reg); @@ -274,7 +269,7 @@ static int stm32_dma_get_width(struct stm32_dma_chan *c= han, case DMA_SLAVE_BUSWIDTH_4_BYTES: return STM32_DMA_WORD; default: - dev_err(chan2dev(chan), "Dma bus width not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Dma bus width not supported\n"); return -EINVAL; } } @@ -374,7 +369,7 @@ static int stm32_dma_get_burst(struct stm32_dma_chan *c= han, u32 maxburst) case 16: return STM32_DMA_BURST_INCR16; default: - dev_err(chan2dev(chan), "Dma burst size not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Dma burst size not supported\n"); return -EINVAL; } } @@ -487,7 +482,7 @@ static void stm32_dma_stop(struct stm32_dma_chan *chan) /* Clear interrupt status if it is there */ status =3D stm32_dma_irq_status(chan); if (status) { - dev_dbg(chan2dev(chan), "%s(): clearing interrupt: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "%s(): clearing interrupt: 0x%08x\= n", __func__, status); stm32_dma_irq_clear(chan, status); } @@ -536,12 +531,12 @@ static void stm32_dma_dump_reg(struct stm32_dma_chan = *chan) u32 sm1ar =3D stm32_dma_read(dmadev, STM32_DMA_SM1AR(chan->id)); u32 sfcr =3D stm32_dma_read(dmadev, STM32_DMA_SFCR(chan->id)); =20 - dev_dbg(chan2dev(chan), "SCR: 0x%08x\n", scr); - dev_dbg(chan2dev(chan), "NDTR: 0x%08x\n", ndtr); - dev_dbg(chan2dev(chan), "SPAR: 0x%08x\n", spar); - dev_dbg(chan2dev(chan), "SM0AR: 0x%08x\n", sm0ar); - dev_dbg(chan2dev(chan), "SM1AR: 0x%08x\n", sm1ar); - dev_dbg(chan2dev(chan), "SFCR: 0x%08x\n", sfcr); + dev_dbg(vchan_chan_dev(&chan->vchan), "SCR: 0x%08x\n", scr); + dev_dbg(vchan_chan_dev(&chan->vchan), "NDTR: 0x%08x\n", ndtr); + dev_dbg(vchan_chan_dev(&chan->vchan), "SPAR: 0x%08x\n", spar); + dev_dbg(vchan_chan_dev(&chan->vchan), "SM0AR: 0x%08x\n", sm0ar); + dev_dbg(vchan_chan_dev(&chan->vchan), "SM1AR: 0x%08x\n", sm1ar); + dev_dbg(vchan_chan_dev(&chan->vchan), "SFCR: 0x%08x\n", sfcr); } =20 static void stm32_dma_sg_inc(struct stm32_dma_chan *chan) @@ -613,7 +608,7 @@ static void stm32_dma_start_transfer(struct stm32_dma_c= han *chan) reg->dma_scr |=3D STM32_DMA_SCR_EN; stm32_dma_write(dmadev, STM32_DMA_SCR(chan->id), reg->dma_scr); =20 - dev_dbg(chan2dev(chan), "vchan %p: started\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: started\n", &chan->vchan= ); } =20 static void stm32_dma_configure_next_sg(struct stm32_dma_chan *chan) @@ -630,12 +625,12 @@ static void stm32_dma_configure_next_sg(struct stm32_= dma_chan *chan) if (dma_scr & STM32_DMA_SCR_CT) { dma_sm0ar =3D sg_req->chan_reg.dma_sm0ar; stm32_dma_write(dmadev, STM32_DMA_SM0AR(id), dma_sm0ar); - dev_dbg(chan2dev(chan), "CT=3D1 <=3D> SM0AR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CT=3D1 <=3D> SM0AR: 0x%08x\n", stm32_dma_read(dmadev, STM32_DMA_SM0AR(id))); } else { dma_sm1ar =3D sg_req->chan_reg.dma_sm1ar; stm32_dma_write(dmadev, STM32_DMA_SM1AR(id), dma_sm1ar); - dev_dbg(chan2dev(chan), "CT=3D0 <=3D> SM1AR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CT=3D0 <=3D> SM1AR: 0x%08x\n", stm32_dma_read(dmadev, STM32_DMA_SM1AR(id))); } } @@ -676,7 +671,7 @@ static void stm32_dma_handle_chan_paused(struct stm32_d= ma_chan *chan) =20 chan->status =3D DMA_PAUSED; =20 - dev_dbg(chan2dev(chan), "vchan %p: paused\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: paused\n", &chan->vchan); } =20 static void stm32_dma_post_resume_reconfigure(struct stm32_dma_chan *chan) @@ -728,7 +723,7 @@ static void stm32_dma_post_resume_reconfigure(struct st= m32_dma_chan *chan) dma_scr |=3D STM32_DMA_SCR_EN; stm32_dma_write(dmadev, STM32_DMA_SCR(chan->id), dma_scr); =20 - dev_dbg(chan2dev(chan), "vchan %p: reconfigured after pause/resume\n", &c= han->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: reconfigured after pause= /resume\n", &chan->vchan); } =20 static void stm32_dma_handle_chan_done(struct stm32_dma_chan *chan, u32 sc= r) @@ -775,16 +770,16 @@ static irqreturn_t stm32_dma_chan_irq(int irq, void *= devid) if (sfcr & STM32_DMA_SFCR_FEIE) { if (!(scr & STM32_DMA_SCR_EN) && !(status & STM32_DMA_TCI)) - dev_err(chan2dev(chan), "FIFO Error\n"); + dev_err(vchan_chan_dev(&chan->vchan), "FIFO Error\n"); else - dev_dbg(chan2dev(chan), "FIFO over/underrun\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "FIFO over/underrun\n"); } } if (status & STM32_DMA_DMEI) { stm32_dma_irq_clear(chan, STM32_DMA_DMEI); status &=3D ~STM32_DMA_DMEI; if (sfcr & STM32_DMA_SCR_DMEIE) - dev_dbg(chan2dev(chan), "Direct mode overrun\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "Direct mode overrun\n"); } =20 if (status & STM32_DMA_TCI) { @@ -803,9 +798,9 @@ static irqreturn_t stm32_dma_chan_irq(int irq, void *de= vid) =20 if (status) { stm32_dma_irq_clear(chan, status); - dev_err(chan2dev(chan), "DMA error: status=3D0x%08x\n", status); + dev_err(vchan_chan_dev(&chan->vchan), "DMA error: status=3D0x%08x\n", st= atus); if (!(scr & STM32_DMA_SCR_EN)) - dev_err(chan2dev(chan), "chan disabled by HW\n"); + dev_err(vchan_chan_dev(&chan->vchan), "chan disabled by HW\n"); } =20 spin_unlock(&chan->vchan.lock); @@ -820,7 +815,7 @@ static void stm32_dma_issue_pending(struct dma_chan *c) =20 spin_lock_irqsave(&chan->vchan.lock, flags); if (vchan_issue_pending(&chan->vchan) && !chan->desc && !chan->busy) { - dev_dbg(chan2dev(chan), "vchan %p: issued\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: issued\n", &chan->vchan= ); stm32_dma_start_transfer(chan); =20 } @@ -922,7 +917,7 @@ static int stm32_dma_resume(struct dma_chan *c) =20 spin_unlock_irqrestore(&chan->vchan.lock, flags); =20 - dev_dbg(chan2dev(chan), "vchan %p: resumed\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: resumed\n", &chan->vchan= ); =20 return 0; } @@ -1059,7 +1054,7 @@ static int stm32_dma_set_xfer_param(struct stm32_dma_= chan *chan, break; =20 default: - dev_err(chan2dev(chan), "Dma direction is not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Dma direction is not supported\n"= ); return -EINVAL; } =20 @@ -1092,12 +1087,12 @@ static struct dma_async_tx_descriptor *stm32_dma_pr= ep_slave_sg( int i, ret; =20 if (!chan->config_init) { - dev_err(chan2dev(chan), "dma channel is not configured\n"); + dev_err(vchan_chan_dev(&chan->vchan), "dma channel is not configured\n"); return NULL; } =20 if (sg_len < 1) { - dev_err(chan2dev(chan), "Invalid segment length %d\n", sg_len); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid segment length %d\n", sg_= len); return NULL; } =20 @@ -1129,7 +1124,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep= _slave_sg( =20 nb_data_items =3D desc->sg_req[i].len / buswidth; if (nb_data_items > STM32_DMA_ALIGNED_MAX_DATA_ITEMS) { - dev_err(chan2dev(chan), "nb items not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "nb items not supported\n"); goto err; } =20 @@ -1164,17 +1159,17 @@ static struct dma_async_tx_descriptor *stm32_dma_pr= ep_dma_cyclic( int i, ret; =20 if (!buf_len || !period_len) { - dev_err(chan2dev(chan), "Invalid buffer/period len\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid buffer/period len\n"); return NULL; } =20 if (!chan->config_init) { - dev_err(chan2dev(chan), "dma channel is not configured\n"); + dev_err(vchan_chan_dev(&chan->vchan), "dma channel is not configured\n"); return NULL; } =20 if (buf_len % period_len) { - dev_err(chan2dev(chan), "buf_len not multiple of period_len\n"); + dev_err(vchan_chan_dev(&chan->vchan), "buf_len not multiple of period_le= n\n"); return NULL; } =20 @@ -1185,7 +1180,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep= _dma_cyclic( * terminating the DMA. */ if (chan->busy) { - dev_err(chan2dev(chan), "Request not allowed when dma busy\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Request not allowed when dma busy= \n"); return NULL; } =20 @@ -1196,7 +1191,7 @@ static struct dma_async_tx_descriptor *stm32_dma_prep= _dma_cyclic( =20 nb_data_items =3D period_len / buswidth; if (nb_data_items > STM32_DMA_ALIGNED_MAX_DATA_ITEMS) { - dev_err(chan2dev(chan), "number of items not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "number of items not supported\n"); return NULL; } =20 @@ -1478,7 +1473,7 @@ static void stm32_dma_free_chan_resources(struct dma_= chan *c) struct stm32_dma_device *dmadev =3D stm32_dma_get_dev(chan); unsigned long flags; =20 - dev_dbg(chan2dev(chan), "Freeing channel %d\n", chan->id); + dev_dbg(vchan_chan_dev(&chan->vchan), "Freeing channel %d\n", chan->id); =20 if (chan->busy) { spin_lock_irqsave(&chan->vchan.lock, flags); diff --git a/drivers/dma/stm32/stm32-dma3.c b/drivers/dma/stm32/stm32-dma3.c index 6ee7a1435efb6..4fe226541efa4 100644 --- a/drivers/dma/stm32/stm32-dma3.c +++ b/drivers/dma/stm32/stm32-dma3.c @@ -328,11 +328,6 @@ static inline struct stm32_dma3_swdesc *to_stm32_dma3_= swdesc(struct virt_dma_des return container_of(vdesc, struct stm32_dma3_swdesc, vdesc); } =20 -static struct device *chan2dev(struct stm32_dma3_chan *chan) -{ - return &chan->vchan.chan.dev->device; -} - static struct device *ddata2dev(struct stm32_dma3_ddata *ddata) { return ddata->dma_dev.dev; @@ -341,7 +336,7 @@ static struct device *ddata2dev(struct stm32_dma3_ddata= *ddata) static void stm32_dma3_chan_dump_reg(struct stm32_dma3_chan *chan) { struct stm32_dma3_ddata *ddata =3D to_stm32_dma3_ddata(chan); - struct device *dev =3D chan2dev(chan); + struct device *dev =3D vchan_chan_dev(&chan->vchan); u32 id =3D chan->id, offset; =20 offset =3D STM32_DMA3_SECCFGR; @@ -381,21 +376,21 @@ static void stm32_dma3_chan_dump_hwdesc(struct stm32_= dma3_chan *chan, for (i =3D 0; i < swdesc->lli_size; i++) { hwdesc =3D swdesc->lli[i].hwdesc; if (i) - dev_dbg(chan2dev(chan), "V\n"); - dev_dbg(chan2dev(chan), "[%d]@%pad\n", i, &swdesc->lli[i].hwdesc_addr); - dev_dbg(chan2dev(chan), "| C%dTR1: %08x\n", chan->id, hwdesc->ctr1); - dev_dbg(chan2dev(chan), "| C%dTR2: %08x\n", chan->id, hwdesc->ctr2); - dev_dbg(chan2dev(chan), "| C%dBR1: %08x\n", chan->id, hwdesc->cbr1); - dev_dbg(chan2dev(chan), "| C%dSAR: %08x\n", chan->id, hwdesc->csar); - dev_dbg(chan2dev(chan), "| C%dDAR: %08x\n", chan->id, hwdesc->cdar); - dev_dbg(chan2dev(chan), "| C%dLLR: %08x\n", chan->id, hwdesc->cllr); + dev_dbg(vchan_chan_dev(&chan->vchan), "V\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "[%d]@%pad\n", i, &swdesc->lli[i].= hwdesc_addr); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dTR1: %08x\n", chan->id, hwde= sc->ctr1); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dTR2: %08x\n", chan->id, hwde= sc->ctr2); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dBR1: %08x\n", chan->id, hwde= sc->cbr1); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dSAR: %08x\n", chan->id, hwde= sc->csar); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dDAR: %08x\n", chan->id, hwde= sc->cdar); + dev_dbg(vchan_chan_dev(&chan->vchan), "| C%dLLR: %08x\n", chan->id, hwde= sc->cllr); } =20 if (swdesc->cyclic) { - dev_dbg(chan2dev(chan), "|\n"); - dev_dbg(chan2dev(chan), "-->[0]@%pad\n", &swdesc->lli[0].hwdesc_addr); + dev_dbg(vchan_chan_dev(&chan->vchan), "|\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "-->[0]@%pad\n", &swdesc->lli[0].h= wdesc_addr); } else { - dev_dbg(chan2dev(chan), "X\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "X\n"); } } =20 @@ -411,7 +406,7 @@ static struct stm32_dma3_swdesc *stm32_dma3_chan_desc_a= lloc(struct stm32_dma3_ch * addressed, so abort the allocation. */ if ((count * 32) > CLLR_LA) { - dev_err(chan2dev(chan), "Transfer is too big (> %luB)\n", STM32_DMA3_MAX= _SEG_SIZE); + dev_err(vchan_chan_dev(&chan->vchan), "Transfer is too big (> %luB)\n", = STM32_DMA3_MAX_SEG_SIZE); return NULL; } =20 @@ -438,7 +433,7 @@ static struct stm32_dma3_swdesc *stm32_dma3_chan_desc_a= lloc(struct stm32_dma3_ch return swdesc; =20 err_pool_free: - dev_err(chan2dev(chan), "Failed to alloc descriptors\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Failed to alloc descriptors\n"); while (--i >=3D 0) dma_pool_free(chan->lli_pool, swdesc->lli[i].hwdesc, swdesc->lli[i].hwde= sc_addr); kfree(swdesc); @@ -468,7 +463,7 @@ static void stm32_dma3_chan_vdesc_free(struct virt_dma_= desc *vdesc) static void stm32_dma3_check_user_setting(struct stm32_dma3_chan *chan) { struct stm32_dma3_ddata *ddata =3D to_stm32_dma3_ddata(chan); - struct device *dev =3D chan2dev(chan); + struct device *dev =3D vchan_chan_dev(&chan->vchan); u32 ctr1 =3D readl_relaxed(ddata->base + STM32_DMA3_CTR1(chan->id)); u32 cbr1 =3D readl_relaxed(ddata->base + STM32_DMA3_CBR1(chan->id)); u32 csar =3D readl_relaxed(ddata->base + STM32_DMA3_CSAR(chan->id)); @@ -579,7 +574,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf u32 sap =3D FIELD_GET(STM32_DMA3_DT_SAP, tr_conf), sap_max_dw; u32 dap =3D FIELD_GET(STM32_DMA3_DT_DAP, tr_conf), dap_max_dw; =20 - dev_dbg(chan2dev(chan), "%s from %pad to %pad\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "%s from %pad to %pad\n", dmaengine_get_direction_text(dir), &src_addr, &dst_addr); =20 sdw =3D chan->dma_config.src_addr_width ? : get_chan_max_dw(sap, chan->ma= x_burst); @@ -589,12 +584,12 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_= chan *chan, enum dma_transf =20 /* Following conditions would raise User Setting Error interrupt */ if (!(dma_device.src_addr_widths & BIT(sdw)) || !(dma_device.dst_addr_wid= ths & BIT(ddw))) { - dev_err(chan2dev(chan), "Bus width (src=3D%u, dst=3D%u) not supported\n"= , sdw, ddw); + dev_err(vchan_chan_dev(&chan->vchan), "Bus width (src=3D%u, dst=3D%u) no= t supported\n", sdw, ddw); return -EINVAL; } =20 if (ddata->ports_max_dw[1] =3D=3D DW_INVALID && (sap || dap)) { - dev_err(chan2dev(chan), "Only one master port, port 1 is not supported\n= "); + dev_err(vchan_chan_dev(&chan->vchan), "Only one master port, port 1 is n= ot supported\n"); return -EINVAL; } =20 @@ -602,7 +597,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf dap_max_dw =3D ddata->ports_max_dw[dap]; if ((port_is_ahb(sap_max_dw) && sdw =3D=3D DMA_SLAVE_BUSWIDTH_8_BYTES) || (port_is_ahb(dap_max_dw) && ddw =3D=3D DMA_SLAVE_BUSWIDTH_8_BYTES)) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "8 bytes buswidth (src=3D%u, dst=3D%u) not supported on port (sap=3D%u,= dap=3D%u\n", sdw, ddw, sap, dap); return -EINVAL; @@ -659,7 +654,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf _ctr1 |=3D FIELD_PREP(CTR1_PAM, CTR1_PAM_PACK_UNPACK); /* Should never reach this case as ddw is clamped down */ if (len & (ddw - 1)) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Packing mode is enabled and len is not multiple of ddw"); return -EINVAL; } @@ -695,7 +690,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf _ctr1 |=3D FIELD_PREP(CTR1_PAM, CTR1_PAM_PACK_UNPACK); /* Should never reach this case as ddw is clamped down */ if (len & (ddw - 1)) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Packing mode is enabled and len is not multiple of ddw\n"); return -EINVAL; } @@ -740,7 +735,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf _ctr1 |=3D FIELD_PREP(CTR1_PAM, CTR1_PAM_PACK_UNPACK); /* Should never reach this case as ddw is clamped down */ if (len & (ddw - 1)) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Packing mode is enabled and len is not multiple of ddw"); return -EINVAL; } @@ -752,7 +747,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf break; =20 default: - dev_err(chan2dev(chan), "Direction %s not supported\n", + dev_err(vchan_chan_dev(&chan->vchan), "Direction %s not supported\n", dmaengine_get_direction_text(dir)); return -EINVAL; } @@ -761,7 +756,7 @@ static int stm32_dma3_chan_prep_hw(struct stm32_dma3_ch= an *chan, enum dma_transf *ctr1 =3D _ctr1; *ctr2 =3D _ctr2; =20 - dev_dbg(chan2dev(chan), "%s: sdw=3D%u bytes sbl=3D%u beats ddw=3D%u bytes= dbl=3D%u beats\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "%s: sdw=3D%u bytes sbl=3D%u beats = ddw=3D%u bytes dbl=3D%u beats\n", __func__, sdw, sbl_max, ddw, dbl_max); =20 return 0; @@ -807,7 +802,7 @@ static void stm32_dma3_chan_start(struct stm32_dma3_cha= n *chan) =20 chan->dma_status =3D DMA_IN_PROGRESS; =20 - dev_dbg(chan2dev(chan), "vchan %p: started\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: started\n", &chan->vchan= ); } =20 static int stm32_dma3_chan_suspend(struct stm32_dma3_chan *chan, bool susp) @@ -871,7 +866,7 @@ static void stm32_dma3_chan_set_residue(struct stm32_dm= a3_chan *chan, struct dma_tx_state *txstate) { struct stm32_dma3_ddata *ddata =3D to_stm32_dma3_ddata(chan); - struct device *dev =3D chan2dev(chan); + struct device *dev =3D vchan_chan_dev(&chan->vchan); struct stm32_dma3_hwdesc *hwdesc; u32 residue, curr_lli, csr, cdar, cbr1, cllr, bndt, fifol; bool pack_unpack; @@ -921,7 +916,7 @@ static void stm32_dma3_chan_set_residue(struct stm32_dm= a3_chan *chan, /* Get current hwdesc and cumulate residue of pending hwdesc BNDT */ ret =3D stm32_dma3_chan_get_curr_hwdesc(swdesc, cllr, &residue); if (ret < 0) { - dev_err(chan2dev(chan), "Can't get residue: current hwdesc not found\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Can't get residue: current hwdesc= not found\n"); return; } curr_lli =3D ret; @@ -957,7 +952,7 @@ static void stm32_dma3_chan_set_residue(struct stm32_dm= a3_chan *chan, =20 skip_fifol_update: if (fifol) { - dev_dbg(chan2dev(chan), "%u byte(s) in the FIFO\n", fifol); + dev_dbg(vchan_chan_dev(&chan->vchan), "%u byte(s) in the FIFO\n", fifol); dma_set_in_flight_bytes(txstate, fifol); /* * Residue is already accurate for DMA_MEM_TO_DEV as BNDT reflects data = read from @@ -987,7 +982,7 @@ static int stm32_dma3_chan_stop(struct stm32_dma3_chan = *chan) /* Suspend the channel */ ret =3D stm32_dma3_chan_suspend(chan, true); if (ret) - dev_warn(chan2dev(chan), "%s: timeout, data might be lost\n", __func__); + dev_warn(vchan_chan_dev(&chan->vchan), "%s: timeout, data might be lost= \n", __func__); } =20 /* @@ -1034,7 +1029,7 @@ static irqreturn_t stm32_dma3_chan_irq(int irq, void = *devid) } =20 if (csr & CSR_USEF && ccr & CCR_USEIE) { - dev_err(chan2dev(chan), "User setting error\n"); + dev_err(vchan_chan_dev(&chan->vchan), "User setting error\n"); chan->dma_status =3D DMA_ERROR; /* CCR.EN automatically cleared by HW */ stm32_dma3_check_user_setting(chan); @@ -1042,14 +1037,14 @@ static irqreturn_t stm32_dma3_chan_irq(int irq, voi= d *devid) } =20 if (csr & CSR_ULEF && ccr & CCR_ULEIE) { - dev_err(chan2dev(chan), "Update link transfer error\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Update link transfer error\n"); chan->dma_status =3D DMA_ERROR; /* CCR.EN automatically cleared by HW */ stm32_dma3_chan_reset(chan); } =20 if (csr & CSR_DTEF && ccr & CCR_DTEIE) { - dev_err(chan2dev(chan), "Data transfer error\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Data transfer error\n"); chan->dma_status =3D DMA_ERROR; /* CCR.EN automatically cleared by HW */ stm32_dma3_chan_reset(chan); @@ -1087,13 +1082,13 @@ static int stm32_dma3_get_chan_sem(struct stm32_dma= 3_chan *chan) goto bad_cid; =20 chan->semaphore_taken =3D true; - dev_dbg(chan2dev(chan), "under CID1 control (semcr=3D0x%08x)\n", csemcr); + dev_dbg(vchan_chan_dev(&chan->vchan), "under CID1 control (semcr=3D0x%08x= )\n", csemcr); =20 return 0; =20 bad_cid: chan->semaphore_taken =3D false; - dev_err(chan2dev(chan), "not under CID1 control (in-use by CID%d)\n", cci= d); + dev_err(vchan_chan_dev(&chan->vchan), "not under CID1 control (in-use by = CID%d)\n", ccid); =20 return -EACCES; } @@ -1105,7 +1100,7 @@ static void stm32_dma3_put_chan_sem(struct stm32_dma3= _chan *chan) if (chan->semaphore_taken) { writel_relaxed(0, ddata->base + STM32_DMA3_CSEMCR(chan->id)); chan->semaphore_taken =3D false; - dev_dbg(chan2dev(chan), "no more under CID1 control\n"); + dev_dbg(vchan_chan_dev(&chan->vchan), "no more under CID1 control\n"); } } =20 @@ -1130,7 +1125,7 @@ static int stm32_dma3_alloc_chan_resources(struct dma= _chan *c) sizeof(struct stm32_dma3_hwdesc), __alignof__(struct stm32_dma3_hwdesc), SZ_64K); if (!chan->lli_pool) { - dev_err(chan2dev(chan), "Failed to create LLI pool\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Failed to create LLI pool\n"); ret =3D -ENOMEM; goto err_put_sync; } @@ -1366,7 +1361,7 @@ static struct dma_async_tx_descriptor *stm32_dma3_pre= p_slave_sg(struct dma_chan } =20 if (count !=3D sg_len && chan->tcem !=3D CTR2_TCEM_CHANNEL) - dev_warn(chan2dev(chan), "Linked-list refactored, %d items instead of %d= \n", + dev_warn(vchan_chan_dev(&chan->vchan), "Linked-list refactored, %d items= instead of %d\n", count, sg_len); =20 /* Enable Error interrupts */ @@ -1401,12 +1396,12 @@ static struct dma_async_tx_descriptor *stm32_dma3_p= rep_dma_cyclic(struct dma_cha return NULL; =20 if (!buf_len || !period_len || period_len > STM32_DMA3_MAX_BLOCK_SIZE) { - dev_err(chan2dev(chan), "Invalid buffer/period length\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid buffer/period length\n"); return NULL; } =20 if (buf_len % period_len) { - dev_err(chan2dev(chan), "Buffer length not multiple of period length\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Buffer length not multiple of per= iod length\n"); return NULL; } =20 @@ -1428,7 +1423,7 @@ static struct dma_async_tx_descriptor *stm32_dma3_pre= p_dma_cyclic(struct dma_cha ret =3D stm32_dma3_chan_prep_hw(chan, DMA_DEV_TO_MEM, &swdesc->ccr, &ctr= 1, &ctr2, src, dst, period_len); } else { - dev_err(chan2dev(chan), "Invalid direction\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid direction\n"); ret =3D -EINVAL; } =20 @@ -1502,7 +1497,7 @@ static int stm32_dma3_pause(struct dma_chan *c) =20 chan->dma_status =3D DMA_PAUSED; =20 - dev_dbg(chan2dev(chan), "vchan %p: paused\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: paused\n", &chan->vchan); =20 return 0; } @@ -1515,7 +1510,7 @@ static int stm32_dma3_resume(struct dma_chan *c) =20 chan->dma_status =3D DMA_IN_PROGRESS; =20 - dev_dbg(chan2dev(chan), "vchan %p: resumed\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: resumed\n", &chan->vchan= ); =20 return 0; } @@ -1540,7 +1535,7 @@ static int stm32_dma3_terminate_all(struct dma_chan *= c) spin_unlock_irqrestore(&chan->vchan.lock, flags); vchan_dma_desc_free_list(&chan->vchan, &head); =20 - dev_dbg(chan2dev(chan), "vchan %p: terminated\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: terminated\n", &chan->vc= han); =20 return 0; } @@ -1593,7 +1588,7 @@ static void stm32_dma3_issue_pending(struct dma_chan = *c) spin_lock_irqsave(&chan->vchan.lock, flags); =20 if (vchan_issue_pending(&chan->vchan) && !chan->swdesc) { - dev_dbg(chan2dev(chan), "vchan %p: issued\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: issued\n", &chan->vchan= ); stm32_dma3_chan_start(chan); } =20 diff --git a/drivers/dma/stm32/stm32-mdma.c b/drivers/dma/stm32/stm32-mdma.c index c6dc8a9a7a288..04639e4b554ea 100644 --- a/drivers/dma/stm32/stm32-mdma.c +++ b/drivers/dma/stm32/stm32-mdma.c @@ -276,11 +276,6 @@ static struct stm32_mdma_desc *to_stm32_mdma_desc(stru= ct virt_dma_desc *vdesc) return container_of(vdesc, struct stm32_mdma_desc, vdesc); } =20 -static struct device *chan2dev(struct stm32_mdma_chan *chan) -{ - return &chan->vchan.chan.dev->device; -} - static struct device *mdma2dev(struct stm32_mdma_device *mdma_dev) { return mdma_dev->ddev.dev; @@ -334,7 +329,7 @@ static struct stm32_mdma_desc *stm32_mdma_alloc_desc( return desc; =20 err: - dev_err(chan2dev(chan), "Failed to allocate descriptor\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Failed to allocate descriptor\n"); while (--i >=3D 0) dma_pool_free(chan->desc_pool, desc->node[i].hwdesc, desc->node[i].hwdesc_phys); @@ -364,7 +359,7 @@ static int stm32_mdma_get_width(struct stm32_mdma_chan = *chan, case DMA_SLAVE_BUSWIDTH_8_BYTES: return ffs(width) - 1; default: - dev_err(chan2dev(chan), "Dma bus width %i not supported\n", + dev_err(vchan_chan_dev(&chan->vchan), "Dma bus width %i not supported\n", width); return -EINVAL; } @@ -422,7 +417,7 @@ static int stm32_mdma_disable_chan(struct stm32_mdma_ch= an *chan) dmadev->base + STM32_MDMA_CISR(id), cisr, (cisr & STM32_MDMA_CISR_CTCIF), 10, 1000); if (ret) { - dev_err(chan2dev(chan), "%s: timeout!\n", __func__); + dev_err(vchan_chan_dev(&chan->vchan), "%s: timeout!\n", __func__); return -EBUSY; } } @@ -444,7 +439,7 @@ static void stm32_mdma_stop(struct stm32_mdma_chan *cha= n) /* Clear interrupt status if it is there */ status =3D stm32_mdma_read(dmadev, STM32_MDMA_CISR(chan->id)); if (status) { - dev_dbg(chan2dev(chan), "%s(): clearing interrupt: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "%s(): clearing interrupt: 0x%08x\= n", __func__, status); stm32_mdma_set_bits(dmadev, STM32_MDMA_CIFCR(chan->id), status); } @@ -513,7 +508,7 @@ static int stm32_mdma_set_xfer_param(struct stm32_mdma_= chan *chan, /* Check burst size constraints */ if (src_maxburst * src_addr_width > STM32_MDMA_MAX_BURST || dst_maxburst * dst_addr_width > STM32_MDMA_MAX_BURST) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "burst size * bus width higher than %d bytes\n", STM32_MDMA_MAX_BURST); return -EINVAL; @@ -521,7 +516,7 @@ static int stm32_mdma_set_xfer_param(struct stm32_mdma_= chan *chan, =20 if ((!is_power_of_2(src_maxburst) && src_maxburst > 0) || (!is_power_of_2(dst_maxburst) && dst_maxburst > 0)) { - dev_err(chan2dev(chan), "burst size must be a power of 2\n"); + dev_err(vchan_chan_dev(&chan->vchan), "burst size must be a power of 2\n= "); return -EINVAL; } =20 @@ -658,7 +653,7 @@ static int stm32_mdma_set_xfer_param(struct stm32_mdma_= chan *chan, break; =20 default: - dev_err(chan2dev(chan), "Dma direction is not supported\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Dma direction is not supported\n"= ); return -EINVAL; } =20 @@ -672,16 +667,16 @@ static int stm32_mdma_set_xfer_param(struct stm32_mdm= a_chan *chan, static void stm32_mdma_dump_hwdesc(struct stm32_mdma_chan *chan, struct stm32_mdma_desc_node *node) { - dev_dbg(chan2dev(chan), "hwdesc: %pad\n", &node->hwdesc_phys); - dev_dbg(chan2dev(chan), "CTCR: 0x%08x\n", node->hwdesc->ctcr); - dev_dbg(chan2dev(chan), "CBNDTR: 0x%08x\n", node->hwdesc->cbndtr); - dev_dbg(chan2dev(chan), "CSAR: 0x%08x\n", node->hwdesc->csar); - dev_dbg(chan2dev(chan), "CDAR: 0x%08x\n", node->hwdesc->cdar); - dev_dbg(chan2dev(chan), "CBRUR: 0x%08x\n", node->hwdesc->cbrur); - dev_dbg(chan2dev(chan), "CLAR: 0x%08x\n", node->hwdesc->clar); - dev_dbg(chan2dev(chan), "CTBR: 0x%08x\n", node->hwdesc->ctbr); - dev_dbg(chan2dev(chan), "CMAR: 0x%08x\n", node->hwdesc->cmar); - dev_dbg(chan2dev(chan), "CMDR: 0x%08x\n\n", node->hwdesc->cmdr); + dev_dbg(vchan_chan_dev(&chan->vchan), "hwdesc: %pad\n", &node->hwdesc_ph= ys); + dev_dbg(vchan_chan_dev(&chan->vchan), "CTCR: 0x%08x\n", node->hwdesc->= ctcr); + dev_dbg(vchan_chan_dev(&chan->vchan), "CBNDTR: 0x%08x\n", node->hwdesc->= cbndtr); + dev_dbg(vchan_chan_dev(&chan->vchan), "CSAR: 0x%08x\n", node->hwdesc->= csar); + dev_dbg(vchan_chan_dev(&chan->vchan), "CDAR: 0x%08x\n", node->hwdesc->= cdar); + dev_dbg(vchan_chan_dev(&chan->vchan), "CBRUR: 0x%08x\n", node->hwdesc->= cbrur); + dev_dbg(vchan_chan_dev(&chan->vchan), "CLAR: 0x%08x\n", node->hwdesc->= clar); + dev_dbg(vchan_chan_dev(&chan->vchan), "CTBR: 0x%08x\n", node->hwdesc->= ctbr); + dev_dbg(vchan_chan_dev(&chan->vchan), "CMAR: 0x%08x\n", node->hwdesc->= cmar); + dev_dbg(vchan_chan_dev(&chan->vchan), "CMDR: 0x%08x\n\n", node->hwdesc= ->cmdr); } =20 static void stm32_mdma_setup_hwdesc(struct stm32_mdma_chan *chan, @@ -739,7 +734,7 @@ static int stm32_mdma_setup_xfer(struct stm32_mdma_chan= *chan, =20 for_each_sg(sgl, sg, sg_len, i) { if (sg_dma_len(sg) > STM32_MDMA_MAX_BLOCK_LEN) { - dev_err(chan2dev(chan), "Invalid block len\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid block len\n"); return -EINVAL; } =20 @@ -797,7 +792,7 @@ stm32_mdma_prep_slave_sg(struct dma_chan *c, struct sca= tterlist *sgl, * for allowing another request. */ if (chan->desc && chan->desc->cyclic) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Request not allowed when dma in cyclic mode\n"); return NULL; } @@ -858,18 +853,18 @@ stm32_mdma_prep_dma_cyclic(struct dma_chan *c, dma_ad= dr_t buf_addr, * for allowing another request. */ if (chan->desc && chan->desc->cyclic) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Request not allowed when dma in cyclic mode\n"); return NULL; } =20 if (!buf_len || !period_len || period_len > STM32_MDMA_MAX_BLOCK_LEN) { - dev_err(chan2dev(chan), "Invalid buffer/period len\n"); + dev_err(vchan_chan_dev(&chan->vchan), "Invalid buffer/period len\n"); return NULL; } =20 if (buf_len % period_len) { - dev_err(chan2dev(chan), "buf_len not multiple of period_len\n"); + dev_err(vchan_chan_dev(&chan->vchan), "buf_len not multiple of period_le= n\n"); return NULL; } =20 @@ -954,7 +949,7 @@ stm32_mdma_prep_dma_memcpy(struct dma_chan *c, dma_addr= _t dest, dma_addr_t src, * to allow another request */ if (chan->desc && chan->desc->cyclic) { - dev_err(chan2dev(chan), + dev_err(vchan_chan_dev(&chan->vchan), "Request not allowed when dma in cyclic mode\n"); return NULL; } @@ -1116,25 +1111,25 @@ static void stm32_mdma_dump_reg(struct stm32_mdma_c= han *chan) { struct stm32_mdma_device *dmadev =3D stm32_mdma_get_dev(chan); =20 - dev_dbg(chan2dev(chan), "CCR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CCR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CCR(chan->id))); - dev_dbg(chan2dev(chan), "CTCR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CTCR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CTCR(chan->id))); - dev_dbg(chan2dev(chan), "CBNDTR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CBNDTR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CBNDTR(chan->id))); - dev_dbg(chan2dev(chan), "CSAR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CSAR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CSAR(chan->id))); - dev_dbg(chan2dev(chan), "CDAR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CDAR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CDAR(chan->id))); - dev_dbg(chan2dev(chan), "CBRUR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CBRUR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CBRUR(chan->id))); - dev_dbg(chan2dev(chan), "CLAR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CLAR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CLAR(chan->id))); - dev_dbg(chan2dev(chan), "CTBR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CTBR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CTBR(chan->id))); - dev_dbg(chan2dev(chan), "CMAR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CMAR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CMAR(chan->id))); - dev_dbg(chan2dev(chan), "CMDR: 0x%08x\n", + dev_dbg(vchan_chan_dev(&chan->vchan), "CMDR: 0x%08x\n", stm32_mdma_read(dmadev, STM32_MDMA_CMDR(chan->id))); } =20 @@ -1187,7 +1182,7 @@ static void stm32_mdma_start_transfer(struct stm32_md= ma_chan *chan) =20 chan->busy =3D true; =20 - dev_dbg(chan2dev(chan), "vchan %p: started\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: started\n", &chan->vchan= ); } =20 static void stm32_mdma_issue_pending(struct dma_chan *c) @@ -1200,7 +1195,7 @@ static void stm32_mdma_issue_pending(struct dma_chan = *c) if (!vchan_issue_pending(&chan->vchan)) goto end; =20 - dev_dbg(chan2dev(chan), "vchan %p: issued\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: issued\n", &chan->vchan); =20 if (!chan->desc && !chan->busy) stm32_mdma_start_transfer(chan); @@ -1220,7 +1215,7 @@ static int stm32_mdma_pause(struct dma_chan *c) spin_unlock_irqrestore(&chan->vchan.lock, flags); =20 if (!ret) - dev_dbg(chan2dev(chan), "vchan %p: pause\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: pause\n", &chan->vchan); =20 return ret; } @@ -1261,7 +1256,7 @@ static int stm32_mdma_resume(struct dma_chan *c) =20 spin_unlock_irqrestore(&chan->vchan.lock, flags); =20 - dev_dbg(chan2dev(chan), "vchan %p: resume\n", &chan->vchan); + dev_dbg(vchan_chan_dev(&chan->vchan), "vchan %p: resume\n", &chan->vchan); =20 return 0; } @@ -1422,10 +1417,10 @@ static irqreturn_t stm32_mdma_irq_handler(int irq, = void *devid) if (!(status & ien)) { spin_unlock(&chan->vchan.lock); if (chan->busy) - dev_warn(chan2dev(chan), + dev_warn(vchan_chan_dev(&chan->vchan), "spurious it (status=3D0x%04x, ien=3D0x%04x)\n", status, ien); else - dev_dbg(chan2dev(chan), + dev_dbg(vchan_chan_dev(&chan->vchan), "spurious it (status=3D0x%04x, ien=3D0x%04x)\n", status, ien); return IRQ_NONE; } @@ -1433,7 +1428,7 @@ static irqreturn_t stm32_mdma_irq_handler(int irq, vo= id *devid) reg =3D STM32_MDMA_CIFCR(id); =20 if (status & STM32_MDMA_CISR_TEIF) { - dev_err(chan2dev(chan), "Transfer Err: stat=3D0x%08x\n", + dev_err(vchan_chan_dev(&chan->vchan), "Transfer Err: stat=3D0x%08x\n", readl_relaxed(dmadev->base + STM32_MDMA_CESR(id))); stm32_mdma_set_bits(dmadev, reg, STM32_MDMA_CIFCR_CTEIF); status &=3D ~STM32_MDMA_CISR_TEIF; @@ -1468,9 +1463,9 @@ static irqreturn_t stm32_mdma_irq_handler(int irq, vo= id *devid) =20 if (status) { stm32_mdma_set_bits(dmadev, reg, status); - dev_err(chan2dev(chan), "DMA error: status=3D0x%08x\n", status); + dev_err(vchan_chan_dev(&chan->vchan), "DMA error: status=3D0x%08x\n", st= atus); if (!(ccr & STM32_MDMA_CCR_EN)) - dev_err(chan2dev(chan), "chan disabled by HW\n"); + dev_err(vchan_chan_dev(&chan->vchan), "chan disabled by HW\n"); } =20 spin_unlock(&chan->vchan.lock); @@ -1489,7 +1484,7 @@ static int stm32_mdma_alloc_chan_resources(struct dma= _chan *c) __alignof__(struct stm32_mdma_hwdesc), 0); if (!chan->desc_pool) { - dev_err(chan2dev(chan), "failed to allocate descriptor pool\n"); + dev_err(vchan_chan_dev(&chan->vchan), "failed to allocate descriptor poo= l\n"); return -ENOMEM; } =20 @@ -1510,7 +1505,7 @@ static void stm32_mdma_free_chan_resources(struct dma= _chan *c) struct stm32_mdma_device *dmadev =3D stm32_mdma_get_dev(chan); unsigned long flags; =20 - dev_dbg(chan2dev(chan), "Freeing channel %d\n", chan->id); + dev_dbg(vchan_chan_dev(&chan->vchan), "Freeing channel %d\n", chan->id); =20 if (chan->busy) { spin_lock_irqsave(&chan->vchan.lock, flags); diff --git a/drivers/dma/sun4i-dma.c b/drivers/dma/sun4i-dma.c index d2321f7287d20..225e4a53502b4 100644 --- a/drivers/dma/sun4i-dma.c +++ b/drivers/dma/sun4i-dma.c @@ -246,11 +246,6 @@ static struct sun4i_dma_contract *to_sun4i_dma_contrac= t(struct virt_dma_desc *vd return container_of(vd, struct sun4i_dma_contract, vd); } =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static void set_dst_data_width_a10(u32 *p_cfg, s8 data_width) { *p_cfg |=3D SUN4I_DMA_CFG_DST_DATA_WIDTH(data_width); @@ -428,7 +423,7 @@ static int __execute_vchan_pending(struct sun4i_dma_dev= *priv, * has already submitted some work, we can't do anything else */ if (vchan->processing) { - dev_dbg(chan2dev(&vchan->vc.chan), + dev_dbg(vchan_chan_dev(&vchan->vc), "processing something to this endpoint already\n"); ret =3D -EBUSY; goto release_pchan; @@ -438,7 +433,7 @@ static int __execute_vchan_pending(struct sun4i_dma_dev= *priv, /* Figure out which contract we're working with today */ vd =3D vchan_next_desc(&vchan->vc); if (!vd) { - dev_dbg(chan2dev(&vchan->vc.chan), + dev_dbg(vchan_chan_dev(&vchan->vc), "No pending contract found"); ret =3D 0; goto release_pchan; @@ -449,7 +444,7 @@ static int __execute_vchan_pending(struct sun4i_dma_dev= *priv, /* The contract has been completed so mark it as such */ list_del(&contract->vd.node); vchan_cookie_complete(&contract->vd); - dev_dbg(chan2dev(&vchan->vc.chan), + dev_dbg(vchan_chan_dev(&vchan->vc), "Empty contract found and marked complete"); } } while (list_empty(&contract->demands)); @@ -542,7 +537,7 @@ generate_ndma_promise(struct dma_chan *chan, dma_addr_t= src, dma_addr_t dest, promise->cfg =3D SUN4I_DMA_CFG_LOADING | SUN4I_NDMA_CFG_BYTE_COUNT_MODE_REMAIN; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "src burst %d, dst burst %d, src buswidth %d, dst buswidth %d", sconfig->src_maxburst, sconfig->dst_maxburst, sconfig->src_addr_width, sconfig->dst_addr_width); @@ -769,7 +764,7 @@ sun4i_dma_prep_dma_cyclic(struct dma_chan *chan, dma_ad= dr_t buf, size_t len, u8 ram_type, io_mode, linear_mode; =20 if (!is_slave_direction(dir)) { - dev_err(chan2dev(chan), "Invalid DMA direction\n"); + dev_err(dmaengine_chan_dev(chan), "Invalid DMA direction\n"); return NULL; } =20 @@ -894,7 +889,7 @@ sun4i_dma_prep_slave_sg(struct dma_chan *chan, struct s= catterlist *sgl, return NULL; =20 if (!is_slave_direction(dir)) { - dev_err(chan2dev(chan), "Invalid DMA direction\n"); + dev_err(dmaengine_chan_dev(chan), "Invalid DMA direction\n"); return NULL; } =20 diff --git a/drivers/dma/sun6i-dma.c b/drivers/dma/sun6i-dma.c index c248c2dec956a..5ad9d01cff3ae 100644 --- a/drivers/dma/sun6i-dma.c +++ b/drivers/dma/sun6i-dma.c @@ -213,11 +213,6 @@ struct sun6i_dma_dev { u32 max_request; }; =20 -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} - static inline struct sun6i_dma_dev *to_sun6i_dma_dev(struct dma_device *d) { return container_of(d, struct sun6i_dma_dev, slave); @@ -397,7 +392,7 @@ static inline void sun6i_dma_dump_lli(struct sun6i_vcha= n *vchan, struct sun6i_dma_lli *v_lli, dma_addr_t p_lli) { - dev_dbg(chan2dev(&vchan->vc.chan), + dev_dbg(vchan_chan_dev(&vchan->vc), "\n\tdesc:\tp - %pad v - 0x%p\n" "\t\tc - 0x%08x s - 0x%08x d - 0x%08x\n" "\t\tl - 0x%08x p - 0x%08x n - 0x%08x\n", @@ -678,7 +673,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_d= ma_memcpy( dma_addr_t p_lli; s8 burst, width; =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s; chan: %d, dest: %pad, src: %pad, len: %zu. flags: 0x%08lx\n", __func__, vchan->vc.chan.chan_id, &dest, &src, len, flags); =20 @@ -739,7 +734,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_s= lave_sg( =20 ret =3D set_config(sdev, sconfig, dir, &lli_cfg); if (ret) { - dev_err(chan2dev(chan), "Invalid DMA configuration\n"); + dev_err(dmaengine_chan_dev(chan), "Invalid DMA configuration\n"); return NULL; } =20 @@ -763,7 +758,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_s= lave_sg( sdev->cfg->set_drq(&v_lli->cfg, DRQ_SDRAM, vchan->port); sdev->cfg->set_mode(&v_lli->cfg, LINEAR_MODE, IO_MODE); =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s; chan: %d, dest: %pad, src: %pad, len: %u. flags: 0x%08lx\n", __func__, vchan->vc.chan.chan_id, &sconfig->dst_addr, &sg_dma_address(sg), @@ -777,7 +772,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_s= lave_sg( sdev->cfg->set_drq(&v_lli->cfg, vchan->port, DRQ_SDRAM); sdev->cfg->set_mode(&v_lli->cfg, IO_MODE, LINEAR_MODE); =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s; chan: %d, dest: %pad, src: %pad, len: %u. flags: 0x%08lx\n", __func__, vchan->vc.chan.chan_id, &sg_dma_address(sg), &sconfig->src_addr, @@ -787,7 +782,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_s= lave_sg( prev =3D sun6i_dma_lli_add(prev, v_lli, p_lli, txd); } =20 - dev_dbg(chan2dev(chan), "First: %pad\n", &txd->p_lli); + dev_dbg(dmaengine_chan_dev(chan), "First: %pad\n", &txd->p_lli); for (p_lli =3D txd->p_lli, v_lli =3D txd->v_lli; v_lli; p_lli =3D v_lli->p_lli_next, v_lli =3D v_lli->v_lli_next) sun6i_dma_dump_lli(vchan, v_lli, p_lli); @@ -819,7 +814,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_d= ma_cyclic( =20 ret =3D set_config(sdev, sconfig, dir, &lli_cfg); if (ret) { - dev_err(chan2dev(chan), "Invalid DMA configuration\n"); + dev_err(dmaengine_chan_dev(chan), "Invalid DMA configuration\n"); return NULL; } =20 @@ -844,7 +839,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_d= ma_cyclic( v_lli->cfg =3D lli_cfg; sdev->cfg->set_drq(&v_lli->cfg, DRQ_SDRAM, vchan->port); sdev->cfg->set_mode(&v_lli->cfg, LINEAR_MODE, IO_MODE); - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s; chan: %d, dest: %pad, src: %pad, len: %zu. flags: 0x%08lx\n", __func__, vchan->vc.chan.chan_id, &sconfig->dst_addr, &buf_addr, @@ -856,7 +851,7 @@ static struct dma_async_tx_descriptor *sun6i_dma_prep_d= ma_cyclic( v_lli->cfg =3D lli_cfg; sdev->cfg->set_drq(&v_lli->cfg, vchan->port, DRQ_SDRAM); sdev->cfg->set_mode(&v_lli->cfg, IO_MODE, LINEAR_MODE); - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "%s; chan: %d, dest: %pad, src: %pad, len: %zu. flags: 0x%08lx\n", __func__, vchan->vc.chan.chan_id, &buf_addr, &sconfig->src_addr, @@ -893,7 +888,7 @@ static int sun6i_dma_pause(struct dma_chan *chan) struct sun6i_vchan *vchan =3D to_sun6i_vchan(chan); struct sun6i_pchan *pchan =3D vchan->phy; =20 - dev_dbg(chan2dev(chan), "vchan %p: pause\n", &vchan->vc); + dev_dbg(dmaengine_chan_dev(chan), "vchan %p: pause\n", &vchan->vc); =20 if (pchan) { writel(DMA_CHAN_PAUSE_PAUSE, @@ -914,7 +909,7 @@ static int sun6i_dma_resume(struct dma_chan *chan) struct sun6i_pchan *pchan =3D vchan->phy; unsigned long flags; =20 - dev_dbg(chan2dev(chan), "vchan %p: resume\n", &vchan->vc); + dev_dbg(dmaengine_chan_dev(chan), "vchan %p: resume\n", &vchan->vc); =20 spin_lock_irqsave(&vchan->vc.lock, flags); =20 @@ -1024,13 +1019,13 @@ static void sun6i_dma_issue_pending(struct dma_chan= *chan) if (!vchan->phy && list_empty(&vchan->node)) { list_add_tail(&vchan->node, &sdev->pending); tasklet_schedule(&sdev->task); - dev_dbg(chan2dev(chan), "vchan %p: issued\n", + dev_dbg(dmaengine_chan_dev(chan), "vchan %p: issued\n", &vchan->vc); } =20 spin_unlock(&sdev->lock); } else { - dev_dbg(chan2dev(chan), "vchan %p: nothing to issue\n", + dev_dbg(dmaengine_chan_dev(chan), "vchan %p: nothing to issue\n", &vchan->vc); } =20 diff --git a/drivers/dma/switchtec_dma.c b/drivers/dma/switchtec_dma.c index c133535d37656..4cc80752f5b69 100644 --- a/drivers/dma/switchtec_dma.c +++ b/drivers/dma/switchtec_dma.c @@ -406,7 +406,7 @@ static int disable_channel(struct switchtec_dma_chan *s= wdma_chan) static void switchtec_dma_cleanup_completed(struct switchtec_dma_chan *swdma_chan) { - struct device *chan_dev =3D &swdma_chan->dma_chan.dev->device; + struct device *chan_dev =3D dmaengine_chan_dev(&swdma_chan->dma_chan); struct switchtec_dma_desc *desc; struct switchtec_dma_hw_ce *ce; struct dmaengine_result res; @@ -851,7 +851,7 @@ static irqreturn_t switchtec_dma_chan_status_isr(int ir= q, void *dma) list_for_each_entry(chan, &dma_dev->channels, device_node) { swdma_chan =3D container_of(chan, struct switchtec_dma_chan, dma_chan); - chan_dev =3D &swdma_chan->dma_chan.dev->device; + chan_dev =3D dmaengine_chan_dev(&swdma_chan->dma_chan); chan_hw =3D swdma_chan->mmio_chan_hw; =20 rcu_read_lock(); @@ -1009,19 +1009,19 @@ static int switchtec_dma_alloc_chan_resources(struc= t dma_chan *chan) perf_cfg =3D readl(&swdma_chan->mmio_chan_fw->perf_cfg); rcu_read_unlock(); =20 - dev_dbg(&chan->dev->device, "Burst Size: 0x%x\n", + dev_dbg(dmaengine_chan_dev(chan), "Burst Size: 0x%x\n", FIELD_GET(PERF_BURST_SIZE_MASK, perf_cfg)); =20 - dev_dbg(&chan->dev->device, "Burst Scale: 0x%x\n", + dev_dbg(dmaengine_chan_dev(chan), "Burst Scale: 0x%x\n", FIELD_GET(PERF_BURST_SCALE_MASK, perf_cfg)); =20 - dev_dbg(&chan->dev->device, "Interval: 0x%x\n", + dev_dbg(dmaengine_chan_dev(chan), "Interval: 0x%x\n", FIELD_GET(PERF_INTERVAL_MASK, perf_cfg)); =20 - dev_dbg(&chan->dev->device, "Arb Weight: 0x%x\n", + dev_dbg(dmaengine_chan_dev(chan), "Arb Weight: 0x%x\n", FIELD_GET(PERF_ARB_WEIGHT_MASK, perf_cfg)); =20 - dev_dbg(&chan->dev->device, "MRRS: 0x%x\n", + dev_dbg(dmaengine_chan_dev(chan), "MRRS: 0x%x\n", FIELD_GET(PERF_MRRS_MASK, perf_cfg)); =20 return SWITCHTEC_DMA_SQ_SIZE; diff --git a/drivers/dma/tegra186-gpc-dma.c b/drivers/dma/tegra186-gpc-dma.c index 64cedef1050ae..b3327aa35de40 100644 --- a/drivers/dma/tegra186-gpc-dma.c +++ b/drivers/dma/tegra186-gpc-dma.c @@ -1537,7 +1537,7 @@ static int tegra_dma_probe(struct platform_device *pd= ev) * the channels available and registered for the DMA device are used. */ list_for_each_entry(chan, &tdma->dma_dev.channels, device_node) { - chdev =3D &chan->dev->device; + chdev =3D dmaengine_chan_dev(chan); tdc =3D to_tegra_dma_chan(chan); =20 if (use_iommu_map) { diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c index 640b8a218c9ad..7ff8c0241f61f 100644 --- a/drivers/dma/tegra20-apb-dma.c +++ b/drivers/dma/tegra20-apb-dma.c @@ -256,7 +256,7 @@ txd_to_tegra_dma_desc(struct dma_async_tx_descriptor *t= d) =20 static inline struct device *tdc2dev(struct tegra_dma_channel *tdc) { - return &tdc->dma_chan.dev->device; + return dmaengine_chan_dev(&tdc->dma_chan); } =20 static dma_cookie_t tegra_dma_tx_submit(struct dma_async_tx_descriptor *tx= ); diff --git a/drivers/dma/ti/k3-udma.c b/drivers/dma/ti/k3-udma.c index fb21e0df5ab7b..49e2d0014d5ed 100644 --- a/drivers/dma/ti/k3-udma.c +++ b/drivers/dma/ti/k3-udma.c @@ -422,7 +422,7 @@ static int navss_psil_unpair(struct udma_dev *ud, u32 s= rc_thread, =20 static void k3_configure_chan_coherency(struct dma_chan *chan, u32 asel) { - struct device *chan_dev =3D &chan->dev->device; + struct device *chan_dev =3D dmaengine_chan_dev(chan); =20 if (asel =3D=3D 0) { /* No special handling for the channel */ diff --git a/drivers/dma/timb_dma.c b/drivers/dma/timb_dma.c index 4fc5119854ec1..0acd7a36a3d0d 100644 --- a/drivers/dma/timb_dma.c +++ b/drivers/dma/timb_dma.c @@ -90,14 +90,9 @@ struct timb_dma { struct tasklet_struct tasklet; struct timb_dma_chan channels[]; }; - -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} static struct device *chan2dmadev(struct dma_chan *chan) { - return chan2dev(chan)->parent->parent; + return dmaengine_chan_dev(chan)->parent->parent; } =20 static struct timb_dma *tdchantotd(struct timb_dma_chan *td_chan) @@ -117,7 +112,7 @@ static void __td_enable_chan_irq(struct timb_dma_chan *= td_chan) /* enable interrupt for this channel */ ier =3D ioread32(td->membase + TIMBDMA_IER); ier |=3D 1 << id; - dev_dbg(chan2dev(&td_chan->chan), "Enabling irq: %d, IER: 0x%x\n", id, + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "Enabling irq: %d, IER: 0x%x\= n", id, ier); iowrite32(ier, td->membase + TIMBDMA_IER); } @@ -131,7 +126,7 @@ static bool __td_dma_done_ack(struct timb_dma_chan *td_= chan) u32 isr; bool done =3D false; =20 - dev_dbg(chan2dev(&td_chan->chan), "Checking irq: %d, td: %p\n", id, td); + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "Checking irq: %d, td: %p\n",= id, td); =20 isr =3D ioread32(td->membase + TIMBDMA_ISR) & (1 << id); if (isr) { @@ -146,18 +141,18 @@ static int td_fill_desc(struct timb_dma_chan *td_chan= , u8 *dma_desc, struct scatterlist *sg, bool last) { if (sg_dma_len(sg) > USHRT_MAX) { - dev_err(chan2dev(&td_chan->chan), "Too big sg element\n"); + dev_err(dmaengine_chan_dev(&td_chan->chan), "Too big sg element\n"); return -EINVAL; } =20 /* length must be word aligned */ if (sg_dma_len(sg) % sizeof(u32)) { - dev_err(chan2dev(&td_chan->chan), "Incorrect length: %d\n", + dev_err(dmaengine_chan_dev(&td_chan->chan), "Incorrect length: %d\n", sg_dma_len(sg)); return -EINVAL; } =20 - dev_dbg(chan2dev(&td_chan->chan), "desc: %p, addr: 0x%llx\n", + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "desc: %p, addr: 0x%llx\n", dma_desc, (unsigned long long)sg_dma_address(sg)); =20 dma_desc[7] =3D (sg_dma_address(sg) >> 24) & 0xff; @@ -180,7 +175,7 @@ static void __td_start_dma(struct timb_dma_chan *td_cha= n) struct timb_dma_desc *td_desc; =20 if (td_chan->ongoing) { - dev_err(chan2dev(&td_chan->chan), + dev_err(dmaengine_chan_dev(&td_chan->chan), "Transfer already ongoing\n"); return; } @@ -188,7 +183,7 @@ static void __td_start_dma(struct timb_dma_chan *td_cha= n) td_desc =3D list_entry(td_chan->active_list.next, struct timb_dma_desc, desc_node); =20 - dev_dbg(chan2dev(&td_chan->chan), + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "td_chan: %p, chan: %d, membase: %p\n", td_chan, td_chan->chan.chan_id, td_chan->membase); =20 @@ -230,7 +225,7 @@ static void __td_finish(struct timb_dma_chan *td_chan) desc_node); txd =3D &td_desc->txd; =20 - dev_dbg(chan2dev(&td_chan->chan), "descriptor %u complete\n", + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "descriptor %u complete\n", txd->cookie); =20 /* make sure to stop the transfer */ @@ -284,7 +279,7 @@ static void __td_start_next(struct timb_dma_chan *td_ch= an) td_desc =3D list_entry(td_chan->queue.next, struct timb_dma_desc, desc_node); =20 - dev_dbg(chan2dev(&td_chan->chan), "%s: started %u\n", + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "%s: started %u\n", __func__, td_desc->txd.cookie); =20 list_move(&td_desc->desc_node, &td_chan->active_list); @@ -303,12 +298,12 @@ static dma_cookie_t td_tx_submit(struct dma_async_tx_= descriptor *txd) cookie =3D dma_cookie_assign(txd); =20 if (list_empty(&td_chan->active_list)) { - dev_dbg(chan2dev(txd->chan), "%s: started %u\n", __func__, + dev_dbg(dmaengine_chan_dev(txd->chan), "%s: started %u\n", __func__, txd->cookie); list_add_tail(&td_desc->desc_node, &td_chan->active_list); __td_start_dma(td_chan); } else { - dev_dbg(chan2dev(txd->chan), "tx_submit: queued %u\n", + dev_dbg(dmaengine_chan_dev(txd->chan), "tx_submit: queued %u\n", txd->cookie); =20 list_add_tail(&td_desc->desc_node, &td_chan->queue); @@ -344,7 +339,7 @@ static struct timb_dma_desc *td_alloc_init_desc(struct = timb_dma_chan *td_chan) =20 err =3D dma_mapping_error(chan2dmadev(chan), td_desc->txd.phys); if (err) { - dev_err(chan2dev(chan), "DMA mapping error: %d\n", err); + dev_err(dmaengine_chan_dev(chan), "DMA mapping error: %d\n", err); goto err; } =20 @@ -359,7 +354,7 @@ static struct timb_dma_desc *td_alloc_init_desc(struct = timb_dma_chan *td_chan) =20 static void td_free_desc(struct timb_dma_desc *td_desc) { - dev_dbg(chan2dev(td_desc->txd.chan), "Freeing desc: %p\n", td_desc); + dev_dbg(dmaengine_chan_dev(td_desc->txd.chan), "Freeing desc: %p\n", td_d= esc); dma_unmap_single(chan2dmadev(td_desc->txd.chan), td_desc->txd.phys, td_desc->desc_list_len, DMA_TO_DEVICE); =20 @@ -370,7 +365,7 @@ static void td_free_desc(struct timb_dma_desc *td_desc) static void td_desc_put(struct timb_dma_chan *td_chan, struct timb_dma_desc *td_desc) { - dev_dbg(chan2dev(&td_chan->chan), "Putting desc: %p\n", td_desc); + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "Putting desc: %p\n", td_desc= ); =20 spin_lock_bh(&td_chan->lock); list_add(&td_desc->desc_node, &td_chan->free_list); @@ -390,7 +385,7 @@ static struct timb_dma_desc *td_desc_get(struct timb_dm= a_chan *td_chan) ret =3D td_desc; break; } - dev_dbg(chan2dev(&td_chan->chan), "desc %p not ACKed\n", + dev_dbg(dmaengine_chan_dev(&td_chan->chan), "desc %p not ACKed\n", td_desc); } spin_unlock_bh(&td_chan->lock); @@ -404,7 +399,7 @@ static int td_alloc_chan_resources(struct dma_chan *cha= n) container_of(chan, struct timb_dma_chan, chan); int i; =20 - dev_dbg(chan2dev(chan), "%s: entry\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: entry\n", __func__); =20 BUG_ON(!list_empty(&td_chan->free_list)); for (i =3D 0; i < td_chan->descs; i++) { @@ -413,7 +408,7 @@ static int td_alloc_chan_resources(struct dma_chan *cha= n) if (i) break; else { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "Couldn't allocate any descriptors\n"); return -ENOMEM; } @@ -436,7 +431,7 @@ static void td_free_chan_resources(struct dma_chan *cha= n) struct timb_dma_desc *td_desc, *_td_desc; LIST_HEAD(list); =20 - dev_dbg(chan2dev(chan), "%s: Entry\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: Entry\n", __func__); =20 /* check that all descriptors are free */ BUG_ON(!list_empty(&td_chan->active_list)); @@ -447,7 +442,7 @@ static void td_free_chan_resources(struct dma_chan *cha= n) spin_unlock_bh(&td_chan->lock); =20 list_for_each_entry_safe(td_desc, _td_desc, &list, desc_node) { - dev_dbg(chan2dev(chan), "%s: Freeing desc: %p\n", __func__, + dev_dbg(dmaengine_chan_dev(chan), "%s: Freeing desc: %p\n", __func__, td_desc); td_free_desc(td_desc); } @@ -458,11 +453,11 @@ static enum dma_status td_tx_status(struct dma_chan *= chan, dma_cookie_t cookie, { enum dma_status ret; =20 - dev_dbg(chan2dev(chan), "%s: Entry\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: Entry\n", __func__); =20 ret =3D dma_cookie_status(chan, cookie, txstate); =20 - dev_dbg(chan2dev(chan), "%s: exit, ret: %d\n", __func__, ret); + dev_dbg(dmaengine_chan_dev(chan), "%s: exit, ret: %d\n", __func__, ret); =20 return ret; } @@ -472,7 +467,7 @@ static void td_issue_pending(struct dma_chan *chan) struct timb_dma_chan *td_chan =3D container_of(chan, struct timb_dma_chan, chan); =20 - dev_dbg(chan2dev(chan), "%s: Entry\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: Entry\n", __func__); spin_lock_bh(&td_chan->lock); =20 if (!list_empty(&td_chan->active_list)) @@ -499,20 +494,20 @@ static struct dma_async_tx_descriptor *td_prep_slave_= sg(struct dma_chan *chan, unsigned int desc_usage =3D 0; =20 if (!sgl || !sg_len) { - dev_err(chan2dev(chan), "%s: No SG list\n", __func__); + dev_err(dmaengine_chan_dev(chan), "%s: No SG list\n", __func__); return NULL; } =20 /* even channels are for RX, odd for TX */ if (td_chan->direction !=3D direction) { - dev_err(chan2dev(chan), + dev_err(dmaengine_chan_dev(chan), "Requesting channel in wrong direction\n"); return NULL; } =20 td_desc =3D td_desc_get(td_chan); if (!td_desc) { - dev_err(chan2dev(chan), "Not enough descriptors available\n"); + dev_err(dmaengine_chan_dev(chan), "Not enough descriptors available\n"); return NULL; } =20 @@ -521,14 +516,14 @@ static struct dma_async_tx_descriptor *td_prep_slave_= sg(struct dma_chan *chan, for_each_sg(sgl, sg, sg_len, i) { int err; if (desc_usage > td_desc->desc_list_len) { - dev_err(chan2dev(chan), "No descriptor space\n"); + dev_err(dmaengine_chan_dev(chan), "No descriptor space\n"); return NULL; } =20 err =3D td_fill_desc(td_chan, td_desc->desc_list + desc_usage, sg, i =3D=3D (sg_len - 1)); if (err) { - dev_err(chan2dev(chan), "Failed to update desc: %d\n", + dev_err(dmaengine_chan_dev(chan), "Failed to update desc: %d\n", err); td_desc_put(td_chan, td_desc); return NULL; @@ -548,7 +543,7 @@ static int td_terminate_all(struct dma_chan *chan) container_of(chan, struct timb_dma_chan, chan); struct timb_dma_desc *td_desc, *_td_desc; =20 - dev_dbg(chan2dev(chan), "%s: Entry\n", __func__); + dev_dbg(dmaengine_chan_dev(chan), "%s: Entry\n", __func__); =20 /* first the easy part, put the queue into the free list */ spin_lock_bh(&td_chan->lock); diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c index 6595a54a4b97f..ecfaa6a765167 100644 --- a/drivers/dma/txx9dmac.c +++ b/drivers/dma/txx9dmac.c @@ -125,14 +125,9 @@ static struct txx9dmac_regs32 __iomem *__txx9dmac_regs= 32( #define dma_writel(ddev, name, val) \ (__is_dmac64(ddev) ? \ dma64_writel(ddev, name, val) : dma32_writel(ddev, name, val)) - -static struct device *chan2dev(struct dma_chan *chan) -{ - return &chan->dev->device; -} static struct device *chan2parent(struct dma_chan *chan) { - return chan->dev->device.parent; + return dmaengine_chan_dev(chan)->parent; } =20 static struct txx9dmac_desc * @@ -218,12 +213,12 @@ static struct txx9dmac_desc *txx9dmac_desc_get(struct= txx9dmac_chan *dc) ret =3D desc; break; } - dev_dbg(chan2dev(&dc->chan), "desc %p not ACKed\n", desc); + dev_dbg(dmaengine_chan_dev(&dc->chan), "desc %p not ACKed\n", desc); i++; } spin_unlock_bh(&dc->lock); =20 - dev_vdbg(chan2dev(&dc->chan), "scanned %u descriptors on freelist\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "scanned %u descriptors on freeli= st\n", i); if (!ret) { ret =3D txx9dmac_desc_alloc(dc, GFP_ATOMIC); @@ -232,7 +227,7 @@ static struct txx9dmac_desc *txx9dmac_desc_get(struct t= xx9dmac_chan *dc) dc->descs_allocated++; spin_unlock_bh(&dc->lock); } else - dev_err(chan2dev(&dc->chan), + dev_err(dmaengine_chan_dev(&dc->chan), "not enough descriptors available\n"); } return ret; @@ -267,11 +262,11 @@ static void txx9dmac_desc_put(struct txx9dmac_chan *d= c, =20 spin_lock_bh(&dc->lock); list_for_each_entry(child, &desc->tx_list, desc_node) - dev_vdbg(chan2dev(&dc->chan), + dev_vdbg(dmaengine_chan_dev(&dc->chan), "moving child desc %p to freelist\n", child); list_splice_init(&desc->tx_list, &dc->free_list); - dev_vdbg(chan2dev(&dc->chan), "moving desc %p to freelist\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "moving desc %p to freelist\n", desc); list_add(&desc->desc_node, &dc->free_list); spin_unlock_bh(&dc->lock); @@ -283,7 +278,7 @@ static void txx9dmac_desc_put(struct txx9dmac_chan *dc, static void txx9dmac_dump_regs(struct txx9dmac_chan *dc) { if (is_dmac64(dc)) - dev_err(chan2dev(&dc->chan), + dev_err(dmaengine_chan_dev(&dc->chan), " CHAR: %#llx SAR: %#llx DAR: %#llx CNTR: %#x" " SAIR: %#x DAIR: %#x CCR: %#x CSR: %#x\n", (u64)channel64_read_CHAR(dc), @@ -295,7 +290,7 @@ static void txx9dmac_dump_regs(struct txx9dmac_chan *dc) channel64_readl(dc, CCR), channel64_readl(dc, CSR)); else - dev_err(chan2dev(&dc->chan), + dev_err(dmaengine_chan_dev(&dc->chan), " CHAR: %#x SAR: %#x DAR: %#x CNTR: %#x" " SAIR: %#x DAIR: %#x CCR: %#x CSR: %#x\n", channel32_readl(dc, CHAR), @@ -333,11 +328,11 @@ static void txx9dmac_dostart(struct txx9dmac_chan *dc, struct txx9dmac_slave *ds =3D dc->chan.private; u32 sai, dai; =20 - dev_vdbg(chan2dev(&dc->chan), "dostart %u %p\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "dostart %u %p\n", first->txd.cookie, first); /* ASSERT: channel is idle */ if (channel_readl(dc, CSR) & TXX9_DMA_CSR_XFACT) { - dev_err(chan2dev(&dc->chan), + dev_err(dmaengine_chan_dev(&dc->chan), "BUG: Attempted to start non-idle channel\n"); txx9dmac_dump_regs(dc); /* The tasklet will hopefully advance the queue... */ @@ -402,7 +397,7 @@ txx9dmac_descriptor_complete(struct txx9dmac_chan *dc, struct dmaengine_desc_callback cb; struct dma_async_tx_descriptor *txd =3D &desc->txd; =20 - dev_vdbg(chan2dev(&dc->chan), "descriptor %u %p complete\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "descriptor %u %p complete\n", txd->cookie, desc); =20 dma_cookie_complete(txd); @@ -469,11 +464,11 @@ static void txx9dmac_dump_desc(struct txx9dmac_chan *= dc, { if (is_dmac64(dc)) { #ifdef TXX9_DMA_USE_SIMPLE_CHAIN - dev_crit(chan2dev(&dc->chan), + dev_crit(dmaengine_chan_dev(&dc->chan), " desc: ch%#llx s%#llx d%#llx c%#x\n", (u64)desc->CHAR, desc->SAR, desc->DAR, desc->CNTR); #else - dev_crit(chan2dev(&dc->chan), + dev_crit(dmaengine_chan_dev(&dc->chan), " desc: ch%#llx s%#llx d%#llx c%#x" " si%#x di%#x cc%#x cs%#x\n", (u64)desc->CHAR, desc->SAR, desc->DAR, desc->CNTR, @@ -482,11 +477,11 @@ static void txx9dmac_dump_desc(struct txx9dmac_chan *= dc, } else { struct txx9dmac_hwdesc32 *d =3D (struct txx9dmac_hwdesc32 *)desc; #ifdef TXX9_DMA_USE_SIMPLE_CHAIN - dev_crit(chan2dev(&dc->chan), + dev_crit(dmaengine_chan_dev(&dc->chan), " desc: ch%#x s%#x d%#x c%#x\n", d->CHAR, d->SAR, d->DAR, d->CNTR); #else - dev_crit(chan2dev(&dc->chan), + dev_crit(dmaengine_chan_dev(&dc->chan), " desc: ch%#x s%#x d%#x c%#x" " si%#x di%#x cc%#x cs%#x\n", d->CHAR, d->SAR, d->DAR, d->CNTR, @@ -506,7 +501,7 @@ static void txx9dmac_handle_error(struct txx9dmac_chan = *dc, u32 csr) * borked. Since we don't have any way to report errors, we'll * just have to scream loudly and try to carry on. */ - dev_crit(chan2dev(&dc->chan), "Abnormal Chain Completion\n"); + dev_crit(dmaengine_chan_dev(&dc->chan), "Abnormal Chain Completion\n"); txx9dmac_dump_regs(dc); =20 bad_desc =3D txx9dmac_first_active(dc); @@ -523,7 +518,7 @@ static void txx9dmac_handle_error(struct txx9dmac_chan = *dc, u32 csr) if (!list_empty(&dc->active_list)) txx9dmac_dostart(dc, txx9dmac_first_active(dc)); =20 - dev_crit(chan2dev(&dc->chan), + dev_crit(dmaengine_chan_dev(&dc->chan), "Bad descriptor submitted for DMA! (cookie: %d)\n", bad_desc->txd.cookie); txx9dmac_dump_desc(dc, &bad_desc->hwdesc); @@ -558,7 +553,7 @@ static void txx9dmac_scan_descriptors(struct txx9dmac_c= han *dc) if (!(csr & TXX9_DMA_CSR_CHNEN)) chain =3D 0; /* last descriptor of this chain */ =20 - dev_vdbg(chan2dev(&dc->chan), "scan_descriptors: char=3D%#llx\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "scan_descriptors: char=3D%#llx\n= ", (u64)chain); =20 list_for_each_entry_safe(desc, _desc, &dc->active_list, desc_node) { @@ -589,7 +584,7 @@ static void txx9dmac_scan_descriptors(struct txx9dmac_c= han *dc) return; } =20 - dev_err(chan2dev(&dc->chan), + dev_err(dmaengine_chan_dev(&dc->chan), "BUG: All descriptors done, but channel not idle!\n"); =20 /* Try to continue after resetting the channel... */ @@ -609,7 +604,7 @@ static void txx9dmac_chan_tasklet(struct tasklet_struct= *t) =20 dc =3D from_tasklet(dc, t, tasklet); csr =3D channel_readl(dc, CSR); - dev_vdbg(chan2dev(&dc->chan), "tasklet: status=3D%x\n", csr); + dev_vdbg(dmaengine_chan_dev(&dc->chan), "tasklet: status=3D%x\n", csr); =20 spin_lock(&dc->lock); if (csr & (TXX9_DMA_CSR_ABCHC | TXX9_DMA_CSR_NCHNC | @@ -625,7 +620,7 @@ static irqreturn_t txx9dmac_chan_interrupt(int irq, voi= d *dev_id) { struct txx9dmac_chan *dc =3D dev_id; =20 - dev_vdbg(chan2dev(&dc->chan), "interrupt: status=3D%#x\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "interrupt: status=3D%#x\n", channel_readl(dc, CSR)); =20 tasklet_schedule(&dc->tasklet); @@ -654,7 +649,7 @@ static void txx9dmac_tasklet(struct tasklet_struct *t) if ((mcr >> (24 + i)) & 0x11) { dc =3D ddev->chan[i]; csr =3D channel_readl(dc, CSR); - dev_vdbg(chan2dev(&dc->chan), "tasklet: status=3D%x\n", + dev_vdbg(dmaengine_chan_dev(&dc->chan), "tasklet: status=3D%x\n", csr); spin_lock(&dc->lock); if (csr & (TXX9_DMA_CSR_ABCHC | TXX9_DMA_CSR_NCHNC | @@ -696,7 +691,7 @@ static dma_cookie_t txx9dmac_tx_submit(struct dma_async= _tx_descriptor *tx) spin_lock_bh(&dc->lock); cookie =3D dma_cookie_assign(tx); =20 - dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u %p\n", + dev_vdbg(dmaengine_chan_dev(tx->chan), "tx_submit: queued %u %p\n", desc->txd.cookie, desc); =20 list_add_tail(&desc->desc_node, &dc->queue); @@ -717,11 +712,11 @@ txx9dmac_prep_dma_memcpy(struct dma_chan *chan, dma_a= ddr_t dest, dma_addr_t src, size_t xfer_count; size_t offset; =20 - dev_vdbg(chan2dev(chan), "prep_dma_memcpy d%#llx s%#llx l%#zx f%#lx\n", + dev_vdbg(dmaengine_chan_dev(chan), "prep_dma_memcpy d%#llx s%#llx l%#zx f= %#lx\n", (u64)dest, (u64)src, len, flags); =20 if (unlikely(!len)) { - dev_dbg(chan2dev(chan), "prep_dma_memcpy: length is zero!\n"); + dev_dbg(dmaengine_chan_dev(chan), "prep_dma_memcpy: length is zero!\n"); return NULL; } =20 @@ -812,7 +807,7 @@ txx9dmac_prep_slave_sg(struct dma_chan *chan, struct sc= atterlist *sgl, unsigned int i; struct scatterlist *sg; =20 - dev_vdbg(chan2dev(chan), "prep_dma_slave\n"); + dev_vdbg(dmaengine_chan_dev(chan), "prep_dma_slave\n"); =20 BUG_ON(!ds || !ds->reg_width); if (ds->tx_reg) @@ -900,7 +895,7 @@ static int txx9dmac_terminate_all(struct dma_chan *chan) struct txx9dmac_desc *desc, *_desc; LIST_HEAD(list); =20 - dev_vdbg(chan2dev(chan), "terminate_all\n"); + dev_vdbg(dmaengine_chan_dev(chan), "terminate_all\n"); spin_lock_bh(&dc->lock); =20 txx9dmac_reset_chan(dc); @@ -988,11 +983,11 @@ static int txx9dmac_alloc_chan_resources(struct dma_c= han *chan) struct txx9dmac_desc *desc; int i; =20 - dev_vdbg(chan2dev(chan), "alloc_chan_resources\n"); + dev_vdbg(dmaengine_chan_dev(chan), "alloc_chan_resources\n"); =20 /* ASSERT: channel is idle */ if (channel_readl(dc, CSR) & TXX9_DMA_CSR_XFACT) { - dev_dbg(chan2dev(chan), "DMA channel not idle?\n"); + dev_dbg(dmaengine_chan_dev(chan), "DMA channel not idle?\n"); return -EIO; } =20 @@ -1022,7 +1017,7 @@ static int txx9dmac_alloc_chan_resources(struct dma_c= han *chan) =20 desc =3D txx9dmac_desc_alloc(dc, GFP_KERNEL); if (!desc) { - dev_info(chan2dev(chan), + dev_info(dmaengine_chan_dev(chan), "only allocated %d descriptors\n", i); spin_lock_bh(&dc->lock); break; @@ -1034,7 +1029,7 @@ static int txx9dmac_alloc_chan_resources(struct dma_c= han *chan) } spin_unlock_bh(&dc->lock); =20 - dev_dbg(chan2dev(chan), + dev_dbg(dmaengine_chan_dev(chan), "alloc_chan_resources allocated %d descriptors\n", i); =20 return i; @@ -1047,7 +1042,7 @@ static void txx9dmac_free_chan_resources(struct dma_c= han *chan) struct txx9dmac_desc *desc, *_desc; LIST_HEAD(list); =20 - dev_dbg(chan2dev(chan), "free_chan_resources (descs allocated=3D%u)\n", + dev_dbg(dmaengine_chan_dev(chan), "free_chan_resources (descs allocated= =3D%u)\n", dc->descs_allocated); =20 /* ASSERT: channel is idle */ @@ -1061,13 +1056,13 @@ static void txx9dmac_free_chan_resources(struct dma= _chan *chan) spin_unlock_bh(&dc->lock); =20 list_for_each_entry_safe(desc, _desc, &list, desc_node) { - dev_vdbg(chan2dev(chan), " freeing descriptor %p\n", desc); + dev_vdbg(dmaengine_chan_dev(chan), " freeing descriptor %p\n", desc); dma_unmap_single(chan2parent(chan), desc->txd.phys, ddev->descsize, DMA_TO_DEVICE); kfree(desc); } =20 - dev_vdbg(chan2dev(chan), "free_chan_resources done\n"); + dev_vdbg(dmaengine_chan_dev(chan), "free_chan_resources done\n"); } =20 /*----------------------------------------------------------------------*/ diff --git a/drivers/dma/virt-dma.h b/drivers/dma/virt-dma.h index dd023a3831209..abf2ae737c30c 100644 --- a/drivers/dma/virt-dma.h +++ b/drivers/dma/virt-dma.h @@ -41,6 +41,11 @@ static inline struct virt_dma_chan *to_virt_chan(struct = dma_chan *chan) return container_of(chan, struct virt_dma_chan, chan); } =20 +static inline struct device *vchan_chan_dev(struct virt_dma_chan *vc) +{ + return dmaengine_chan_dev(&vc->chan); +} + void vchan_dma_desc_free_list(struct virt_dma_chan *vc, struct list_head *= head); void vchan_init(struct virt_dma_chan *vc, struct dma_device *dmadev); struct virt_dma_desc *vchan_find_desc(struct virt_dma_chan *, dma_cookie_t= ); diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h index fe33a20abc614..33aa1bfc8fb84 100644 --- a/include/linux/dmaengine.h +++ b/include/linux/dmaengine.h @@ -1803,10 +1803,15 @@ dmaengine_get_direction_text(enum dma_transfer_dire= ction dir) } } =20 +static inline struct device *dmaengine_chan_dev(struct dma_chan *chan) +{ + return &chan->dev->device; +} + static inline struct device *dmaengine_get_dma_device(struct dma_chan *cha= n) { if (chan->dev->chan_dma_dev) - return &chan->dev->device; + return dmaengine_chan_dev(chan); =20 return chan->device->dev; } --=20 2.43.0 From nobody Fri Sep 25 18:24:27 2026 Received: from AM0PR02CU008.outbound.protection.outlook.com (mail-westeuropeazon11013070.outbound.protection.outlook.com [52.101.72.70]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B6EF557F72E; Wed, 9 Sep 2026 16:23:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=52.101.72.70 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970989; cv=fail; b=QxRY9MZlwlRgVadYz42tgmP3kehb51n0klgs6nDG/6zUJAPJw01l3SZgQnTRTNN6OYzqj4lZbeL0LYpvcEC9W/Peqd1ST+wZEeBe4kcpWTsM2+ea2s976AVMUt2Y01Rx741+5+62Q8x5rU/4PfYdyq75bsIsmdpMv0lfzSIcIY0= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788970989; c=relaxed/simple; bh=Ua0YwGFSrxEWjUVeaNv4r7bsH+XK7b+1JLJ/YN4lWcM=; h=From:Date:Subject:Content-Type:Message-Id:References:In-Reply-To: To:Cc:MIME-Version; b=uA1gpmuhXfCuajTQfh30d8EnQFrr8k57cNuwkQGkN4NBHHdvKmXs1Knq7yEc3cCwyu2JjzETwfKN3UrqCIdQJDNc/ct28HoPmmAFLLDq6oUxqEUEV8Sag6vDgnfSnoN1vcn3t0+C+zK+R49EcsolTJ3XDgCrdROEtjOj826Gxd4= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com; spf=pass smtp.mailfrom=oss.nxp.com; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b=EgkGXJrI; arc=fail smtp.client-ip=52.101.72.70 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="EgkGXJrI" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=PmCyBJFF4/JJjLvKG4S0lQFVDQ3CETjF7DRX3GWG6w0zdWdVpUobRijswCdDFV0LLt1cZ7ISO4BHIQ9zvqubOJThoutdeOp4yDjWs5D5VrMGUoW/36jWMGNbXZaeXct1oV6ZJmJPkCJ1ObGMc/J7oKQwmam7knVMvSlX1cdMFa/GQIqWzi6qG9woQWiMBKNJPp8kXjIWZdW9SVwRxDEuvXtonJzkw4QLlLRJaMHOtAesfcL3R1x0oVkauZEpItngpWOGFTf+E80rdnbEZmA6VFyxpWZMNxsno0z3s1fQoH/nOWKJNY/9Z1jV4phY2ce07CEQAplG45VCFOuDHdM7nQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=7abauvZzDACK0Ed+1mJvu+H/+yYSq0K/zf/n2yHRa2E=; b=xtDCjuB4wLKnX/IkKFMRBnsHIJ6dhgXexcJNJAdc9In/arQTdTFuAPGok0bVCHEsZ91dLquC0t2UOxqBcwHPxdw3N4Bvp/qIw0GMH+mTe6o5XB1ir2oTSrhXWSE9phZMYVO1j0eoFoglg8ccRGh18soT8joNaFoAlTOV/pT9LgZwlmcJgB2ssGnpXBEAnrl8S8m3OXAkybUS6/8Wr1YFzo7vWRVa3zgDbp/uqM+MQb2ZuBrE0ROm08Z8Iq2puj0HI/MrrkEZVry40rv78P5lQO095+5dqchnebG4f1XH70gmioRi4KMl59Cdu1UCYr7Q15ZMGzcw6PP5Crq5iKZoOA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector1-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=7abauvZzDACK0Ed+1mJvu+H/+yYSq0K/zf/n2yHRa2E=; b=EgkGXJrIDu9sZjzAztwkv+/7JgE6a23nn4l/AE4CZYkVwcdlr4Yiu+Hz7AbgUeX//MKqrKKSyj6ior48Tz3WcNUO0mlup0QPCCcA0sCm8XdG3sBaMGNEoV063Rmm0pJNHLSlcegEknajkXQiVtLcQZGPghal/eNowK/Ta3kqQG3yARB0MvV/RqKrQA4yQb5YkJTzh1GmOKzD0h+VKNJdClXGSXz3RbBnUk+N2R9fF3q4NpUa3JrmmUwkgmMHlpJYVYgjzjtTdQ64NZTqGGcr8g5PSjMcnQjdm2xUml1Bqxc56RK7CSomBeX3V7RAmGsZUjmy2zFf9TuCrw5dF6NPjQ== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) by AM0PR04MB6786.eurprd04.prod.outlook.com (2603:10a6:208:184::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.406.7; Wed, 9 Sep 2026 16:22:58 +0000 Received: from GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c]) by GV2PR04MB11799.eurprd04.prod.outlook.com ([fe80::2146:83a2:5329:b7c%7]) with mapi id 15.21.0406.005; Wed, 9 Sep 2026 16:22:58 +0000 From: Frank.Li@oss.nxp.com Date: Wed, 09 Sep 2026 12:22:31 -0400 Subject: [PATCH v4 4/4] dmaengine: add union chan_dev for dma_chan::dev for clarity Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260909-dma-chan_dev-rename-v4-4-d8fb6892a70f@nxp.com> References: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> In-Reply-To: <20260909-dma-chan_dev-rename-v4-0-d8fb6892a70f@nxp.com> To: Jacky Huang , Shan-Chun Hung , Vinod Koul , Frank Li , Paul Cercueil , Eugeniy Paltsev , Andy Shevchenko , Binbin Zhou , Patrice Chotard , =?utf-8?q?Am=C3=A9lie_Delaunay?= , Maxime Coquelin , Alexandre Torgue , Steven Rostedt , Masami Hiramatsu , Mathieu Desnoyers , Thierry Reding , Jonathan Hunter , Ludovic Desroches , Viresh Kumar , Keguang Zhang , =?utf-8?q?Andreas_F=C3=A4rber?= , Manivannan Sadhasivam , Daniel Mack , Haojian Zhuang , Robert Jarzmik , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Kelvin Cao , Logan Gunthorpe , Laxman Dewangan , Vignesh Raghavendra Cc: linux-arm-kernel@lists.infradead.org, dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mips@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-trace-kernel@vger.kernel.org, linux-tegra@vger.kernel.org, linux-actions@lists.infradead.org, linux-sunxi@lists.linux.dev, imx@lists.linux.dev, Frank Li X-Mailer: b4 0.15.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1788970951; l=6095; i=Frank.Li@nxp.com; s=20240130; h=from:subject:message-id; bh=gHj52vD4WNLOndR1YWKRKx1PK/eHQkOd6+tAOWX9+Io=; b=rLyrCMSAaeqf737nI0+3KNhYuzF/PHdlwAvBsq4aslxfuLfa/LjJBtXopLfwIeM8T6ydrDSDy +nEvaBDW1XCCj3gdk9RYqFRLEuKRCAio2Q4L8qi7QDJ3vYzzyYeyJdN X-Developer-Key: i=Frank.Li@nxp.com; a=ed25519; pk=I0L1sDUfPxpAkRvPKy7MdauTuSENRq+DnA+G4qcS94Q= X-ClientProxiedBy: PH7P221CA0030.NAMP221.PROD.OUTLOOK.COM (2603:10b6:510:32a::35) To GV2PR04MB11799.eurprd04.prod.outlook.com (2603:10a6:150:2cf::9) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: GV2PR04MB11799:EE_|AM0PR04MB6786:EE_ X-MS-Office365-Filtering-Correlation-Id: e9789093-cbbd-4b38-eae2-08df0e8e9c8f X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|7416014|376014|19092799006|366016|23010399003|1800799024|921020|10067099003|56012099006|11063799006|22082099003|18002099003|41080700001; X-Microsoft-Antispam-Message-Info: 7pwalToPSEwKsAy69W6aq4wBxqMbZUAqZVi7/iqc30RZq7sT1hV7GsGncKTcJ5Xd90zhx2Rqlk8JgnmGU3uzTMhualDiWh1izNfs02o2/qeKMopcncWswenOkIH/wb8ExokO0v6Ru6cIRg46jVZopD+EiAfXHafh6QL/THWwvi/j2zM0c5lcpUfQ4pfNGGTcrcrupeADkfznMpf8jHC8nk3XglM1gN8LGImA2+p48p4kES5981HPQlkiN545fiKDp5JHgVaqNLLB/riplH7mSvtph8fhh2v7ta3+HhAXaF9V9hKl99eMCAWzmV0rqlqMdM3NrBAaINiZGidPxpZ7G7iUja/OIO2ij6VhD4jWB1+4p9NOdiv9IdHlZMXgCO5d3Dtcpo/Wm2of5wLSrsoQ+jhVdDhoBdXSJMeWKnpFAJqkkOQv7YKPOOQE4CmTmDf/qcbFTphqM16qpfTeSQ0X0F+nAyyDs5DTi5XZuEXMlj+R9MVX+8TRu/8my7W5umWtFvghnhEagAvWmN69uB+Es5f5L821ZgiuyQQkMyNCtEiQxV3L/mm78yJocnNfFLN0Q+1ZDjsI0RbIPBbXq3yfnNaHEMMgKhr+/cB1/4GzyKmJpCa4iAv3efmpbTdz0wXNECJa5uipwDF55JMUSMOvP3vK/VxKp3rZlvtCEi24G1DNjsby0UgzDSq/uQyDtmCW3/qWNSDF3n1r/cyK3heTPnlfpsaMJT0QZh57G+t/qynP+tA1limnJDzQyb/UqWKI X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:GV2PR04MB11799.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(7416014)(376014)(19092799006)(366016)(23010399003)(1800799024)(921020)(10067099003)(56012099006)(11063799006)(22082099003)(18002099003)(41080700001);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?QXJxenBuQWt5MXhJdkU2alpTb216QWZobTNiK056R1lJRG5pUjRRRk5DY0J5?= =?utf-8?B?cTl5SDZUSHJTc0wvVGxsdEg1YU1QZDRtSDJJQkg0ekpMbEpyVGduck9kNFJT?= =?utf-8?B?c25MeU01M2FjYS9uMWR6RDNTSUk1MENIbXI2cUw0S01FazRyblMxNlMzWjQv?= =?utf-8?B?b2tGUUMxdlEyS0REaHNWcWZGdmpoZVpKd0lYMjE2aXdIKzd5Qkc2R09nRFl0?= =?utf-8?B?MkdXTFp1L3NKaW02Tkh6ZTU1WXMzY01FYWZ5Z1czTEZqY1dHcEJsb2QxUTJ3?= =?utf-8?B?Z3RxdkI0UG95SlRQUHViRUVtUjRoUmxrR3cvZ0dNa3ZvalE3SU9qTVphazZr?= =?utf-8?B?TG95d01sYTFoN3RhdFpjeDg3S09LL09ydml6QnN3eDhXVmsrVDBYejdZeWRu?= =?utf-8?B?VGtYQ0JpQUZUc3pra1J3SWgvUHNaNk1idjY2anNuTXRUY0R3MmNzb1RGbGxv?= =?utf-8?B?TWJjZXVDWXBUdGpBMDJqd2wzTVFQUzZnakFqOWt4UHlDQjlYYWU1bERERVFL?= =?utf-8?B?UTFDSGVDQThFU0J0ZnVLMWozY0VUc2U4eVFzVnpXUno1bGIyOGNmaGVlWW9o?= =?utf-8?B?a1ZzNFJuWFFMdUh0WndyOHpBQUQ4b1FuSjJETURFZjkwZ1JuOGUxRmNUY0RU?= =?utf-8?B?OVlydVpzSUlHN3JOZEg3enVDYWdlaWRiZGtQcnQzS2NDQzlueXJ6YzBCcFk4?= =?utf-8?B?QlFraTlqTDRRM0tIVWRwUmJibm0wcm1TVXUySUdqSG1rc3ZIVDNlTEZNYTY5?= =?utf-8?B?elVtWGZjamdHY1NFY3lnVmJiODZoV3lUS3Q2a29mOWdTcVhOeXJVWlhzYmdy?= =?utf-8?B?NVE1eXdGVy9aOFFhYjJsT1lickhmRGlKWExaSTIyVjNzK1ZJVUNIVUM2bDgr?= =?utf-8?B?ZUhMNDdrKzZnVHNNbTE3OG40TnRkK2s2d3dkMk43V0llMTZVU1ZwMzJhNDZy?= =?utf-8?B?eGFzL2p1SitlL0dKdHBoVXFUdHc4TE5tMUNZVENjSEhIdkFUL0pNTEo1Nmwx?= =?utf-8?B?NkJNeVFmMEwraTZubERPQ09hWDNwUWI3NjJBSWRuK0ZDRWxsV2ZQKzd2bFYw?= =?utf-8?B?RUxYUHhCSXU2SjZlaEdkemZFZDRlWEViZ3FNaFZTbTRtaVJyOWNvUExkaVNx?= =?utf-8?B?VW1IbU9NNEp0OWgyZXhrMUc3bGtTcVh4WElNRVlSUExTMWw3K2NsdThHbU0r?= =?utf-8?B?ZlBDOW0xNTM3VjBFMGxYVkZpY1pIcFFUbmxNNURNWTNwMG9wN2dhOXdnb3Vy?= =?utf-8?B?ZnNlMGdHZHhETUZtaGRNY0NpbS9pWm53K1pZZFowcktpY2c3K1k2MTRoaG11?= =?utf-8?B?VmZ4OVlUUElyNkVRRGZ5OS9Ibm9RaHNOTXdxL21OdjBxcGhGaHk3blVxejBa?= =?utf-8?B?cnNHZFZrT3dtcjNoUEE4Zk5jMDdXSDBuRXJTQU1MenJod1BCNjZlT2Z1WjFF?= =?utf-8?B?MnBDTkF6b0xJQlRKV1VZdWRUZnhDM0QrNFNGTm45dXIwa0tIMDFyRmNGUW43?= =?utf-8?B?bjZaNS9pQ0d4a0xyeEpHaFl0U0Q2dXRlcEp0NkpMMUM3SVZFdmVuYks0VitH?= =?utf-8?B?RjhMZFNsQ0N0YXJGZnJVOE5JVWZXUXFBblhwVVcwZWs3WTJOVnpRUndBMHNE?= =?utf-8?B?VDdLMTA5ZCs0VkIrcyszcFpGVXZvcWFEZ1pINkhlZDYrRHhOQVZubzVST2ZY?= =?utf-8?B?N3ptSDF3RFpPNVZxRDhtRU9YdTdMYnlGSXN3RFJIQ0xCK0ptajdEMmVKZ1RE?= =?utf-8?B?Wkx3RUpidXJnRkNyeHJ2VE9CWGlhaEZHRC9DNHBHb0dJTFZjQUZETGQ1KzVu?= =?utf-8?B?OS80M3pRNnQ5WEQ5emtxbm02TEM4cllkTWppNmg2MFpLSFJRQ3BNeHBDUWZJ?= =?utf-8?B?dFEzSkhnMjJ5bUJmQmVUdFZYQnlCUHNGV2RoWG5TVnZ6UWxWUzVaZHVmdW1L?= =?utf-8?B?OFZySGd5akh2cE1yampUOUpuRCtPWlozVjEwdm5KUVgxandGcHN6MDNMSzNE?= =?utf-8?B?N2ZuK1ZGOFJwYlUyT21rL2lpT09aNEs0TEhHTi94aHhlZVN6dCs3UWFLWTFz?= =?utf-8?B?aTlvR0ZlWmFselpPcTR2VWdjZ081RnV0Rmd2a1lldFEyckxSZFlDQ3crdjNZ?= =?utf-8?B?VEVNUTA4Q2EwU2RDZUV5c2FlZ1FrYmVpemhGbHdhaDhNNWMyb1VUTGFXZm9z?= =?utf-8?B?bFdYUWVwdnRXV21hY3QzY3pZMXEyRTJwaXd4bXpqRnNWZTdOUzVNY0VZQ1p4?= =?utf-8?B?M1p4VEtndnMwZTdSSEN5Vk81N1kydXc4NGV4dUFmT0lmVmIrSUo5czBMMzBz?= =?utf-8?B?UjBEV0RPMXZRZDVrNy9hc3FxQVBldDNNano0OGU3aVpuckwwdHRBVzh1L1Zl?= =?utf-8?Q?ZreykT2TGIlkyqv4jViBjl4Q5vWkVQs8xbZXY?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: e9789093-cbbd-4b38-eae2-08df0e8e9c8f X-MS-Exchange-CrossTenant-AuthSource: GV2PR04MB11799.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Sep 2026 16:22:58.6470 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: ZZEiLnC4iI5iaYVem9V5CjQuUahbxiCPKaloEtNgbWFGZaLx/irSfO7ZMxY1afLo3owBgZvjYViOBtCvoiOzAat6oKocfDa+mjyKR8hSWrMSAMUsl31RKH8JVt5RV58a X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR04MB6786 From: Frank Li The current dma_chan structure contains both "device" and "dev". So chan->device->dev refers to the DMA engine device. chan->dev->device refers to the per-channel device instance. Their similar naming makes the distinction unclear and increases reader confusion. Add union dma_chan::chan_dev to make its purpose explicit and clearly identify it as the per-channel device. After all user switch to chan_dev, union and dma_chan::dev will be removed. Update the kernel-doc accordingly. Besides its sysfs usage, the per-channel device is also used by some DMA engine drivers for IOMMU mapping and therefore deserves a more accurate description. No functional change intended. Reviewed-by: Logan Gunthorpe Reviewed-by: Andy Shevchenko Signed-off-by: Frank Li --- there are other user use it outside drivers/dma/ directory. --- drivers/dma/dmaengine.c | 14 +++++++------- drivers/dma/tegra186-gpc-dma.c | 2 +- drivers/dma/ti/k3-udma.c | 4 ++-- include/linux/dmaengine.h | 18 +++++++++++++----- 4 files changed, 23 insertions(+), 15 deletions(-) diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c index a7ac2729e4d9d..bb30a9aa54d3f 100644 --- a/drivers/dma/dmaengine.c +++ b/drivers/dma/dmaengine.c @@ -1083,8 +1083,8 @@ static int __dma_async_device_channel_register(struct= dma_device *device, chan->local =3D alloc_percpu(typeof(*chan->local)); if (!chan->local) return -ENOMEM; - chan->dev =3D kzalloc_obj(*chan->dev); - if (!chan->dev) { + chan->chan_dev =3D kzalloc_obj(*chan->chan_dev); + if (!chan->chan_dev) { rc =3D -ENOMEM; goto err_free_local; } @@ -1103,8 +1103,8 @@ static int __dma_async_device_channel_register(struct= dma_device *device, =20 dmaengine_chan_dev(chan)->class =3D &dma_devclass; dmaengine_chan_dev(chan)->parent =3D device->dev; - chan->dev->chan =3D chan; - chan->dev->dev_id =3D device->dev_id; + chan->chan_dev->chan =3D chan; + chan->chan_dev->dev_id =3D device->dev_id; spin_lock_init(&chan->lock); =20 if (!name) @@ -1122,7 +1122,7 @@ static int __dma_async_device_channel_register(struct= dma_device *device, err_out_ida: ida_free(&device->chan_ida, chan->chan_id); err_free_dev: - kfree(chan->dev); + kfree(chan->chan_dev); err_free_local: free_percpu(chan->local); chan->local =3D NULL; @@ -1155,7 +1155,7 @@ static void __dma_async_device_channel_unregister(str= uct dma_device *device, __func__, chan->client_count); mutex_lock(&dma_list_mutex); device->chancnt--; - chan->dev->chan =3D NULL; + chan->chan_dev->chan =3D NULL; mutex_unlock(&dma_list_mutex); ida_free(&device->chan_ida, chan->chan_id); device_unregister(dmaengine_chan_dev(chan)); @@ -1290,7 +1290,7 @@ int dma_async_device_register(struct dma_device *devi= ce) if (chan->local =3D=3D NULL) continue; mutex_lock(&dma_list_mutex); - chan->dev->chan =3D NULL; + chan->chan_dev->chan =3D NULL; mutex_unlock(&dma_list_mutex); device_unregister(dmaengine_chan_dev(chan)); free_percpu(chan->local); diff --git a/drivers/dma/tegra186-gpc-dma.c b/drivers/dma/tegra186-gpc-dma.c index b3327aa35de40..e76c58f213d84 100644 --- a/drivers/dma/tegra186-gpc-dma.c +++ b/drivers/dma/tegra186-gpc-dma.c @@ -1554,7 +1554,7 @@ static int tegra_dma_probe(struct platform_device *pd= ev) return dev_err_probe(chdev, -EINVAL, "Failed to get stream ID for channel %d\n", tdc->id); =20 - chan->dev->chan_dma_dev =3D true; + chan->chan_dev->chan_dma_dev =3D true; } =20 /* program stream-id for this channel */ diff --git a/drivers/dma/ti/k3-udma.c b/drivers/dma/ti/k3-udma.c index 49e2d0014d5ed..78a67cb9d6e00 100644 --- a/drivers/dma/ti/k3-udma.c +++ b/drivers/dma/ti/k3-udma.c @@ -426,12 +426,12 @@ static void k3_configure_chan_coherency(struct dma_ch= an *chan, u32 asel) =20 if (asel =3D=3D 0) { /* No special handling for the channel */ - chan->dev->chan_dma_dev =3D false; + chan->chan_dev->chan_dma_dev =3D false; =20 dev_clear_dma_coherent(chan_dev); chan_dev->dma_parms =3D NULL; } else if (asel =3D=3D 14 || asel =3D=3D 15) { - chan->dev->chan_dma_dev =3D true; + chan->chan_dev->chan_dma_dev =3D true; =20 dev_set_dma_coherent(chan_dev); dma_coerce_mask_and_coherent(chan_dev, DMA_BIT_MASK(48)); diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h index 33aa1bfc8fb84..c3a49a33307c6 100644 --- a/include/linux/dmaengine.h +++ b/include/linux/dmaengine.h @@ -325,7 +325,8 @@ struct dma_router { * @lock: protect between config and prepare transfer when driver have not * implemented callback device_prep_config_sg(). * @chan_id: channel ID for sysfs - * @dev: class device for sysfs + * @chan_dev: class channel device for sysfs, some device use it for per-c= hannel + * IOMMU mapping. * @name: backlink name for sysfs * @dbg_client_name: slave name for debugfs in format: * dev_name(requester's dev):channel name, for example: "2b00000.mcasp:tx" @@ -351,7 +352,14 @@ struct dma_chan { =20 /* sysfs */ int chan_id; - struct dma_chan_dev *dev; + union { + struct dma_chan_dev *chan_dev; + /* + * Use chan_dev; dev will be removed once all users are + * converted. + */ + struct dma_chan_dev *dev; + }; const char *name; #ifdef CONFIG_DEBUG_FS char *dbg_client_name; @@ -532,7 +540,7 @@ struct dma_slave_caps { =20 static inline const char *dma_chan_name(struct dma_chan *chan) { - return dev_name(&chan->dev->device); + return dev_name(&chan->chan_dev->device); } =20 /** @@ -1805,12 +1813,12 @@ dmaengine_get_direction_text(enum dma_transfer_dire= ction dir) =20 static inline struct device *dmaengine_chan_dev(struct dma_chan *chan) { - return &chan->dev->device; + return &chan->chan_dev->device; } =20 static inline struct device *dmaengine_get_dma_device(struct dma_chan *cha= n) { - if (chan->dev->chan_dma_dev) + if (chan->chan_dev->chan_dma_dev) return dmaengine_chan_dev(chan); =20 return chan->device->dev; --=20 2.43.0