From nobody Mon Mar 23 21:28:58 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (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 9AB8A3AF643 for ; Mon, 23 Mar 2026 15:17:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774279062; cv=none; b=rnWaEn9Bwoev3nPqGK9u94I4+HQ3tJHlijDCikgkG5wr95ZFuPL7a8cO9geqzX5CTxoMIXvNHJdY8wQFiFEiOFeZYZRbmxoTyrwoI0t4l8azGT58/ze2Y/fLg4bG5TD0CDMrzcLeIm9dm1ap6zMj+ojtb+1eBurX7/ybKj2w18U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774279062; c=relaxed/simple; bh=rWOE47026mczpuQ+OpCmY6UmFXFZSFt73L3FX2KDFWk=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=c19a2u1v/ldSAiEqMzGgjMUv71sc7qj+Wf0OlwZVMyl4NEgCkPa7lyBdJQcaYxA2uktQyeLw03USrgAgyep3//Bt9CAGaiftGBixfaM/gpV6L3cVTkev57OmR17iq2Lv6Ra0+4gcpC00OCJuxAuGo7G/plkiKZns4oOE9RSxPGg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=oss.qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=WXc6WxQv; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b=F6L2IfoD; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="WXc6WxQv"; dkim=pass (2048-bit key) header.d=oss.qualcomm.com header.i=@oss.qualcomm.com header.b="F6L2IfoD" Received: from pps.filterd (m0279869.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 62NFGWP3600276 for ; Mon, 23 Mar 2026 15:17:39 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=qcppdkim1; bh= 2y0wDnbloqZyr+tffy5v2L5LGuKsXqmk7G5sbV/+toc=; b=WXc6WxQv7ig6fn+V PQzxiOo7hKM+KAo3gzR/j4J1/VPTZZtuPtGj9IBeLdUWMrQIlHdm6K+oNTfnKUm4 Ax92xwqHsVffCFnJaib9h986D+SSVO+ZIO5n7uuUwmG1VhRgoRpzY+RMOIPaDIql hgc5TWBopFjr6zB2U7gXWl7WHaKMrtZoHII41tqSI060kYmaAmMLf6yc9ij3sOhA YVWasxLl4izCv9TZqafJqR+4wtb5JFMTYwKJCk8aPEtm9Yg4tVPgAH1vM2H7mL1S kzQKP4V1Thvo5BN5Wf7qLeb4io1ie3Myb+enGccJGyj9nn7FmyQJs9hVrKfNuRLM 1AdF+g== Received: from mail-ua1-f70.google.com (mail-ua1-f70.google.com [209.85.222.70]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4d34vkrs71-1 (version=TLSv1.3 cipher=TLS_AES_128_GCM_SHA256 bits=128 verify=NOT) for ; Mon, 23 Mar 2026 15:17:39 +0000 (GMT) Received: by mail-ua1-f70.google.com with SMTP id a1e0cc1a2514c-94ea747d58eso1247181241.2 for ; Mon, 23 Mar 2026 08:17:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oss.qualcomm.com; s=google; t=1774279059; x=1774883859; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=2y0wDnbloqZyr+tffy5v2L5LGuKsXqmk7G5sbV/+toc=; b=F6L2IfoD0tQZ0dbBR9il4hWvTezAySCa0Yh8MMoQDugTaU0vIy9cArFaNSEPUMv5Mp ZCRWjt++NY7OaQ/MAnoWu88yFidhYItkjWEIydJYAlO9j1ARkNAGzSmIpUnl3baY8s42 XcVuBtJ96W882jBdO8SfvLNWybVRYrTFH/F5zJQp4CPARf2rQqIJxo4QBqxfrqOscc6F XgwTf5NFJKwKczfTPq3uTtw6W7YbL6LogZL5GL1QpEgQh3WyzO4daAjvEK17QGQr7Dpe SLoJHCIdnUL7+KX6ZBG0V76mzXEAx8WnRs7YllUAL73HJCkki8CqLS4xJxx5wdqAG1Ew vt0Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1774279059; x=1774883859; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=2y0wDnbloqZyr+tffy5v2L5LGuKsXqmk7G5sbV/+toc=; b=NpPQdfFFaFU88Fmukz21T7Vr9xzzU033UZhYenyt8E6TnOfUTRi/RwBFrrBxxv+DX3 dVlwSkv2mCep4oaYSBabTWl7iRKDl3eZcDJBhnJpw/+VQU4brLXRMCGi9Ip5gM3bQJTT /nwef7qZmME3U8lFhwiDCJef91Gi9vAkYZfgdput4pddM/EML6FxOqDX5ZT5J+fXapjk EXJrS2LKp6WHTkr+Mphw/8VU+u3A/ps5r6+0RE+IJfjuBy2O1cO4P+9PblJ75HJ/2zQ+ hwWqDd9vY7GtnlL1IUr3NMHD8fJS4JppvnIHogQCY25KuEh+d7VlJVoc1y8Ov9S/1n+O iU0Q== X-Forwarded-Encrypted: i=1; AJvYcCXbfOOL4EMml77bf2LGD74ZYX5Gj39cJFFxuuIAOA3H2gcZM7iGbyqqqXo/PBXjDER6YYdjVtKBYfQM3U8=@vger.kernel.org X-Gm-Message-State: AOJu0YzfltY4+wxbDqNmOrSNJYWXQpS+jYZb9lqWP3TWptQJuiMZ4I+f p9As6gOE6WTx8euDqtKS/b7IFJmLK4XmZUwqrw/fNVcz8GI5zPtRcAGrW9dYAFZH+c7/kXCR+es f/FneTrJ42zOB1dqXmz6TzmKnX0YuSNypgiEHrGUzG41jesQ9aVEcFNW5Sgdjv7njwD0= X-Gm-Gg: ATEYQzys4kXJl/mahd/vp8EQEsIsYo/++l7qWoc7p7AhQVDbkG7S6JCH4frlmZMBgi1 FTUro3n+Hz3hGSmFSMKAlqYJCuVgrGC3pyD725zxC7i7zBhFF2FLP2xcKfSfbPT1sfkHvNn4B5c YJQJ+WDhnXXJ3UCmFJbAr99rUgufSN7JCYi8ihT35UUVUuOfftPOugIhbvdGlsVhOdDNyD5TfaZ yg3edCNXqpa7+ORmAr12oUFM6uTRjHlJVs7olKQopPp52Fwo7Cqb2vQgqYeSek6+Cop6ueIR09A oqNUSstjkUKxKQARvItaZSu/C5RABnWduWxSeoKt8OnX0xzCaQBpWIzLpoCj7mms60BFtnby5NF VC41fMFxSFxwUZvOcpgYdKY+P47A2bqGwOXZ9ekZ8qOXTHmCIPeMb X-Received: by 2002:a05:6122:d1e:b0:56c:d59a:cfe4 with SMTP id 71dfb90a1353d-56cde47e3camr5670689e0c.17.1774279058968; Mon, 23 Mar 2026 08:17:38 -0700 (PDT) X-Received: by 2002:a05:6122:d1e:b0:56c:d59a:cfe4 with SMTP id 71dfb90a1353d-56cde47e3camr5670592e0c.17.1774279058409; Mon, 23 Mar 2026 08:17:38 -0700 (PDT) Received: from brgl-qcom.local ([2a01:cb1d:dc:7e00:f9a0:d7e2:7eb6:79b5]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-43b644bd923sm35936993f8f.12.2026.03.23.08.17.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Mar 2026 08:17:37 -0700 (PDT) From: Bartosz Golaszewski Date: Mon, 23 Mar 2026 16:17:11 +0100 Subject: [PATCH v14 05/12] dmaengine: qcom: bam_dma: add support for BAM locking Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260323-qcom-qce-cmd-descr-v14-5-f323af411274@oss.qualcomm.com> References: <20260323-qcom-qce-cmd-descr-v14-0-f323af411274@oss.qualcomm.com> In-Reply-To: <20260323-qcom-qce-cmd-descr-v14-0-f323af411274@oss.qualcomm.com> To: Vinod Koul , Jonathan Corbet , Thara Gopinath , Herbert Xu , "David S. Miller" , Udit Tiwari , Md Sadre Alam , Dmitry Baryshkov , Manivannan Sadhasivam , Stephan Gerhold , Bjorn Andersson , Peter Ujfalusi , Michal Simek , Frank Li Cc: dmaengine@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org, brgl@kernel.org, Bartosz Golaszewski , Bartosz Golaszewski X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=9224; i=bartosz.golaszewski@oss.qualcomm.com; h=from:subject:message-id; bh=rWOE47026mczpuQ+OpCmY6UmFXFZSFt73L3FX2KDFWk=; b=owEBbQKS/ZANAwAKAQWdLsv/NoTDAcsmYgBpwVl/U2pDgQv5YxJHbZX0VcINEtapypUTtW6+Q G08A0O5glWJAjMEAAEKAB0WIQSR5RMt5bVGHXuiZfwFnS7L/zaEwwUCacFZfwAKCRAFnS7L/zaE w238D/9yCNG/4+r3GzaQR/gjiJCNM1R+ndI3hsQQnE2EU5YjB9lPbmyo+6Frz5Mnxa6DJAxmprz ASU3k8COi5+hBlGRgZOFGnObO+ztW7s6w3gSYgn0KnMhJ0Eb5SbHTE30ZecNSCV+wZlmhztJ2xU dq8dURfoGz/hsU/nK0Uqa/eFXYkWwkHHzsf8/FCDwgUVFY93K1DJA6AEsFiQlgG9WOBvegOGk8b LxQXXZTF7Qnu0wv9pz1iC4Em8Lrg5svC1n31PLNPUh8LGEeAyRp4rDtbIZa5zsvI+MHFwCKNV3P kvurpbgqj6DoYiX3OFwFVErqJ10G4UBuLpLWePWcdZdmV1FzVoV0GrCYnH9lErTJxKVqkj5h+7/ BGHa/lVEN8WjuXTiJaoyNrUFlFgt8DurWofp1OOJ7L+ho9Kot3Gb96cyV2xRqYeHj7zkLPnb94R FH+/A9IPopOM1CbQl331/HFRfA7rNzp5hLJAeH4QRv9qaz5Ohvd2wQ6pEjgqw1VGjYUURzErbcE l/Kfjf/IX13AFA3sA6pdwoQZMkM61DxGFxngVVQoe0kH2akN0lt7/AzDCzlnoZm0M0TQDsFhUSm hAWF4RnTvLK/wjeuniT6zb7uTWMhXrzeIhioku2Rb5+buHYxOuIHOwrMe0pO+AlS5CDL4hTW5qr y6v1a/Xu/M/OULw== X-Developer-Key: i=bartosz.golaszewski@oss.qualcomm.com; a=openpgp; fpr=169DEB6C0BC3C46013D2C79F11A72EA01471D772 X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMzIzMDExOCBTYWx0ZWRfX4F7gyJec3Odf 0q2YaL/GMW+yS3b/5zaaKBigG53B3cK7FV5xH6vDXGxnotmz2HTATxQY9ShIeV+gWvbqDG6bE1y 4mnD39xcSSnb8rEudyAwyKbpCNBEdomUyG3BAyTmn8b6tzxPzur0x9y+g5hadhQuxK3E2dl+EJe 97tbWH8HVhGr56cJF9q8iyoktdjrSRVkYjKqQ1IPuIIhSIND0ItrBTmxfhccbCdowkmBUweEokD UjylOE3YrxIwshyThVu2dlYXx+5R6u5/u7h9ObkCkw1vyWTm/OE9dIeX29huvKe7A3mPZ0HP840 wdnorAM66arkl89wiMgmZW7aZ0fgCPffrLWHHeuUKoU7MXx4yQhLmdfXOQzXdlRfwv3UlSBk4RP BRMxZL6g2YvXL9xLMMxzXgYZeXgCvKRxpZFd0w+6AvyZ+v2uvnj9TQTSnJOnPESogqoXToglPJ7 wyxE5BXMenxP2XxJVzQ== X-Authority-Analysis: v=2.4 cv=eMoeTXp1 c=1 sm=1 tr=0 ts=69c15993 cx=c_pps a=R6oCqFB+Yf/t2GF8e0/dFg==:117 a=xqWC_Br6kY4A:10 a=IkcTkHD0fZMA:10 a=Yq5XynenixoA:10 a=s4-Qcg_JpJYA:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_glEPmIy2e8OvE2BGh3C:22 a=EUspDBNiAAAA:8 a=RdU2YfPBjIXQodyA8iAA:9 a=QEXdDO2ut3YA:10 a=TD8TdBvy0hsOASGTdmB-:22 X-Proofpoint-GUID: sqk4UNKznctDcbaoI_E10BM_23MCy-EL X-Proofpoint-ORIG-GUID: sqk4UNKznctDcbaoI_E10BM_23MCy-EL X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1143,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-03-23_04,2026-03-23_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 malwarescore=0 suspectscore=0 adultscore=0 lowpriorityscore=0 impostorscore=0 bulkscore=0 phishscore=0 spamscore=0 clxscore=1015 priorityscore=1501 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2603050001 definitions=main-2603230118 Add support for BAM pipe locking. To that end: when starting DMA on an RX channel - prepend the existing queue of issued descriptors with an additional "dummy" command descriptor with the LOCK bit set. Once the transaction is done (no more issued descriptors), issue one more dummy descriptor with the UNLOCK bit. We *must* wait until the transaction is signalled as done because we must not perform any writes into config registers while the engine is busy. The dummy writes must be issued into a scratchpad register of the client so provide a mechanism to communicate the right address via descriptor metadata. Signed-off-by: Bartosz Golaszewski --- drivers/dma/qcom/bam_dma.c | 165 +++++++++++++++++++++++++++++++++++= +++- include/linux/dma/qcom_bam_dma.h | 10 +++ 2 files changed, 171 insertions(+), 4 deletions(-) diff --git a/drivers/dma/qcom/bam_dma.c b/drivers/dma/qcom/bam_dma.c index 83491e7c2f17d8c9d12a1a055baea7e3a0a75a53..309681e798d2e44992e3d20679c= 3a7564ad8f29e 100644 --- a/drivers/dma/qcom/bam_dma.c +++ b/drivers/dma/qcom/bam_dma.c @@ -28,11 +28,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include #include @@ -60,6 +62,8 @@ struct bam_desc_hw { #define DESC_FLAG_EOB BIT(13) #define DESC_FLAG_NWD BIT(12) #define DESC_FLAG_CMD BIT(11) +#define DESC_FLAG_LOCK BIT(10) +#define DESC_FLAG_UNLOCK BIT(9) =20 struct bam_async_desc { struct virt_dma_desc vd; @@ -391,6 +395,13 @@ struct bam_chan { struct list_head desc_list; =20 struct list_head node; + + /* BAM locking infrastructure */ + phys_addr_t scratchpad_addr; + struct scatterlist lock_sg; + struct scatterlist unlock_sg; + struct bam_cmd_element lock_ce; + struct bam_cmd_element unlock_ce; }; =20 static inline struct bam_chan *to_bam_chan(struct dma_chan *common) @@ -652,6 +663,32 @@ static int bam_slave_config(struct dma_chan *chan, return 0; } =20 +static int bam_metadata_attach(struct dma_async_tx_descriptor *desc, void = *data, size_t len) +{ + struct bam_chan *bchan =3D to_bam_chan(desc->chan); + const struct bam_device_data *bdata =3D bchan->bdev->dev_data; + struct bam_desc_metadata *metadata =3D data; + + if (!data) + return -EINVAL; + + if (!bdata->pipe_lock_supported) + /* + * The client wants to use locking but this BAM version doesn't + * support it. Don't return an error here as this will stop the + * client from using DMA at all for no reason. + */ + return 0; + + bchan->scratchpad_addr =3D metadata->scratchpad_addr; + + return 0; +} + +static const struct dma_descriptor_metadata_ops bam_metadata_ops =3D { + .attach =3D bam_metadata_attach, +}; + /** * bam_prep_slave_sg - Prep slave sg transaction * @@ -668,6 +705,7 @@ static struct dma_async_tx_descriptor *bam_prep_slave_s= g(struct dma_chan *chan, void *context) { struct bam_chan *bchan =3D to_bam_chan(chan); + struct dma_async_tx_descriptor *tx_desc; struct bam_device *bdev =3D bchan->bdev; struct bam_async_desc *async_desc; struct scatterlist *sg; @@ -723,7 +761,12 @@ static struct dma_async_tx_descriptor *bam_prep_slave_= sg(struct dma_chan *chan, } while (remainder > 0); } =20 - return vchan_tx_prep(&bchan->vc, &async_desc->vd, flags); + tx_desc =3D vchan_tx_prep(&bchan->vc, &async_desc->vd, flags); + if (!tx_desc) + return NULL; + + tx_desc->metadata_ops =3D &bam_metadata_ops; + return tx_desc; } =20 /** @@ -1012,13 +1055,116 @@ static void bam_apply_new_config(struct bam_chan *= bchan, bchan->reconfigure =3D 0; } =20 +static struct bam_async_desc * +bam_make_lock_desc(struct bam_chan *bchan, struct scatterlist *sg, + struct bam_cmd_element *ce, unsigned long flag) +{ + struct dma_chan *chan =3D &bchan->vc.chan; + struct bam_async_desc *async_desc; + struct bam_desc_hw *desc; + struct virt_dma_desc *vd; + struct virt_dma_chan *vc; + unsigned int mapped; + dma_cookie_t cookie; + int ret; + + sg_init_table(sg, 1); + + async_desc =3D kzalloc_flex(*async_desc, desc, 1, GFP_NOWAIT); + if (!async_desc) { + dev_err(bchan->bdev->dev, "failed to allocate the BAM lock descriptor\n"= ); + return ERR_PTR(-ENOMEM); + } + + async_desc->num_desc =3D 1; + async_desc->curr_desc =3D async_desc->desc; + async_desc->dir =3D DMA_MEM_TO_DEV; + + desc =3D async_desc->desc; + + bam_prep_ce_le32(ce, bchan->scratchpad_addr, BAM_WRITE_COMMAND, 0); + sg_set_buf(sg, ce, sizeof(*ce)); + + mapped =3D dma_map_sg_attrs(chan->slave, sg, 1, DMA_TO_DEVICE, DMA_PREP_C= MD); + if (!mapped) { + kfree(async_desc); + return ERR_PTR(-ENOMEM); + } + + desc->flags |=3D cpu_to_le16(DESC_FLAG_CMD | flag); + desc->addr =3D sg_dma_address(sg); + desc->size =3D sizeof(struct bam_cmd_element); + + vc =3D &bchan->vc; + vd =3D &async_desc->vd; + + dma_async_tx_descriptor_init(&vd->tx, &vc->chan); + vd->tx.flags =3D DMA_PREP_CMD; + vd->tx.desc_free =3D vchan_tx_desc_free; + vd->tx_result.result =3D DMA_TRANS_NOERROR; + vd->tx_result.residue =3D 0; + + cookie =3D dma_cookie_assign(&vd->tx); + ret =3D dma_submit_error(cookie); + if (ret) { + dma_unmap_sg(chan->slave, sg, 1, DMA_TO_DEVICE); + kfree(async_desc); + return ERR_PTR(ret); + } + + return async_desc; +} + +static int bam_do_setup_pipe_lock(struct bam_chan *bchan, bool lock) +{ + struct bam_device *bdev =3D bchan->bdev; + const struct bam_device_data *bdata =3D bdev->dev_data; + struct bam_async_desc *lock_desc; + struct bam_cmd_element *ce; + struct scatterlist *sgl; + unsigned long flag; + + lockdep_assert_held(&bchan->vc.lock); + + if (!bdata->pipe_lock_supported || !bchan->scratchpad_addr || + bchan->slave.direction !=3D DMA_MEM_TO_DEV) + return 0; + + if (lock) { + sgl =3D &bchan->lock_sg; + ce =3D &bchan->lock_ce; + flag =3D DESC_FLAG_LOCK; + } else { + sgl =3D &bchan->unlock_sg; + ce =3D &bchan->unlock_ce; + flag =3D DESC_FLAG_UNLOCK; + } + + lock_desc =3D bam_make_lock_desc(bchan, sgl, ce, flag); + if (IS_ERR(lock_desc)) + return PTR_ERR(lock_desc); + + if (lock) + list_add(&lock_desc->vd.node, &bchan->vc.desc_issued); + else + list_add_tail(&lock_desc->vd.node, &bchan->vc.desc_issued); + + return 0; +} + +static void bam_setup_pipe_lock(struct bam_chan *bchan) +{ + if (bam_do_setup_pipe_lock(bchan, true) || bam_do_setup_pipe_lock(bchan, = false)) + dev_err(bchan->vc.chan.slave, "Failed to setup BAM pipe lock descriptors= "); +} + /** * bam_start_dma - start next transaction * @bchan: bam dma channel */ static void bam_start_dma(struct bam_chan *bchan) { - struct virt_dma_desc *vd =3D vchan_next_desc(&bchan->vc); + struct virt_dma_desc *vd; struct bam_device *bdev =3D bchan->bdev; struct bam_async_desc *async_desc =3D NULL; struct bam_desc_hw *desc; @@ -1030,6 +1176,9 @@ static void bam_start_dma(struct bam_chan *bchan) =20 lockdep_assert_held(&bchan->vc.lock); =20 + bam_setup_pipe_lock(bchan); + + vd =3D vchan_next_desc(&bchan->vc); if (!vd) return; =20 @@ -1157,8 +1306,15 @@ static void bam_issue_pending(struct dma_chan *chan) */ static void bam_dma_free_desc(struct virt_dma_desc *vd) { - struct bam_async_desc *async_desc =3D container_of(vd, - struct bam_async_desc, vd); + struct bam_async_desc *async_desc =3D container_of(vd, struct bam_async_d= esc, vd); + struct bam_desc_hw *desc =3D async_desc->desc; + struct dma_chan *chan =3D vd->tx.chan; + struct bam_chan *bchan =3D to_bam_chan(chan); + + if (le16_to_cpu(desc->flags) & DESC_FLAG_LOCK) + dma_unmap_sg(chan->slave, &bchan->lock_sg, 1, DMA_TO_DEVICE); + else if (le16_to_cpu(desc->flags) & DESC_FLAG_UNLOCK) + dma_unmap_sg(chan->slave, &bchan->unlock_sg, 1, DMA_TO_DEVICE); =20 kfree(async_desc); } @@ -1350,6 +1506,7 @@ static int bam_dma_probe(struct platform_device *pdev) bdev->common.device_terminate_all =3D bam_dma_terminate_all; bdev->common.device_issue_pending =3D bam_issue_pending; bdev->common.device_tx_status =3D bam_tx_status; + bdev->common.desc_metadata_modes =3D DESC_METADATA_CLIENT; bdev->common.dev =3D bdev->dev; =20 ret =3D dma_async_device_register(&bdev->common); diff --git a/include/linux/dma/qcom_bam_dma.h b/include/linux/dma/qcom_bam_= dma.h index 68fc0e643b1b97fe4520d5878daa322b81f4f559..5f0d2a27face8223ecb77da33d9= e050c1ff2622f 100644 --- a/include/linux/dma/qcom_bam_dma.h +++ b/include/linux/dma/qcom_bam_dma.h @@ -34,6 +34,16 @@ enum bam_command_type { BAM_READ_COMMAND, }; =20 +/** + * struct bam_desc_metadata - DMA descriptor metadata specific to the BAM = driver. + * + * @scratchpad_addr: Physical address to use for dummy write operations wh= en + * queuing command descriptors with LOCK/UNLOCK bits set. + */ +struct bam_desc_metadata { + phys_addr_t scratchpad_addr; +}; + /* * prep_bam_ce_le32 - Wrapper function to prepare a single BAM command * element with the data already in le32 format. --=20 2.47.3