From nobody Sun Apr 12 04:21:21 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D6A3BC19F2C for ; Tue, 2 Aug 2022 09:59:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236381AbiHBJ67 (ORCPT ); Tue, 2 Aug 2022 05:58:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42164 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236168AbiHBJ6y (ORCPT ); Tue, 2 Aug 2022 05:58:54 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 300EF4B0C4; Tue, 2 Aug 2022 02:58:53 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=OrAAmiL71WJEZ2sYcwu162xdjsCfJz+mi7d/EviKKbG6KkKoS1cEZp57kwt5M2caT/5fpTNOpTgb/bGZfk1MP9rb8rwBHC8SPthFRrFj7TURgGMrd9QoBcQ7u8Q5JsFC3vO6bdtsyXSx/S0LUY/vvSGuNiDjLNMXH7dWTy34egH02ufX1MJs7m17IdVfV2lAkg077YbuVekb5YocaRpjjt3GrAS7L/4GwAzlPJBaeplyzwHouAFWbDsXMdlyqmPhg/B6N0e8iqmm9WYRa0biiTCbIcrItwyCIu5z+XgqmqhyQlqR1jEYLln5RWwGFow+u4wQ1T2TCMgYxV4rTf1Ywg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=wXOdF3cE6IyAZrsT4wTECkt/yCciaBYokLHgvJeWwJ4=; b=ICi+ZmSbWO9+hfxeVNHXBoztbMHjnE80WQtf34gxy9x71ekVVLh30XZsqSTbzhl7usF+X49k5IFDa77pJ+lT4/JrtHcYvNkAXWsC2ncaUm1tOfAoXML21GdMMtHslNCzMQlysRMJ71JnWcuaHHU46SbuyIRIj8FMszSH1tfsAfZzrHZBX6pabLij5VzR9TALy+oUiAhAE5YrmQy6QdCjnbk89dKwM/aGgIpEqgdHst9Sg6fVCJzMBH6Twe48KwinSc7hgxxIqnRpy+qWwsy6iKn38F920sEucxDUufw3SDivAi2sQSLkAkZj1P/v1l4W/b6oFmBEgqqqHujBt5HfPA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=wXOdF3cE6IyAZrsT4wTECkt/yCciaBYokLHgvJeWwJ4=; b=RMEpMqfhlhwZTCCuJdBytFnkHQwT2TjkzRvZq6PvpJ9fHE7fMk1Z+YJ+wPLin72I8paK2y/07aO7+3PCARnLBFSovApPgxqoq943CA89gn2ThQAHvy5HxRRtv34iP6cq99TYsNJ9qK8vOCHsvn7adqElJK1h2xSnE2rbwmuruoA= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:51 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:51 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 1/5] ANDROID: dma-buf: heaps: Add deferred-free-helper library code Date: Tue, 2 Aug 2022 11:58:39 +0200 Message-Id: <20220802095843.14614-2-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: a0696432-f15e-42e3-edcf-08da746d9994 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 4j7UWFRmKfOkhZ9E1PD5Am1xX/1ykjbLzUYkFeGXDQPUQJZWkWm+30KxykNIVXKC2UCJGS9UXrL1PEkNpSwAjkjQSV3rqfohOudMgEoH9ewkbxdtDLdMoNDBuBAtnDazjUkdl3rrXVSeWwIPhOGVPKdoHoJt2etVAMQ7nBZZuarljoF/DZe2oeE+IO4neWq+V2vMCtEKikksoqSakAunl7qkTQd9uQaZgv8K5qoDoHOP1x7iAbukQMIikTgYfGT+QDq1S53EHZ74K9VHoOyc0rz4ibudKKG+YvArmyUu3+rn1qoIU0BR4PmrhNT04tkkIrbgUAgIL8u9Py/gznfjgqIMyzOWdLyCA2hSJWaKfS5y/jo6yiZEQOvCdxQ3NKsuboawC2YBrBo731d880r2TNnwxiV80fJXO6RrJZld6rYJ/9gWRfCmG+vxsECHK7Ku93Ik1ipTTOv2TQnuDC2kJoeBCwK5ad0g7/t9A/Z8VjFiJZXkAC8HuM5GmJuI0CPDH/m6MkgiWKMaWZcvoVe8AwtrL/gOkmg8urq9evZGoe51bnDV0p6Ga50zlXSEZy/79urTHD639M8S9pg2IznlyrlWrkmjqdMkzKRfGyThmgVb6gDN10rGsoYWPHQAze8jgs4BfoW/78MuJYLcMRCoLL6UgQRQIV/VfPbh+BxMSs0eJRZ1gO9/+5dlFezBc3Shf7djOd/jY4XYOxc8o8tjiwEMEGoR+H3T0vNs6YpwsDHAHtTON7dKcEWdSxLXW265/zI+hPdjQhJ2ld+jzYOP9T3bG1lIKQJLk4koeUditEo= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR04MB6737.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?K2h5RFFmSS9QbkZubFAvczV0WWtjNTBIRDViQ2YxaFI4TE9Rb1poT0lDUW0r?= =?utf-8?B?UnBGWkJmOEQweWxrV2VrRi9ibnY4OFdQT25KWWNKYVlwbzVaWDJ1NTRvdnNt?= =?utf-8?B?a25hMG5DcWkyZFBHY0RjUWQ3aUw3N0dsV3ROWWMxeGNKMVlOZytSSUlLUFBu?= =?utf-8?B?MVRObXlHUm00OVk2djMzVkdEc3hUemVnaUE3K1E1elB4SlpiSHMwalcrZkVD?= =?utf-8?B?V2REOTlnLytZR091ZVBqTlF0aGhJYjlQbkN3OHpwODB0b0JIOTQ3amdIRGE5?= =?utf-8?B?WXNSZmh5dlJITlNONnQyM3lEOFdDQlNyK0dLaDUyRjFaWFNtNVhSUDdiZGdo?= =?utf-8?B?dFplRTJ0KzMrdHdKZFJ5aVIyaUlWOEFTWWp3MkhYb3JxL2U2L0ZlSW84aVAx?= =?utf-8?B?bGRPYmdjS0ZaTVMvRmZqSUJqK3p5UVJGSzZXZzdkUU1zbitsS2tJSnFMYm5y?= =?utf-8?B?ZGhnM0NHWFdsd3FwR2JxTVI1Si9VR0l0UTZsWTg1K2NWalhieXVmNGFlMWVQ?= =?utf-8?B?MFR5QnNrcFF2WHBUZUdzRTJBd0RxcjNHejVHWU5yRlhjQjdReFV6YnRadzBq?= =?utf-8?B?cVVGYjd4ZjBGZmVqOHA1TmZWKzhoU2Y0ejI0azRhdG1ualpOREQzYjMzV3Iw?= =?utf-8?B?Vi8vTjFXN1V0R1YyYThNNW8xWFJOMDJzK3E1WmU1cXlaY21YanVVSVpVdUZl?= =?utf-8?B?YlRNd0NKbTNsMmdjRGpBeXFGME90RlcyRTNRcFNzai8yQTVPNnl4VDUyL3VZ?= =?utf-8?B?Vm1BYnVzZElEOEZlVi9pamFDSERVQzZNVHd3WHFVcDdTa05keXhpcnFuaW1E?= =?utf-8?B?ZVk5QWRrUGp4WUhmSHI0cTVBbC9xcFJYaTVtRk9oTEw5Y0IyUGZ4eXFJN1NE?= =?utf-8?B?MkI3UHkyWmMvT3hrMUlVYUljVnBGcVYrYkpIV1J4VVp0MnlqT0REMWMzSCtN?= =?utf-8?B?Z1kwdGVHdTNPdGgwVGhBMlZwSjc2RE1nekJHTVVrSHp3YTU2ZFZBQmZST2sy?= =?utf-8?B?M0V3OHhrdytrTjd3YTFsRDVSWURrMFUyRHZxUDdJajR6OHZDTFpQcmt3TGNi?= =?utf-8?B?U2VsQklYQjJ4a2Z4Y0RBeEZyQVJrYTdRVmdQYld6QUVhbm9sc3dmVVo5Q2Nv?= =?utf-8?B?YWNoZHRkYklrbVdldnhBWXAzSWxPclVNaTNaeFN1R3NDbU4rUk5iOXNzb3NS?= =?utf-8?B?dDJsWnNEWi9aS0ZsZjAyT2lOZHlrY1VaVFJPblZReCtvUlJTQWx1ZVlESkhh?= =?utf-8?B?S0dTTlFwU05JZTlIelhGREQzVStUSWNHNTRma2R0WThMV1A5MXFxMHBGb0V1?= =?utf-8?B?OUtvanZ6TDVud01KTFNEcUVhYUFMY04vcmZxMWhrQUM2ZGM1bklKZTJ6YW5U?= =?utf-8?B?ZnNMK1hhekdOYU81ZEZ4SlVyMVdzYlJnaFVMZDZvYzRaL2NCcFl1YmxEQVJq?= =?utf-8?B?OGVBdDQ4ME44bjBGZ2g4SFVSbDJDN3Bwc1orVEc0UU8rN3FKMnVDNythcU11?= =?utf-8?B?d21KRGUyTUNJMWQ2TDdpbTlhdXQ3UW5CSXYwaEQ5MVpwSGxrcHp5amkwWGt2?= =?utf-8?B?YUxnRHRUNXd0WjA4MFA3RUs5K2tQcHJkUEpaNm94amd2ckhacWdTUWFYd2hH?= =?utf-8?B?TUlNc1BFOTFWcEMxUDNia2NKK1VrZnlCaGVzOUY2aTU0MWZYMFlLNVg2Mmlw?= =?utf-8?B?ZVgwSUlhemNXRi9iV0pxNVlGNE9LejRZNEsrNGI0T1pxT2d5RzlJTFJzbkFl?= =?utf-8?B?blFLK3B6eURhR3NxNTFaYTh2U2lqaWdFK3VwV0RFaVZFYmtUWGxkc004REN3?= =?utf-8?B?T2oxWEJFV1dlcW1CMDlqd0kyWjlZK09LMENxeUtjQXNVRGQ0dUg2UGF4TzZt?= =?utf-8?B?RUhQc01EbWVSMzIzTkNoSk9sblZZWkpXanRkTDJjb3FhVjhOWGsybHhpZDZZ?= =?utf-8?B?dlpzN3FTc1BkclRQL2J3OW5kc0I2SGdXdytoaG9pU2ZubjJnenA2KytiWnlw?= =?utf-8?B?K082aWlIRWl5RE9aY0RMU3lGdjFEcmpZaFRzZjN4cFAyRUxFakFzQ2xNbWRp?= =?utf-8?B?ajlvN3pRZWgrcGVROUt3Z3VOUDNwNEw1cnNiS05WclR3U1RIMzIyYXRWWi9p?= =?utf-8?Q?i+uhXwqf8DPyRk5szjkSEsnvH?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: a0696432-f15e-42e3-edcf-08da746d9994 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:51.2496 (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: kwtc640SNxd0zYeuD/PzoeUH9BLGiec7c8muO2Mcr5RCmYh/PLkhOu7uaB2fb5QGo3f3ov9WL/C4wIg1rvm6NQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: John Stultz This patch provides infrastructure for deferring buffer frees. This is a feature ION provided which when used with some form of a page pool, provides a nice performance boost in an allocation microbenchmark. The reason it helps is it allows the page-zeroing to be done out of the normal allocation/free path, and pushed off to a kthread. As not all heaps will find this useful, its implemented as a optional helper library that heaps can utilize. Cc: Daniel Vetter Cc: Sumit Semwal Cc: Liam Mark Cc: Chris Goldsworthy Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz Cc: =C3=98rjan Eide Cc: Robin Murphy Cc: Ezequiel Garcia Cc: Simon Ser Cc: James Jones Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz Bug: 168742043 --- drivers/dma-buf/heaps/Kconfig | 3 + drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/deferred-free-helper.c | 136 +++++++++++++++++++ drivers/dma-buf/heaps/deferred-free-helper.h | 63 +++++++++ 4 files changed, 203 insertions(+) create mode 100644 drivers/dma-buf/heaps/deferred-free-helper.c create mode 100644 drivers/dma-buf/heaps/deferred-free-helper.h diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 3782eeeb91c0..8ee64277a5d2 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,3 +1,6 @@ +config DMABUF_HEAPS_DEFERRED_FREE + tristate + config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" depends on DMABUF_HEAPS diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index 29733f84c354..5de95b77e169 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_DMABUF_HEAPS_DEFERRED_FREE) +=3D deferred-free-helper.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) +=3D system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) +=3D cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) +=3D dsp_heap.o diff --git a/drivers/dma-buf/heaps/deferred-free-helper.c b/drivers/dma-buf= /heaps/deferred-free-helper.c new file mode 100644 index 000000000000..478faa319908 --- /dev/null +++ b/drivers/dma-buf/heaps/deferred-free-helper.c @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Deferred dmabuf freeing helper + * + * Copyright (C) 2020 Linaro, Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#include +#include +#include +#include +#include + +#include "deferred-free-helper.h" + +static LIST_HEAD(free_list); +static size_t list_nr_pages; +static wait_queue_head_t freelist_waitqueue; +static struct task_struct *freelist_task; +static DEFINE_SPINLOCK(free_list_lock); + +void deferred_free(struct deferred_freelist_item *item, + void (*free)(struct deferred_freelist_item*, + enum df_reason), + size_t nr_pages) +{ + unsigned long flags; + + if (!nr_pages) + return; + + INIT_LIST_HEAD(&item->list); + item->nr_pages =3D nr_pages; + item->free =3D free; + + spin_lock_irqsave(&free_list_lock, flags); + list_add(&item->list, &free_list); + list_nr_pages +=3D nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + wake_up(&freelist_waitqueue); +} +EXPORT_SYMBOL_GPL(deferred_free); + +static size_t free_one_item(enum df_reason reason) +{ + unsigned long flags; + size_t nr_pages; + struct deferred_freelist_item *item; + + spin_lock_irqsave(&free_list_lock, flags); + if (list_empty(&free_list)) { + spin_unlock_irqrestore(&free_list_lock, flags); + return 0; + } + item =3D list_first_entry(&free_list, struct deferred_freelist_item, list= ); + list_del(&item->list); + nr_pages =3D item->nr_pages; + list_nr_pages -=3D nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + + item->free(item, reason); + return nr_pages; +} + +static unsigned long get_freelist_nr_pages(void) +{ + unsigned long nr_pages; + unsigned long flags; + + spin_lock_irqsave(&free_list_lock, flags); + nr_pages =3D list_nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + return nr_pages; +} + +static unsigned long freelist_shrink_count(struct shrinker *shrinker, + struct shrink_control *sc) +{ + return get_freelist_nr_pages(); +} + +static unsigned long freelist_shrink_scan(struct shrinker *shrinker, + struct shrink_control *sc) +{ + unsigned long total_freed =3D 0; + + while (total_freed < sc->nr_to_scan) { + size_t pages_freed =3D free_one_item(DF_UNDER_PRESSURE); + + if (!pages_freed) + break; + + total_freed +=3D pages_freed; + } + + return total_freed; +} + +static struct shrinker freelist_shrinker =3D { + .count_objects =3D freelist_shrink_count, + .scan_objects =3D freelist_shrink_scan, + .seeks =3D DEFAULT_SEEKS, + .batch =3D 0, +}; + +static int deferred_free_thread(void *data) +{ + while (true) { + wait_event_freezable(freelist_waitqueue, + get_freelist_nr_pages() > 0); + + free_one_item(DF_NORMAL); + } + + return 0; +} + +static int deferred_freelist_init(void) +{ + init_waitqueue_head(&freelist_waitqueue); + freelist_task =3D kthread_run(deferred_free_thread, NULL, + "%s", "dmabuf-deferred-free-worker"); + if (IS_ERR(freelist_task)) { + pr_err("Creating thread for deferred free failed\n"); + return PTR_ERR(freelist_task); + } + sched_set_normal(freelist_task, 19); + + return register_shrinker(&freelist_shrinker); +} +module_init(deferred_freelist_init); +MODULE_LICENSE("GPL v2"); + diff --git a/drivers/dma-buf/heaps/deferred-free-helper.h b/drivers/dma-buf= /heaps/deferred-free-helper.h new file mode 100644 index 000000000000..4ed5893fdf3a --- /dev/null +++ b/drivers/dma-buf/heaps/deferred-free-helper.h @@ -0,0 +1,63 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Deferred dmabuf freeing helper + * + * Copyright (C) 2020 Linaro, Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#ifndef DEFERRED_FREE_HELPER_H +#define DEFERRED_FREE_HELPER_H + +/** + * df_reason - enum for reason why item was freed + * + * This provides a reason for why the free function was called + * on the item. This is useful when deferred_free is used in + * combination with a pagepool, so under pressure the page can + * be immediately freed. + * + * DF_NORMAL: Normal deferred free + * + * DF_UNDER_PRESSURE: Free was called because the system + * is under memory pressure. Usually + * from a shrinker. Avoid allocating + * memory in the free call, as it may + * fail. + */ +enum df_reason { + DF_NORMAL, + DF_UNDER_PRESSURE, +}; + +/** + * deferred_freelist_item - item structure for deferred freelist + * + * This is to be added to the structure for whatever you want to + * defer freeing on. + * + * @nr_pages: number of pages used by item to be freed + * @free: function pointer to be called when freeing the item + * @list: list entry for the deferred list + */ +struct deferred_freelist_item { + size_t nr_pages; + void (*free)(struct deferred_freelist_item *i, + enum df_reason reason); + struct list_head list; +}; + +/** + * deferred_free - add item to the deferred free list + * + * @item: Pointer to deferred_freelist_item field of a structure + * @free: Function pointer to the free call + * @nr_pages: number of pages to be freed + */ +void deferred_free(struct deferred_freelist_item *item, + void (*free)(struct deferred_freelist_item *i, + enum df_reason reason), + size_t nr_pages); +#endif --=20 2.25.0 From nobody Sun Apr 12 04:21:21 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EE8ABC00140 for ; Tue, 2 Aug 2022 09:59:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236383AbiHBJ7D (ORCPT ); Tue, 2 Aug 2022 05:59:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42182 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236353AbiHBJ64 (ORCPT ); Tue, 2 Aug 2022 05:58:56 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5A83F48C9B; Tue, 2 Aug 2022 02:58:54 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=lhYAwWmzEbXWMWfplvvTPs2jdv7G5K/U4X06eCW2LDiUDLYFCrTWZNdvmwAbAKnFyV5r+T6SIqU1z+jZIXMnhiWPLKIUun4caev1LGsSmmYrybXBxybv95TxkHO74BZeensHNJyuH2TViLOP+Ra1LlMbVNQA9i4WJrJrrlFbXQuakvv7xkdwep04hl8RUjyGBK7khA17mdkiHS1wkj1nUR+NTMmhLJhD4E+8Dn5bEdsQnz9t8snIzVulVNvt2mHZilnpAn/Np6njvnLS0A5XaA+76Xq3gbhNfJXoQvtkZuF0p6Lid2ESWWJTLx+4WIsEC3+iHS18kZZvDnBvtMniKA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=B6F4CMRdmn0GSb1NELVUv8fyXfsdW1uJtKJqqy0RZHs=; b=c04TM49Wfkm+Bng/rkCbN1wkDmskI1ZKdrsB8axBnq/NWm4ujX4jwrne9WSYqtJpJDuh05NDR6I79Cve8QnmigtG5rPjtkO9oxF+cvmE9jgILx7CpxpRVdpCyeYn5yD9uugBrPNVT3IxHCy2u7wXuJn0o5u5sg0Vo7axo/1awLun3/DG3Lfaonf7A0wA27AEIEn6zd1OsEe9pBWQlG0qs8LhnkP27aoShq+5c4b3aew0XN3a/nF5eUqseiAMP8gVq5lXqpEIf3jdFEdLNJrGMrinNyRbOdJ2e3R1tCnYtujEyusEKEpcU67h0ZDeuWt1ahId5v4HGI3jBI5akRfT0g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=B6F4CMRdmn0GSb1NELVUv8fyXfsdW1uJtKJqqy0RZHs=; b=hHeWLaNkxVsyN7YIJ58EQ18YBZNAoOfutrJWRBbRDlwwq6dvopuX9ARso3HH86ArB9vC1zZpQRPXnwvZYQ5GOHRRnFC+MVnMdTy6izvE4lS6aEk8/5GOQXiZpIYOX1w7AuWleeuTccqAZlgr/a5KXjshZdKoDnNCUfEO/DwqZrk= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:52 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:52 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 2/5] ANDROID: dma-buf: heaps: Add a shrinker controlled page pool Date: Tue, 2 Aug 2022 11:58:40 +0200 Message-Id: <20220802095843.14614-3-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: d1aa91d2-bdc0-4ee8-19a8-08da746d9a88 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: OrZ+Mf2Im1BWeUgPbN/aeFSeGEekynp4KPB7T98fHlEIdvs8OvGsFdFjRALozCFA/gkdbPPx8avo2CD8IiVLwq+FeSb8bhmN6/XlBai9zjnk3AxtOwM3OLZlimRwL8CqtaFhuNRNKwlIDrMs5/4KhN5msNAX3uN5jV0zNOy6QCN1PzcY8iXmqTAeysEiahk7f5aUCnErBUBN5RLp/d0ErRHmNVel8fVNnN0Fvbiwvy+mSpV/px610mP07GPKuBuuD5mt9DmAW3e5bLCvWBVXhjYMvBhf+eLO4bjMq7RBV0T7wyvKk/p5jBheFx6tyC0FcFtx8GDT8MMnGpzvS1D5mzy50PZWhJmMpbkior99F0gtjL18MSveLPzWY2hKg6IVpXNCpmJb5xy6OogG1nHO4S0jD137ouRxhNPXsgdJEQQr6mJFOfEMOyNVhYh3E4YBWxajhnaDygzA/+sSWe91gaiB6b8Jp3hUrYaNTrlJ367MK7c3+OizXmgzbkSZjJAYX68XVnh8pG2cLmfaqW9W1zzXaI1lvhOYfZJ1PFxo99yupkGA7FV0SYfHOggsBOl/ep6QVvRzdsl7KftFJjK7HSsO6WoofMu5qv/GyPD9jv16t2B8eqrv4bnPg7tQ8wHkV35oDV3IoVqrkDBYHFFRkQYjCb0dczyEwr0rXbYgNOkiFdiSzIGHAC0L9t/RS0agtyy0VDFvRPCizmcZDeJng2mEoG22k4Mqv+2WKUuoKuf15iZnnxaKifyFewTFJNeJGUgUipQyIoS3Fbd0xOXrhKV9n4OiQUltOV11TZx6Crk= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR04MB6737.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(30864003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?OUdyV2V6Z3RqcEYvbmVLUWFldTJzT0ZoekFDUUNwTnB5WHc1QVQ3NWh3RmFk?= =?utf-8?B?NjI2T3l2RjUvYmpQcDVYNndnSTlkYTNTVzRwcGxLcTJvTzNFQzJ1WnFvSkp2?= =?utf-8?B?bzYrZURyLzRFckRVV1AxY3lyaE42ZmFuMisyVnE4QWFEZWZqNitva3VsNm5r?= =?utf-8?B?R0ZpUkcxeFcrbU80eGY0WEFLZytGY1o3djhLWk4yaWoxdDR5TzVKcmc1UUlW?= =?utf-8?B?dEg0ZXhPU3BvMDdNbit2dzY1R3E0ZVo2aERZY3phVHgxNlVYaFRqN1lhcE1E?= =?utf-8?B?MEs0dldFaTRoVWdNNTRWQWtkUER4YUJaenNxV3FONEZmTTZLV0tzNldIN1Iz?= =?utf-8?B?cHZ3Y3djcGgzRWtCVWhmek9pRWNYdmowYVRNQzlYT0xSTlpTRUZmSHUzcng5?= =?utf-8?B?Q3ZreEZTRUxyVjdqaVlpc0s0N004RW9Ka2dxUTlqeHNkb1oyYm5ndEdWTHI3?= =?utf-8?B?dnBvNDVDL0sxR1BQemNNN21Ta3ljaytsaFZnS0NRNnlwMHp6WkVzRjRTUEFB?= =?utf-8?B?Snh3WTc0Y3BydXdQOG4vVTdqU3p4Nk5ZVDVIUm9lTmdrdy9IaWtOR0ZETXFR?= =?utf-8?B?UjdpTVVSdTI0SUQ0ejlSRk1nODdJd2V1ci9EQ0cxeHJFbytWcy9CUW9LL3BL?= =?utf-8?B?YlB1UHQ3OTAycnVJTktOM2dEV016NkxBd09keUgxRjl3Qm1zYmVBWGFkUTFG?= =?utf-8?B?UGc3WmZydmdEYitzV0czbStkWmcvK3l3Wk9jczBQQ2pBWlR0OFppZ3Fzdnpl?= =?utf-8?B?MC9nd0FKZkNsSnRsYUprMk5aYTdicGhYdjFRbzhXYVpITnMydHJwTXByYzN5?= =?utf-8?B?T0c1S3dkRUdtVmpaN0pPci9KMWVJWStLVmljSG5MNHdSQWpWcnNGNkwzMG45?= =?utf-8?B?L0poa0JIVjB6OEJjSFBGb1NMZWlUem5JTmxuSmlRbmhxWEduQXFMU29lRDhk?= =?utf-8?B?Ym11S0pYRmIzLzZIUDhETXMwejhqOWpLVFBSb0ZqdzV2Z0Y5YStsdTl4N0s0?= =?utf-8?B?SlFwdXVmdTJIQWlZNyt4cWwzNXRyOFpTV2tPR2cwencvd0o1Q3c3TUJLa3Zi?= =?utf-8?B?NGRwYUV1dWFkVUZVOGJjWDBmVGRIMGhLdXRBSVFVTGg0MDllbHRPNndXWUZs?= =?utf-8?B?Z3cwOFYrOU9xTXY3TFljaTZJYXo1RGNGTGJpYnBxdUZ4cnhKY2pQK0VMSTZ4?= =?utf-8?B?OUNWNThoSkl4czBGWTVNZ2xmZUxIelZpbndOU0QvVWlwanFZcDFFaE92L2VW?= =?utf-8?B?Snc3UlRMY0NVR0tuRkZtdUhDd0RnOXF6eWIrN0ZWV1BUU0RYbTQ2OWw2SDZ6?= =?utf-8?B?bHJkeFV3VGpneDh5RWpSZkNFRER3SVFRdGREOVVUbnRuNWwrU3VVL0piOU5z?= =?utf-8?B?RDYzNW9NcW8wVXpEeTdKWFJ5YmZCbG9UWnQ4MVc0MDhLWGE5NERnY3p5RWxo?= =?utf-8?B?K3djczNoZGs2SVhWMjJHVjFNTUxRSURtNkdwVkZmSnZ1NWFDQU81dTgyVVlm?= =?utf-8?B?M3phZ1VNejJRMTFxZGlxdlRMbmhiWENma1FvTE05ZERrckVaUVd5Q3N6bkFH?= =?utf-8?B?MnE1RzBpSTNscG5zVU10ODVFRDN3b2NZdFNaejdrYmcxSUt5MTQxUWxGWHA5?= =?utf-8?B?eURPcUN0Y21vOGZ2a2N5U3pnK3BRY0cxWHlpYUFaMVZBaGxNVFVaczYraVkz?= =?utf-8?B?NnYwQkZoOGluenMwVDNvUzdiVWJrZEExSkZXSGJOYWpRSmRIa0pFMDAzRytX?= =?utf-8?B?WDNhc3l0THRTQUxUdDc5RWkvS1k2TmVBOTRVWHJjYWJkaDFndzVzS1VSaEVD?= =?utf-8?B?WFowL0ZuWGhVQzhTdzN2VkhmaXFxTW94akN1TzBIQ1RpTzVrUmJCMmRsRVUx?= =?utf-8?B?OUdIazFONjhDeTRpY2NDQWNyeUVaRkJsMUhBOVZrWnNnNXBZazVzbnYzQzl3?= =?utf-8?B?MmJuUDVPWElHK1NFUERvUC9nd0QvL2Y2UlVBVFl5bXExZnJyVHRkTkdldThH?= =?utf-8?B?dGZNMzZYN3NjZXVINjJCb2lIVTljbUh3aStTemxiYVYyWGhReUh5MDNWMHVQ?= =?utf-8?B?MXhwV2owbzdyaWdFeVVmME90V2pOZ1llSUo5OWRlQ3d3R3FuMVFwK3JkVGZi?= =?utf-8?Q?qzUe9BkSK6iQ32qnk95Y7Wilb?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: d1aa91d2-bdc0-4ee8-19a8-08da746d9a88 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:52.0620 (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: JJVQHhZVNHPI+vhQST2F/FbSJjoy0Oqz6BAmLzShGIaCRPcNiniHit7RCDbtHPsZK50coI1r7PjNQ7KlBC0mfw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: John Stultz This patch adds a simple shrinker controlled page pool to the dmabuf heaps subsystem. This replaces the use of the networking page_pool, over concerns that the lack of a shrinker for that implementation may cause additional low-memory kills TODO: Take another pass at trying to unify this w/ the ttm pool Thoughts and feedback would be greatly appreciated! Cc: Sumit Semwal Cc: Liam Mark Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz Cc: Chris Goldsworthy Cc: =C3=98rjan Eide Cc: Robin Murphy Cc: Ezequiel Garcia Cc: Simon Ser Cc: James Jones Cc: Andrew Morton Cc: Dave Hansen Cc: linux-mm@kvack.org Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz Signed-off-by: Olivier Masse Bug: 168742043 --- drivers/dma-buf/heaps/Kconfig | 3 + drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/page_pool.c | 246 ++++++++++++++++++++++++++++++ drivers/dma-buf/heaps/page_pool.h | 55 +++++++ 4 files changed, 305 insertions(+) create mode 100644 drivers/dma-buf/heaps/page_pool.c create mode 100644 drivers/dma-buf/heaps/page_pool.h diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 8ee64277a5d2..6a33193a7b3e 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,6 +1,9 @@ config DMABUF_HEAPS_DEFERRED_FREE tristate =20 +config DMABUF_HEAPS_PAGE_POOL + tristate + config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" depends on DMABUF_HEAPS diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index 5de95b77e169..e70722ea615e 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DMABUF_HEAPS_DEFERRED_FREE) +=3D deferred-free-helper.o +obj-$(CONFIG_DMABUF_HEAPS_PAGE_POOL) +=3D page_pool.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) +=3D system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) +=3D cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) +=3D dsp_heap.o diff --git a/drivers/dma-buf/heaps/page_pool.c b/drivers/dma-buf/heaps/page= _pool.c new file mode 100644 index 000000000000..3dd4c3862dca --- /dev/null +++ b/drivers/dma-buf/heaps/page_pool.c @@ -0,0 +1,246 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMA BUF page pool system + * + * Copyright (C) 2020 Linaro Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#include +#include +#include +#include +#include +#include "page_pool.h" + +static LIST_HEAD(pool_list); +static DEFINE_MUTEX(pool_list_lock); + +static struct page *dmabuf_page_pool_alloc_pages(struct dmabuf_page_pool *= pool) +{ + if (fatal_signal_pending(current)) + return NULL; + return alloc_pages(pool->gfp_mask, pool->order); +} + +static void dmabuf_page_pool_free_pages(struct dmabuf_page_pool *pool, + struct page *page) +{ + __free_pages(page, pool->order); +} + +static void dmabuf_page_pool_add(struct dmabuf_page_pool *pool, struct pag= e *page) +{ + int index; + + if (PageHighMem(page)) + index =3D POOL_HIGHPAGE; + else + index =3D POOL_LOWPAGE; + + mutex_lock(&pool->mutex); + list_add_tail(&page->lru, &pool->items[index]); + pool->count[index]++; + mod_node_page_state(page_pgdat(page), NR_KERNEL_MISC_RECLAIMABLE, + 1 << pool->order); + mutex_unlock(&pool->mutex); +} + +static struct page *dmabuf_page_pool_remove(struct dmabuf_page_pool *pool,= int index) +{ + struct page *page; + + mutex_lock(&pool->mutex); + page =3D list_first_entry_or_null(&pool->items[index], struct page, lru); + if (page) { + pool->count[index]--; + list_del(&page->lru); + mod_node_page_state(page_pgdat(page), NR_KERNEL_MISC_RECLAIMABLE, + -(1 << pool->order)); + } + mutex_unlock(&pool->mutex); + + return page; +} + +static struct page *dmabuf_page_pool_fetch(struct dmabuf_page_pool *pool) +{ + struct page *page =3D NULL; + + page =3D dmabuf_page_pool_remove(pool, POOL_HIGHPAGE); + if (!page) + page =3D dmabuf_page_pool_remove(pool, POOL_LOWPAGE); + + return page; +} + +struct page *dmabuf_page_pool_alloc(struct dmabuf_page_pool *pool) +{ + struct page *page =3D NULL; + + if (WARN_ON(!pool)) + return NULL; + + page =3D dmabuf_page_pool_fetch(pool); + if (!page) + page =3D dmabuf_page_pool_alloc_pages(pool); + + return page; +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_alloc); + +void dmabuf_page_pool_free(struct dmabuf_page_pool *pool, struct page *pag= e) +{ + if (WARN_ON(pool->order !=3D compound_order(page))) + return; + + dmabuf_page_pool_add(pool, page); +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_free); + +static int dmabuf_page_pool_total(struct dmabuf_page_pool *pool, bool high) +{ + int count =3D pool->count[POOL_LOWPAGE]; + + if (high) + count +=3D pool->count[POOL_HIGHPAGE]; + + return count << pool->order; +} + +struct dmabuf_page_pool *dmabuf_page_pool_create(gfp_t gfp_mask, unsigned = int order) +{ + struct dmabuf_page_pool *pool =3D kmalloc(sizeof(*pool), GFP_KERNEL); + int i; + + if (!pool) + return NULL; + + for (i =3D 0; i < POOL_TYPE_SIZE; i++) { + pool->count[i] =3D 0; + INIT_LIST_HEAD(&pool->items[i]); + } + pool->gfp_mask =3D gfp_mask | __GFP_COMP; + pool->order =3D order; + mutex_init(&pool->mutex); + + mutex_lock(&pool_list_lock); + list_add(&pool->list, &pool_list); + mutex_unlock(&pool_list_lock); + + return pool; +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_create); + +void dmabuf_page_pool_destroy(struct dmabuf_page_pool *pool) +{ + struct page *page; + int i; + + /* Remove us from the pool list */ + mutex_lock(&pool_list_lock); + list_del(&pool->list); + mutex_unlock(&pool_list_lock); + + /* Free any remaining pages in the pool */ + for (i =3D 0; i < POOL_TYPE_SIZE; i++) { + while ((page =3D dmabuf_page_pool_remove(pool, i))) + dmabuf_page_pool_free_pages(pool, page); + } + + kfree(pool); +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_destroy); + +static int dmabuf_page_pool_do_shrink(struct dmabuf_page_pool *pool, gfp_t= gfp_mask, + int nr_to_scan) +{ + int freed =3D 0; + bool high; + + if (current_is_kswapd()) + high =3D true; + else + high =3D !!(gfp_mask & __GFP_HIGHMEM); + + if (nr_to_scan =3D=3D 0) + return dmabuf_page_pool_total(pool, high); + + while (freed < nr_to_scan) { + struct page *page; + + /* Try to free low pages first */ + page =3D dmabuf_page_pool_remove(pool, POOL_LOWPAGE); + if (!page) + page =3D dmabuf_page_pool_remove(pool, POOL_HIGHPAGE); + + if (!page) + break; + + dmabuf_page_pool_free_pages(pool, page); + freed +=3D (1 << pool->order); + } + + return freed; +} + +static int dmabuf_page_pool_shrink(gfp_t gfp_mask, int nr_to_scan) +{ + struct dmabuf_page_pool *pool; + int nr_total =3D 0; + int nr_freed; + bool only_scan =3D false; + + if (!nr_to_scan) + only_scan =3D true; + + mutex_lock(&pool_list_lock); + list_for_each_entry(pool, &pool_list, list) { + if (only_scan) { + nr_total +=3D dmabuf_page_pool_do_shrink(pool, + gfp_mask, + nr_to_scan); + } else { + nr_freed =3D dmabuf_page_pool_do_shrink(pool, + gfp_mask, + nr_to_scan); + nr_to_scan -=3D nr_freed; + nr_total +=3D nr_freed; + if (nr_to_scan <=3D 0) + break; + } + } + mutex_unlock(&pool_list_lock); + + return nr_total; +} + +static unsigned long dmabuf_page_pool_shrink_count(struct shrinker *shrink= er, + struct shrink_control *sc) +{ + return dmabuf_page_pool_shrink(sc->gfp_mask, 0); +} + +static unsigned long dmabuf_page_pool_shrink_scan(struct shrinker *shrinke= r, + struct shrink_control *sc) +{ + if (sc->nr_to_scan =3D=3D 0) + return 0; + return dmabuf_page_pool_shrink(sc->gfp_mask, sc->nr_to_scan); +} + +struct shrinker pool_shrinker =3D { + .count_objects =3D dmabuf_page_pool_shrink_count, + .scan_objects =3D dmabuf_page_pool_shrink_scan, + .seeks =3D DEFAULT_SEEKS, + .batch =3D 0, +}; + +static int dmabuf_page_pool_init_shrinker(void) +{ + return register_shrinker(&pool_shrinker); +} +module_init(dmabuf_page_pool_init_shrinker); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/dma-buf/heaps/page_pool.h b/drivers/dma-buf/heaps/page= _pool.h new file mode 100644 index 000000000000..e3ec9eaacbc2 --- /dev/null +++ b/drivers/dma-buf/heaps/page_pool.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMA BUF PagePool implementation + * Based on earlier ION code by Google + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2020 Linaro Ltd. + */ + +#ifndef _DMABUF_PAGE_POOL_H +#define _DMABUF_PAGE_POOL_H + +#include +#include +#include +#include +#include +#include + +/* page types we track in the pool */ +enum { + POOL_LOWPAGE, /* Clean lowmem pages */ + POOL_HIGHPAGE, /* Clean highmem pages */ + + POOL_TYPE_SIZE +}; + +/** + * struct dmabuf_page_pool - pagepool struct + * @count[]: array of number of pages of that type in the pool + * @items[]: array of list of pages of the specific type + * @mutex: lock protecting this struct and especially the count + * item list + * @gfp_mask: gfp_mask to use from alloc + * @order: order of pages in the pool + * @list: list node for list of pools + * + * Allows you to keep a pool of pre allocated pages to use + */ +struct dmabuf_page_pool { + int count[POOL_TYPE_SIZE]; + struct list_head items[POOL_TYPE_SIZE]; + struct mutex mutex; + gfp_t gfp_mask; + unsigned int order; + struct list_head list; +}; + +struct dmabuf_page_pool *dmabuf_page_pool_create(gfp_t gfp_mask, + unsigned int order); +void dmabuf_page_pool_destroy(struct dmabuf_page_pool *pool); +struct page *dmabuf_page_pool_alloc(struct dmabuf_page_pool *pool); +void dmabuf_page_pool_free(struct dmabuf_page_pool *pool, struct page *pag= e); + +#endif /* _DMABUF_PAGE_POOL_H */ --=20 2.25.0 From nobody Sun Apr 12 04:21:21 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5ECD9C00140 for ; Tue, 2 Aug 2022 09:59:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236424AbiHBJ7G (ORCPT ); Tue, 2 Aug 2022 05:59:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42222 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236368AbiHBJ66 (ORCPT ); Tue, 2 Aug 2022 05:58:58 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4C7AC4B0D0; Tue, 2 Aug 2022 02:58:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=fAyb09nd/oxYF2HHyOIzdifj0LwovxhxsMt7wXDaqTlxUEFyWDTDM6m1scRQ8wHiQ1WBfOtcrqGaa78E1xs3JnpXLw7gaKKJO93/h0pm7bo4w9TdMf+xNAUeoPiB6RvLp3WrVrZ+juMrL6asbgji88a2BXX8PrEOarbKpxFO7sbbsc23SoXnlW/DnBEQ+2JjzEVHXvLsYxxsFBlBSkUArnuwLvzk28aZRVlcdmKVgnYhCzJ+UyT9qPh+KI9mcLzZtwCv4vqnHasu2BWQ1ZDTtpFMRu9Yq2BvYquilgYFiuJF9hMaPNC6Fsf75yTaw2ULumnZhdZ8i0b4piJ30bZx/g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=Lk8z61pSjUyn51VI9T8eBY3Ubnc7j16YLC8/9J63+4k=; b=QbOSOWbZqt9CSWaMF3aM57bneDYWJiYnTesycTAhzldKkP4I+TbVYme0xwn1dXPzWtCDsmsE47qMMZeh7f3elC2f+jJRp/wIheNIAkuwl9jTuDw65orE4fmzTApK4+mi2YUpB3iVm2hLWA6DiDueFixrN8VV77MrJG0s5YJVhgGkAVhFvcknKIG05iVYSJTDjWOWJemMeMRk8oNIvm28OIBJzEh6j5XHU+blTyoKMXYCUDAHNAHdIvgxgSlHs7Erxi8XIqKRb5ecXOtMV/acHmhiCr63nIx9ohhiRss29JuYOOU9x5FNFUJFr8KB/shgfVWjahjqeZTHxABM/jiFXg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Lk8z61pSjUyn51VI9T8eBY3Ubnc7j16YLC8/9J63+4k=; b=YA7144S06dZgXkQvxUNM6dW3kpWhC6nCiaxX0loZw7Qhd9V2vF6QQmCC5aTQsTuRIDqhp+1Ml42Sk7mzz1qcTj7UrCTfIUsuOwk1UKwBwevk6f5MADQxvS54ktEUy/KYAN1RApfRj/8WmcYERY2dXxOCTLsRiKWJDMpVEA0nHNU= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:53 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:52 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 3/5] dma-buf: heaps: add Linaro secure dmabuf heap support Date: Tue, 2 Aug 2022 11:58:41 +0200 Message-Id: <20220802095843.14614-4-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3c3323bc-c935-4a49-c419-08da746d9af5 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3VJUOiXuJkxZk8uXTbdXPV4FOnmukCl8oeyHT5nadlKsz0HcrdrGP6BMBg9k8LNP/szZyemJw9O0FMhCWDEvpFtLSh+gMpGDyBs0cmW7RTfScuCXk9zL5BLly5jGM0zKCuuGRJo3xGkovLqdbmZVXSe+fqCJ+Z41q+Nqgz/xJqR08xljDh+TO5O8usZan9hk+Sxk8Z8siPQ1cuZh/No+p9qvTBNhjDeXsEVfBnykivqvnv1hfKdoiZ5uvUeENN/OoVHzkprl7lVOppE6aXxbl9zTyZTbJjM4llpqV80PvHStiJEFnuWOJ0W491mQADDzfwWjRl4KZ/TlU+VBnjLn5485X25Z6tsI9x9mvy63gbxrmU5b7uh5wscDyJ5AeHQMeE1p0IRGcQUO4eCrttRMB/UMX9gDSauSRnAgePiLDkOqhEtnGr5czIc2lGFNro8m3G6NsqEiWZTjARFTlj81jUU/Fw6VROLRGT6VonHcXmuQbpXZlwG68JlMISyUaMpv8EPJ7AHSgTeoeuLMwwAKfNNM2kNvMP3yZ93GtFP9FcoDRgrqdEh9FAFVr/h9p2sGi9r7MiVjUukubC7jTXNjQu38EZViEImwFj2sw0Su6PRdt3PSgpq/kQ4a1Oy+Vf+ROleCIz5rwWyPoCS3/YTD8+w71IOsB+b97lgALabIMjGK5JIhmKq1jPfU/QffkaoF3/Qu7/y1G+j2zWeVMLGFfFNZC9AOa56N3lkx4A8Ux6kYXXRmU6ddE95osjDYmBMa6kJOnec5cSmakaibUcDkICrJxLA2WDfPUQEUavFnYiE= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR04MB6737.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(30864003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?RtVU1wcVxH2WPoDSDnZpQBbfWhWRfIPe6FnRQ7p++u0XGdPj4XSUEXTVKgDl?= =?us-ascii?Q?LzeS2YpSiRdr0jC9mIPLl5PW24quP5nL1My5IdzE3v0VUeejF/shnTIRRBsq?= =?us-ascii?Q?U85eUoqHND56TVMb967kNmLxTzqykXCyXJ2K/QN0iHTBGjjV++Xa25Lq9+7k?= =?us-ascii?Q?iTqAcfq/U7p1jELq0X4EhZu/sddsSjZPFtOMYRjt3dYyX334bH7Grkw6yTNI?= =?us-ascii?Q?UftV1T5QXmBPprTs0ASfj48ao/UBJ2kEGI7WHw87y8vL+5C61QoyOj7YCIYM?= =?us-ascii?Q?0J6xMrau+6Xn7EoBBV/3GtNUTQPTO/hhvtktZqvQDAWTl8cGe7S2QMVHJik7?= =?us-ascii?Q?CAsTvJomGuf/kNMI+Taph562icO3aU3B7olQK8eqf1HYtX0Sy0707qZDnMqe?= =?us-ascii?Q?wQ0NyObvc6lNx8x69Xn3uXtxCsAx0Libe3t9onPVleqEN7Q6QKll2JX2DS0Y?= =?us-ascii?Q?jLy5Vn4I62LUzOgdF/13NBZuce5AXH15ALjDNCuDJZO7DLS7KXlEKXd9MSmW?= =?us-ascii?Q?zeH03se8unc46J01XdIzQc4S1JCOMfo7eunCeal3Rrdr5IwtJgjFHeADX8sg?= =?us-ascii?Q?gtoi/kFmj5Ma54cINZZ/HWLw2vBHonSvWMjRZUASY7xxhTnIcRuaUiJewRDG?= =?us-ascii?Q?eb3n+JeXjm2Q9TnywQ8EhHHLmQ8k95KD9n3zdIf+vmMpxwKm5VNizjsbjvXa?= =?us-ascii?Q?6sBLZfdrbmTzEYdZHF34qQLeL9aKZR0p9e5gP/mkL+nm3ErvWWQJ+zJMiMuj?= =?us-ascii?Q?lUy6lZAEqJdfGlTYGpv5vMajU7dydV7kQ5TvSVllBgEtx4im9yddIX8jC+fl?= =?us-ascii?Q?DvxZhMlrdghftDRn8cyX7tyancVrQ3qLnva+cEvGdT+TNtErCFZFTHmPUCjA?= =?us-ascii?Q?ON36S0sZ51J2YCvDoytDlUf/IK9fgdST+fOwZBSMNgfzppMyBBN6QBoihyKi?= =?us-ascii?Q?QrLotc/gboFily66xwP9fEl9UHkyxFMJx2FNXVfo51gLxXIM5jKFHjmQsOGv?= =?us-ascii?Q?J0yXb6wkQkJ3lHEYPj3+alov26D/uA9zJyGBtC5y0xoWDHd0eSrpBuwKQPPD?= =?us-ascii?Q?S1uo/LgzQ772Oa7ilsKe1qFqR0my93le5bSiqE7NZVycRsRKWV/wY6SjSV/p?= =?us-ascii?Q?eRgKfy1TYPcntr2sEFzUFDWTA1OZBCjS2PAtlYUr5EomTkh4l3v2cQmHjTLU?= =?us-ascii?Q?/cqHzW65Dco+r6zBV1n5wxpXPRsYK+1pamqZGhPVgT8hFRE3/FEuIgh+TA7c?= =?us-ascii?Q?5tYgxJ5o41gWMq0AIf3F5DnlI3eIAvi/zVDOGie9zpAt3B1d0RQWXp9jqiox?= =?us-ascii?Q?rUHpHupY8UWenF2CNqWfA74HrXZ1BQMoQkuVh//oFlu23SPMVsm1pONWTYmf?= =?us-ascii?Q?QpNaaY14TVJhEdU/JUZp5yyzU8UvY2F+c+xtaCXs6SrW6ncb8z+wxcRuP+SY?= =?us-ascii?Q?0YglghD2tkplp3OpnUwyQ//9+f6TkzBbIgOPLXb7WZ20bWlEQtizrtgWc74c?= =?us-ascii?Q?6G3Q1SrUiKvrFiwri5r6P3o3RQL3rNBp99ktsiYEC2OdZPSl4sa7XdOm6huG?= =?us-ascii?Q?V1ny4KB8u+BULo8JBl/lGC1sP747f8Zerucrwwyb?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 3c3323bc-c935-4a49-c419-08da746d9af5 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:52.8901 (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: IslUwqqCqgJank03GR1fwYylWB6A1KouinKSk9UMpkq1K5CY/N/sS+MTz/sdJ2R8CtYtciIzIOkcnMffkM9wfA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" add Linaro secure heap bindings: linaro,secure-heap use genalloc to allocate/free buffer from buffer pool. buffer pool info is from dts. use sg_table instore the allocated memory info, the length of sg_table is 1. implement secure_heap_buf_ops to implement buffer share in difference devic= e: 1. Userspace passes this fd to all drivers it wants this buffer to share with: First the filedescriptor is converted to a &dma_buf using dma_buf_get(). Then the buffer is attached to the device using dma_buf_atta= ch(). 2. Once the buffer is attached to all devices userspace can initiate DMA access to the shared buffer. In the kernel this is done by calling dma_buf_= map_attachment() 3. get sg_table with dma_buf_map_attachment in difference device. Signed-off-by: Olivier Masse --- drivers/dma-buf/heaps/Kconfig | 21 +- drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/secure_heap.c | 588 ++++++++++++++++++++++++++++ 3 files changed, 606 insertions(+), 4 deletions(-) create mode 100644 drivers/dma-buf/heaps/secure_heap.c diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 6a33193a7b3e..b2406932192e 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,8 +1,12 @@ -config DMABUF_HEAPS_DEFERRED_FREE - tristate +menuconfig DMABUF_HEAPS_DEFERRED_FREE + bool "DMA-BUF heaps deferred-free library" + help + Choose this option to enable the DMA-BUF heaps deferred-free library. =20 -config DMABUF_HEAPS_PAGE_POOL - tristate +menuconfig DMABUF_HEAPS_PAGE_POOL + bool "DMA-BUF heaps page-pool library" + help + Choose this option to enable the DMA-BUF heaps page-pool library. =20 config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" @@ -26,3 +30,12 @@ config DMABUF_HEAPS_DSP Choose this option to enable the dsp dmabuf heap. The dsp heap is allocated by gen allocater. it's allocated according the dts. If in doubt, say Y. + +config DMABUF_HEAPS_SECURE + tristate "DMA-BUF Secure Heap" + depends on DMABUF_HEAPS && DMABUF_HEAPS_DEFERRED_FREE + help + Choose this option to enable the secure dmabuf heap. The secure heap + pools are defined according to the DT. Heaps are allocated + in the pools using gen allocater. + If in doubt, say Y. diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index e70722ea615e..08f6aa5919d1 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_DMABUF_HEAPS_PAGE_POOL) +=3D page_pool.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) +=3D system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) +=3D cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) +=3D dsp_heap.o +obj-$(CONFIG_DMABUF_HEAPS_SECURE) +=3D secure_heap.o diff --git a/drivers/dma-buf/heaps/secure_heap.c b/drivers/dma-buf/heaps/se= cure_heap.c new file mode 100644 index 000000000000..31aac5d050b4 --- /dev/null +++ b/drivers/dma-buf/heaps/secure_heap.c @@ -0,0 +1,588 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMABUF secure heap exporter + * + * Copyright 2021 NXP. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "deferred-free-helper.h" +#include "page_pool.h" + +#define MAX_SECURE_HEAP 2 +#define MAX_HEAP_NAME_LEN 32 + +struct secure_heap_buffer { + struct dma_heap *heap; + struct list_head attachments; + struct mutex lock; + unsigned long len; + struct sg_table sg_table; + int vmap_cnt; + struct deferred_freelist_item deferred_free; + void *vaddr; + bool uncached; +}; + +struct dma_heap_attachment { + struct device *dev; + struct sg_table *table; + struct list_head list; + bool no_map; + bool mapped; + bool uncached; +}; + +struct secure_heap_info { + struct gen_pool *pool; + + bool no_map; +}; + +struct rmem_secure { + phys_addr_t base; + phys_addr_t size; + + char name[MAX_HEAP_NAME_LEN]; + + bool no_map; +}; + +static struct rmem_secure secure_data[MAX_SECURE_HEAP] =3D {0}; +static unsigned int secure_data_count; + +static struct sg_table *dup_sg_table(struct sg_table *table) +{ + struct sg_table *new_table; + int ret, i; + struct scatterlist *sg, *new_sg; + + new_table =3D kzalloc(sizeof(*new_table), GFP_KERNEL); + if (!new_table) + return ERR_PTR(-ENOMEM); + + ret =3D sg_alloc_table(new_table, table->orig_nents, GFP_KERNEL); + if (ret) { + kfree(new_table); + return ERR_PTR(-ENOMEM); + } + + new_sg =3D new_table->sgl; + for_each_sgtable_sg(table, sg, i) { + sg_set_page(new_sg, sg_page(sg), sg->length, sg->offset); + new_sg->dma_address =3D sg->dma_address; +#ifdef CONFIG_NEED_SG_DMA_LENGTH + new_sg->dma_length =3D sg->dma_length; +#endif + new_sg =3D sg_next(new_sg); + } + + return new_table; +} + +static int secure_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + struct secure_heap_info *info =3D dma_heap_get_drvdata(buffer->heap); + struct dma_heap_attachment *a; + struct sg_table *table; + + a =3D kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + table =3D dup_sg_table(&buffer->sg_table); + if (IS_ERR(table)) { + kfree(a); + return -ENOMEM; + } + + a->table =3D table; + a->dev =3D attachment->dev; + INIT_LIST_HEAD(&a->list); + a->no_map =3D info->no_map; + a->mapped =3D false; + a->uncached =3D buffer->uncached; + attachment->priv =3D a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void secure_heap_detach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + struct dma_heap_attachment *a =3D attachment->priv; + + mutex_lock(&buffer->lock); + list_del(&a->list); + mutex_unlock(&buffer->lock); + + sg_free_table(a->table); + kfree(a->table); + kfree(a); +} + +static struct sg_table *secure_heap_map_dma_buf(struct dma_buf_attachment = *attachment, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a =3D attachment->priv; + struct sg_table *table =3D a->table; + int attr =3D 0; + int ret; + + if (!a->no_map) { + if (a->uncached) + attr =3D DMA_ATTR_SKIP_CPU_SYNC; + + ret =3D dma_map_sgtable(attachment->dev, table, direction, attr); + if (ret) + return ERR_PTR(ret); + + a->mapped =3D true; + } + + return table; +} + +static void secure_heap_unmap_dma_buf(struct dma_buf_attachment *attachmen= t, + struct sg_table *table, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a =3D attachment->priv; + int attr =3D 0; + + if (!a->no_map) { + if (a->uncached) + attr =3D DMA_ATTR_SKIP_CPU_SYNC; + + a->mapped =3D false; + dma_unmap_sgtable(attachment->dev, table, direction, attr); + } +} + +static int secure_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + struct dma_heap_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + invalidate_kernel_vmap_range(buffer->vaddr, buffer->len); + + if (!buffer->uncached) { + list_for_each_entry(a, &buffer->attachments, list) { + if (!a->mapped) + continue; + dma_sync_sgtable_for_cpu(a->dev, a->table, direction); + } + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int secure_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + struct dma_heap_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + flush_kernel_vmap_range(buffer->vaddr, buffer->len); + + if (!buffer->uncached) { + list_for_each_entry(a, &buffer->attachments, list) { + if (!a->mapped) + continue; + dma_sync_sgtable_for_device(a->dev, a->table, direction); + } + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int secure_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct = *vma) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + struct sg_table *table =3D &buffer->sg_table; + unsigned long addr =3D vma->vm_start; + struct sg_page_iter piter; + int ret; + + if (buffer->uncached) + vma->vm_page_prot =3D pgprot_writecombine(vma->vm_page_prot); + + for_each_sgtable_page(table, &piter, vma->vm_pgoff) { + struct page *page =3D sg_page_iter_page(&piter); + + ret =3D remap_pfn_range(vma, addr, page_to_pfn(page), PAGE_SIZE, + vma->vm_page_prot); + if (ret) + return ret; + addr +=3D PAGE_SIZE; + } + return 0; +} + +static void *secure_heap_do_vmap(struct secure_heap_buffer *buffer) +{ + struct sg_table *table =3D &buffer->sg_table; + int npages =3D PAGE_ALIGN(buffer->len) / PAGE_SIZE; + struct page **pages =3D vmalloc(sizeof(struct page *) * npages); + struct page **tmp =3D pages; + struct sg_page_iter piter; + pgprot_t pgprot =3D PAGE_KERNEL; + void *vaddr; + + if (!pages) + return ERR_PTR(-ENOMEM); + + if (buffer->uncached) + pgprot =3D pgprot_writecombine(PAGE_KERNEL); + + for_each_sgtable_page(table, &piter, 0) { + WARN_ON(tmp - pages >=3D npages); + *tmp++ =3D sg_page_iter_page(&piter); + } + + vaddr =3D vmap(pages, npages, VM_MAP, pgprot); + vfree(pages); + + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +static int secure_heap_vmap(struct dma_buf *dmabuf, struct dma_buf_map *ma= p) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + void *vaddr; + int ret =3D 0; + + mutex_lock(&buffer->lock); + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + goto out; + } + + vaddr =3D secure_heap_do_vmap(buffer); + if (IS_ERR(vaddr)) { + ret =3D PTR_ERR(vaddr); + goto out; + } + + buffer->vaddr =3D vaddr; + buffer->vmap_cnt++; + dma_buf_map_set_vaddr(map, buffer->vaddr); +out: + mutex_unlock(&buffer->lock); + + return ret; +} + +static void secure_heap_vunmap(struct dma_buf *dmabuf, struct dma_buf_map = *map) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + + mutex_lock(&buffer->lock); + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr =3D NULL; + } + mutex_unlock(&buffer->lock); + dma_buf_map_clear(map); +} + +static void secure_heap_zero_buffer(struct secure_heap_buffer *buffer) +{ + struct sg_table *sgt =3D &buffer->sg_table; + struct sg_page_iter piter; + struct page *p; + void *vaddr; + + for_each_sgtable_page(sgt, &piter, 0) { + p =3D sg_page_iter_page(&piter); + vaddr =3D kmap_atomic(p); + memset(vaddr, 0, PAGE_SIZE); + kunmap_atomic(vaddr); + } +} + +static void secure_heap_buf_free(struct deferred_freelist_item *item, + enum df_reason reason) +{ + struct secure_heap_buffer *buffer; + struct secure_heap_info *info; + struct sg_table *table; + struct scatterlist *sg; + int i; + + buffer =3D container_of(item, struct secure_heap_buffer, deferred_free); + info =3D dma_heap_get_drvdata(buffer->heap); + + if (!info->no_map) { + // Zero the buffer pages before adding back to the pool + if (reason =3D=3D DF_NORMAL) + secure_heap_zero_buffer(buffer); + } + + table =3D &buffer->sg_table; + for_each_sg(table->sgl, sg, table->nents, i) + gen_pool_free(info->pool, sg_dma_address(sg), sg_dma_len(sg)); + + sg_free_table(table); + kfree(buffer); +} + +static void secure_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct secure_heap_buffer *buffer =3D dmabuf->priv; + int npages =3D PAGE_ALIGN(buffer->len) / PAGE_SIZE; + + deferred_free(&buffer->deferred_free, secure_heap_buf_free, npages); +} + +static const struct dma_buf_ops secure_heap_buf_ops =3D { + .attach =3D secure_heap_attach, + .detach =3D secure_heap_detach, + .map_dma_buf =3D secure_heap_map_dma_buf, + .unmap_dma_buf =3D secure_heap_unmap_dma_buf, + .begin_cpu_access =3D secure_heap_dma_buf_begin_cpu_access, + .end_cpu_access =3D secure_heap_dma_buf_end_cpu_access, + .mmap =3D secure_heap_mmap, + .vmap =3D secure_heap_vmap, + .vunmap =3D secure_heap_vunmap, + .release =3D secure_heap_dma_buf_release, +}; + +static struct dma_buf *secure_heap_do_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long fd_flags, + unsigned long heap_flags, + bool uncached) +{ + struct secure_heap_buffer *buffer; + struct secure_heap_info *info =3D dma_heap_get_drvdata(heap); + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + unsigned long size =3D roundup(len, PAGE_SIZE); + struct dma_buf *dmabuf; + struct sg_table *table; + int ret =3D -ENOMEM; + unsigned long phy_addr; + + buffer =3D kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return ERR_PTR(-ENOMEM); + + INIT_LIST_HEAD(&buffer->attachments); + mutex_init(&buffer->lock); + buffer->heap =3D heap; + buffer->len =3D size; + buffer->uncached =3D uncached; + + phy_addr =3D gen_pool_alloc(info->pool, size); + if (!phy_addr) + goto free_buffer; + + table =3D &buffer->sg_table; + if (sg_alloc_table(table, 1, GFP_KERNEL)) + goto free_pool; + + sg_set_page(table->sgl, phys_to_page(phy_addr), size, 0); + sg_dma_address(table->sgl) =3D phy_addr; + sg_dma_len(table->sgl) =3D size; + + /* create the dmabuf */ + exp_info.exp_name =3D dma_heap_get_name(heap); + exp_info.ops =3D &secure_heap_buf_ops; + exp_info.size =3D buffer->len; + exp_info.flags =3D fd_flags; + exp_info.priv =3D buffer; + dmabuf =3D dma_buf_export(&exp_info); + if (IS_ERR(dmabuf)) { + ret =3D PTR_ERR(dmabuf); + goto free_pages; + } + + return dmabuf; + +free_pages: + sg_free_table(table); + +free_pool: + gen_pool_free(info->pool, phy_addr, size); + +free_buffer: + mutex_destroy(&buffer->lock); + kfree(buffer); + + return ERR_PTR(ret); +} + +static struct dma_buf *secure_heap_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long fd_flags, + unsigned long heap_flags) +{ + // use uncache buffer here by default + return secure_heap_do_allocate(heap, len, fd_flags, heap_flags, true); + // use cache buffer + // return secure_heap_do_allocate(heap, len, fd_flags, heap_flags, false); +} + +static const struct dma_heap_ops secure_heap_ops =3D { + .allocate =3D secure_heap_allocate, +}; + +static int secure_heap_add(struct rmem_secure *rmem) +{ + struct dma_heap *secure_heap; + struct dma_heap_export_info exp_info; + struct secure_heap_info *info =3D NULL; + struct gen_pool *pool =3D NULL; + int ret =3D -EINVAL; + + if (rmem->base =3D=3D 0 || rmem->size =3D=3D 0) { + pr_err("secure_data base or size is not correct\n"); + goto error; + } + + info =3D kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) { + pr_err("dmabuf info allocation failed\n"); + ret =3D -ENOMEM; + goto error; + } + + pool =3D gen_pool_create(PAGE_SHIFT, -1); + if (!pool) { + pr_err("can't create gen pool\n"); + ret =3D -ENOMEM; + goto error; + } + + if (gen_pool_add(pool, rmem->base, rmem->size, -1) < 0) { + pr_err("failed to add memory into pool\n"); + ret =3D -ENOMEM; + goto error; + } + + info->pool =3D pool; + info->no_map =3D rmem->no_map; + + exp_info.name =3D rmem->name; + exp_info.ops =3D &secure_heap_ops; + exp_info.priv =3D info; + + secure_heap =3D dma_heap_add(&exp_info); + if (IS_ERR(secure_heap)) { + pr_err("dmabuf secure heap allocation failed\n"); + ret =3D PTR_ERR(secure_heap); + goto error; + } + + return 0; + +error: + kfree(info); + if (pool) + gen_pool_destroy(pool); + + return ret; +} + +static int secure_heap_create(void) +{ + unsigned int i; + int ret; + + for (i =3D 0; i < secure_data_count; i++) { + ret =3D secure_heap_add(&secure_data[i]); + if (ret) + return ret; + } + return 0; +} + +static int rmem_secure_heap_device_init(struct reserved_mem *rmem, + struct device *dev) +{ + dev_set_drvdata(dev, rmem); + return 0; +} + +static void rmem_secure_heap_device_release(struct reserved_mem *rmem, + struct device *dev) +{ + dev_set_drvdata(dev, NULL); +} + +static const struct reserved_mem_ops rmem_dma_ops =3D { + .device_init =3D rmem_secure_heap_device_init, + .device_release =3D rmem_secure_heap_device_release, +}; + +static int __init rmem_secure_heap_setup(struct reserved_mem *rmem) +{ + if (secure_data_count < MAX_SECURE_HEAP) { + int name_len =3D 0; + char *s =3D rmem->name; + + secure_data[secure_data_count].base =3D rmem->base; + secure_data[secure_data_count].size =3D rmem->size; + secure_data[secure_data_count].no_map =3D + (of_get_flat_dt_prop(rmem->fdt_node, "no-map", NULL) !=3D NULL); + + while (name_len < MAX_HEAP_NAME_LEN) { + if ((*s =3D=3D '@') || (*s =3D=3D '\0')) + break; + name_len++; + s++; + } + if (name_len =3D=3D MAX_HEAP_NAME_LEN) + name_len--; + + strncpy(secure_data[secure_data_count].name, rmem->name, name_len); + + rmem->ops =3D &rmem_dma_ops; + pr_info("Reserved memory: DMA buf secure pool %s at %pa, size %ld MiB\n", + secure_data[secure_data_count].name, + &rmem->base, (unsigned long)rmem->size / SZ_1M); + + secure_data_count++; + return 0; + } + WARN_ONCE(1, "Cannot handle more than %u secure heaps\n", MAX_SECURE_HEAP= ); + return -EINVAL; +} + +RESERVEDMEM_OF_DECLARE(secure_heap, "linaro,secure-heap", rmem_secure_heap= _setup); + +module_init(secure_heap_create); +MODULE_LICENSE("GPL v2"); --=20 2.25.0 From nobody Sun Apr 12 04:21:21 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DC57CC00140 for ; Tue, 2 Aug 2022 09:59:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236437AbiHBJ7M (ORCPT ); Tue, 2 Aug 2022 05:59:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42260 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236384AbiHBJ67 (ORCPT ); Tue, 2 Aug 2022 05:58:59 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 675CB4B0D9; Tue, 2 Aug 2022 02:58:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=RKZ30Yxv9kMZrofK0pOWwUgxqDVpuyFlmqLbKm4mnh9z7t1ciHh4L/3BdCQ3O99c/zCzv0SNcQaXv/E3G7Lja8Qqpz4STvEtODXjoHo/3rXA46mlBiYe0TMmtUV7vy5v4+u8UoPSp8Za5wjjfGZLdqKjHLDTgsJ2zIzNbB0ELpXrU+GnsM5Kt95kybYPPcah5YgPOVagHBz0ZGx4Ui1xfT916rg8TF6hiSJq18zjDAv+Z9MrRhMr2q4fRVfqRNWEJt6iQ52SD03C5e8GDLyrcMLMsZoSKhZ/VMjBk5U6tmBCqle1iIewXwIgfV96w8bmyXyMD3CGqTcbdcUI8AUk9Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=K4xR/woOXLlHvmkQLuIa5OL1e0+nSDFpkc1bQc3CCzg=; b=g0+hv2gWUACAScgCO9Un8zI0dR1QrZo69uQawKKCquVoiifhsWKlEe+iY/mrBUz/O9NPSWiBoIubF6sW9tzmf3JmRVU22gBgpulbWsc95GbIRLHKxsFwSW8l4cDu7KKumKQQCxqJDJFoVBYoB530Z853Rvqp5vmOuAzWCKVJ2viOOE74xr0lqztT2PE62Z13ACSfmoMuNCkK9IfdlNrWGH09qFBxZas4piOlkUkcJiZ/ORMx4JU9ccwi0VXLt/90NTfStYe7gLsT4FnuRIqw2+/F+QxQ252PdopzbDChgT3K/YORMJnmF3tZhDOCvzBBFob4T4OyEA+/cSmKHH2B2w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=K4xR/woOXLlHvmkQLuIa5OL1e0+nSDFpkc1bQc3CCzg=; b=gwuI7OBxjXwQZUv+SL8LBuGOhdiHFiLcRp0Zd2MYwf1Wcw+BKQNugIBRyDAeB6+KDsayTA0QWwUUj83EunwcHA1AEs8jhQ4/zX4CiBr/PeqZDkglHsUfwR0xxbTZJJ4yZuN+k7QLVJ9vKrpX2Mt83GOwqhKtNUMEWYFkXKQsqdA= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:53 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:53 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 4/5] dt-bindings: reserved-memory: add linaro,secure-heap Date: Tue, 2 Aug 2022 11:58:42 +0200 Message-Id: <20220802095843.14614-5-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 75cdf14a-ff6b-4faf-5a09-08da746d9b6f X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Ep7FuFEqKt2zJczPpTiJyNMvQFLWQjjHi436wZsUoAzm57Chl1aLtRybYYAdlUy2yw1ImIbvzUYlserI8rPAA/dE49pkho4xnfsgrcxOU2DghrgTrqwzTcoa8/DncU04wONRx9v1wEd534TAX4Kux0GC1KRfCYy/qGernET/5RQo7lMP/BAr/Y09BQFf2u4+lMEpL3Wpz1DI96WEhDni4Wjutxb4mJjo2vHHdHWpauy9LLts/xQijyvAVC6kXfHFN42RKsV9KrsQ3tyUTiMsnqVMNScaoa3WxtlOb/uCLD/A20qwTfhzjvocNzwDRk1JrbbyG59RgqhVy6FnO3BeDQv8h/rUgeXZ4Nv4r+rV9p6UPVk8H2fSLF+AyRedM4G8WLRSXXybC4xGb2feOsNZYYzRhzxe9wVoJ9H04Jk0Z86fBP6IqZVo23bvq7oADjmHa1/JxsLLabvNQZyzKebpPmz7a/FI3PbGp1rCRayn88PaLg+3bdjJUax0pU4kOEcS925UwfJs5HzBzoUwKFaZTIlK3Q4+uMk5pRMK1Eu95oOad93DIyuXtujapQHVltXReclK/7uaoa50O/F5ehV09fj6VwrFcPpkKLDAR9nJPeOlV/7a5hgwk2CiA4onLkrt/4NYx/z2AayK82Xh4TPvQi4moV1hxTz/nLpGJsS37OACm2/lHG696dwiTgvbswtAFeVGMQzkG57eToxxmp+teDfe/sDSJhmxR3CSSELRPIzeNURsIu76snI1XlGCkFHJxDU93cum/K2I1nFyh52qLAfWQvwujLO/5/cCegj8g5OXOiwu8VplNykyVUCYcphztnPckaprE4M2kOKkXNIA+lqgbQvIhRoExwBxYKFIqBc= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR04MB6737.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002)(966005);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?LXxq85t2tpLuzH0dSrDUBcqA3pujmVT7+8H7G1RxgqzcUSWuy0axs3fyv3RM?= =?us-ascii?Q?0CAO5OqnY8nrZ2QbR30Sz/BCWbzytSkWkz4YHmxnxldlkGdF6pIW/OfKf0wW?= =?us-ascii?Q?dO0Ezh9YJUF4eUWU/dSH/1Sno97JKY0MnRBKnHhcUewBoIMCfKfntdk/i7t8?= =?us-ascii?Q?s5lgkljP+rBSv7geCcBtKktYg080ddOpj4d8RAcJ/33/4rBXX45n515ZUlqW?= =?us-ascii?Q?DNsatjlarQG3l+lv+Pw7LGuaurE2sgsz3M2THRnRn/mu72yLF2gRNoibQI63?= =?us-ascii?Q?kggg5A3mfgoDJUrA0hnoNlb8fLZike0+/ksQAD9JGyg5JTxKeFsymQ3m2MBu?= =?us-ascii?Q?cYanqFti248mLYs4bihDdNEtNzjpiSBN0X5UCk5HE3mdbrgIcp10q6zWic/c?= =?us-ascii?Q?4K5fNCu7BGJX2bmUztxCxZ1I/OCXrUKZL4+FFJJS5hlI/nXUn3zO1R7oRHcu?= =?us-ascii?Q?CDVAXbNfzdrOJ0sK9T11MArjuxQyp2RjRIAfJP+Ojeqe7mq2ahxvl71/GgrJ?= =?us-ascii?Q?46tJiKetbxdu6hmy0bfV47TFJ2ICLSF/0dy8RJykWZov/MAiiOjEbbWJuxYM?= =?us-ascii?Q?D/raICBbYU3ai4u0EsdMjkbBorpQbYkMbxfKk3qA8vnAllW5dl2/ChzYNTOR?= =?us-ascii?Q?EcOjkHjhIwHFtDWs8XyK0+b6+X/7jokdRGC/+pI+lWJK8f5A88qVyrK4djYu?= =?us-ascii?Q?XB78W9YtCQGMfN+aV9gehgVD+w0pLjbSncTFg8KVPZTWn09kTYuycQh6L91X?= =?us-ascii?Q?agxIWB08X2n/ZmP0IqNRXgZX0GapSpSeBSKJvsUAYUypdzDItQsRf7eCaPoz?= =?us-ascii?Q?ByYu2OTUcMwQ+jO3E8+z1uqZbJ3eWWlgJptjOTY16/ygRUSv0mMnqUwC63ih?= =?us-ascii?Q?yiBX9hkuK4vfme+CVvbiQfvmhN2KaaUKMgmmSCjWg8fjttURakup+OpQkizC?= =?us-ascii?Q?mOAOajmrWmiWJmWo+9G85Rv9VT8f/lIcPTgERvscXU1JZrKIJYLgvbzDBc5D?= =?us-ascii?Q?/hnVvAFi33a7LEpmKNVGYh91iWYk+Knptv7gCP8j2G1e7QetnMXq9DvpNQhJ?= =?us-ascii?Q?hdoNe78PxFZNsdUPHWSOLFgnK2vKWx40oBvqjqWYOFBJsMAVYBJeTENii7zL?= =?us-ascii?Q?KASLl24h6F3s3d3OGUXFMgl+wjcm0T2ZE0+DHJ/V0WEytCNHw9uncH8Mp+8x?= =?us-ascii?Q?em28kZwwGClo4kGsT4E+JWKDlOM+DC2DUMZ0Hcsc91IcL2uQf6V1rmsCEhvJ?= =?us-ascii?Q?dWV7Nx2lXqZcSxtmQbXF1jkHQOF9d8349XnAi6qH0wWEE9IQcIiIG1me4GBL?= =?us-ascii?Q?zLPHfovEL4qYa/n+vWPjxKCGc1k64yNWW1U++gRhDfncbrP0I62YouRc9Eld?= =?us-ascii?Q?sY3Lk7JpuFGEIDulS4Qx15jIRUKG5tdwgYgX3g/9LVhD6WVCPvYwZBo0VJFG?= =?us-ascii?Q?B87pWZi8rl/BBQkIJNzm7OjvrIh7yDturgPysP5VEBhhbA6k/ZKasX/7qzp8?= =?us-ascii?Q?zIJPHpTxiHypI4IG+AK9HiNlmMbZmrfIwIuaX5SueXRjLRdCTE1IOXdlpRSm?= =?us-ascii?Q?1YvfxOjvE+v1wzn7qN1XWOWFYM1uZNDz+SunhFnt?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 75cdf14a-ff6b-4faf-5a09-08da746d9b6f X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:53.6244 (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: aqEHAmRMpZxJXpI403FoUa7gn8OjolFDzYfuLopI1dJqRc5Lxzwx2jjO0mFHe4aNSRkIs7GXsA6Nn9P07WndIQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" DMABUF Reserved memory definition for OP-TEE SDP feaure. Signed-off-by: Olivier Masse --- .../reserved-memory/linaro,secure-heap.yaml | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 Documentation/devicetree/bindings/reserved-memory/linar= o,secure-heap.yaml diff --git a/Documentation/devicetree/bindings/reserved-memory/linaro,secur= e-heap.yaml b/Documentation/devicetree/bindings/reserved-memory/linaro,secu= re-heap.yaml new file mode 100644 index 000000000000..80522a4e2989 --- /dev/null +++ b/Documentation/devicetree/bindings/reserved-memory/linaro,secure-heap.= yaml @@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/reserved-memory/linaro,secure-heap.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Linaro Secure DMABUF Heap + +maintainers: + - Olivier Masse + +description: + Linaro OP-TEE firmware needs a reserved memory for the + Secure Data Path feature (aka SDP). + The purpose is to provide a secure memory heap which allow + non-secure OS to allocate/free secure buffers. + The TEE is reponsible for protecting the SDP memory buffers. + TEE Trusted Application can access secure memory references + provided as parameters (DMABUF file descriptor). + +allOf: + - $ref: "reserved-memory.yaml" + +properties: + compatible: + const: linaro,secure-heap + + reg: + description: + Region of memory reserved for OP-TEE SDP feature + + no-map: + $ref: /schemas/types.yaml#/definitions/flag + description: + Avoid creating a virtual mapping of the region as part of the OS' + standard mapping of system memory. + +unevaluatedProperties: false + +required: + - compatible + - reg + - no-map + +examples: + - | + reserved-memory { + #address-cells =3D <2>; + #size-cells =3D <2>; + + sdp@3e800000 { + compatible =3D "linaro,secure-heap"; + no-map; + reg =3D <0 0x3E800000 0 0x00400000>; + }; + }; --=20 2.25.0 From nobody Sun Apr 12 04:21:21 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F2E60C00140 for ; Tue, 2 Aug 2022 09:59:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236445AbiHBJ7S (ORCPT ); Tue, 2 Aug 2022 05:59:18 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42278 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236385AbiHBJ7A (ORCPT ); Tue, 2 Aug 2022 05:59:00 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7E1124B0C9; Tue, 2 Aug 2022 02:58:59 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eDwRj+yjEJSvNRpVq6aK1qC7Qip5Q3RIwjQDOR1lseqtlBfg1kvRCocdKywFRzWy/0r8hHIiOpNV7AwTX3UVGvGxHW9MnGyOY9PMlhiMZZdKHJaCJXS/PfVDzHCyujsco+eXUf7B8nV0RzPwQuWWDOFMBT084pcBH8o5b/Ru48R/Z5ZRBKpfTDd1ZV//cu2VcPGmbGJfAg7PU15JBjcxIWl/2Vjz9LgBJDr0kU7VksO/PPFndELkYxTeVj/gBoVJdJOyX65B6eoOX0NFL5KQcIWclQ5wM5G/8sECSgv+WieTRxhchV91eTAxHv33ewp7dqV2duTVzPm3RUa9/KTPuQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=JMaUYaQcN4WcuDP2F3cy1CDudujZulTsfHyIvpHi2No=; b=icpEcizahJ3iDQv9xzooReFlRHAgJF3ZDylbfL9d/th3Ocz8cTSvY/GJ4VvdSX3ribyAsXfOq228v4oo4dfZ5Yq96PR/tOzUtPjnRFJ1e7vm58MPYAfM1MYP7/D0BS/1klDynUZ9rfAumrb1zkh70pzyrflWI/3Uqh8m/RmHWAd2EAY8KQyJrsMnN4Wdt8apIXUBFE5s4oIEdIPJfMB5aqj/6XZPChH2fZw+ov8Rmrr/Uub4o0BhysTMf74wRegR/RgWKhjDJ6VO63N7ZIFyaotp3jSZwEc+Ua9TTthzcdiGZv9KH8Kp81RUK80Y8bPSl/vvEK7/KVBfF5sn/aGzyg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=JMaUYaQcN4WcuDP2F3cy1CDudujZulTsfHyIvpHi2No=; b=ITC6Q6ai+LFYlnRUbOVAtjiEoF37uJn7lVsueg7ZLJBpXVlDDyzFcPwEyj+EWcYczcJrFfnCSgLcok6CQyT2cjENCFPXbkj4kfbZBSs/GvYUDp2A13e/ZmHYC2L3MwnNdwNF7vvLa5Z1XDssz1DDWbcsz4HqNSWkp2zl2puNzrw= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:54 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:54 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 5/5] plat-hikey: Add linaro,secure-heap compatible Date: Tue, 2 Aug 2022 11:58:43 +0200 Message-Id: <20220802095843.14614-6-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> Content-Transfer-Encoding: quoted-printable X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 219c9b1e-b2c4-4692-8da2-08da746d9be6 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 7dpQHTNFi7odGQcvJk16ccjyLXpRdt16fWo4qhXIVDJf3UZz7uCLvjC/5JnmtfozspZlAgwNFycRj8g4r+YeHsmaBRC98e5CnEC+xpfnvw/PgGiPlepeu6EZy1zYg1ecaUmgQ70d5jbKZxikCKPrymdFtRwNeGiZC4g7l4tT+HblPbUlNAw9IuqMuqrbHP/Wswq7lvJBYVimgWnE3gvUEEL0KZrIgjGLCvyAjnUebkWGsSpffoGJ+Kc5HQ+rF91OJ7PFcJ7AtVaybrbpRr82enf58zEXlHbfZS90VUwGm/+/hXaM31bWXXSHTJpLiDopWFHp8AQlsOfPtzW2vZQFMKklvKET6sIVW3/fyKnMkIfh8ttS4MRMnVWvWMrU0UCjjXJ6nFFmHrOPeNPoq8dZtvimksgiv/k3EXt0uxXDCExkFAVUJ3SM4e8zbjJApxh6qMZ9EwiFm+u8h8Nj814mOCk9jDhasjdDzRHHUq+bNofRzr52UxVzx28FtvQzYMp4esmnf+O0J7rgeDPDKINetdgDgW1Q8IiQu2zYxH+e22qOLMllFHHkGVbzbJmOY+KdOcdrvAS45a88VS1MTOrow4F3zEHOxJQx4psR0YXsMX1nM1fsAU6kqOKZAqAPLvFcHwmtiFog5TorBVh0rIMqIkq0Yt7uh9kurU2bLSYhIdmCvoiaIElsKXljO7MbejNurJVA/AdGy8CKQiabCzjZIAae6WQMKNwXSpHZZ3870CAr98KR6WXZ+qQ1wbJ4MthWfqN149LXcy6fI4VvnIOV9WJnRQInAD/q+1DfoNHJCsI= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:AM0PR04MB6737.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?w44S6pk0jx5fXLp4QdyaZ1RCUQh13jmGIQ0caYHy7TLUvg0m1QEmImdq/eDE?= =?us-ascii?Q?E18iktoe3LZBKzF2r2l+lxS0jll3NZt3Ak7xPbWZA/XOkSsKC0EV2sVVYzkE?= =?us-ascii?Q?0oAHJi0+2VzphTpy9JyX9eW9Yic1e5p2+PAMVlgM5oTzyHZ/f6Ag5q1+xbVm?= =?us-ascii?Q?USwmeg7jDobMyW6TW8yt/mAzbsgqSWinSTP0iij/wU34wl37uUzuiQoTkeQn?= =?us-ascii?Q?YROzQgMADxkyBbzS6KKjXNJcqHCWivhu3SrjpmP9NjS2voK6Tf0EDwYVd7oz?= =?us-ascii?Q?qYiGh8qIbl7aK+W8DNFWUevbkGKrFqP3PqP17FIUkUyTxBG1KClSpbXii5M7?= =?us-ascii?Q?NucMl0gNCwKXRPmBUxS2OkQ4GsolrdwEqHdGMn3t7OI0aKCAnFSUQh5yyE2E?= =?us-ascii?Q?5VNoDChyVPqpQwwC3wGW1E+WSPryEWEAfD2UYgViowrSRWKT3TCM6CAnBjDX?= =?us-ascii?Q?sIpbFxoQvrPfIf1hq/5S79TPotyTNzMRd/6bncdFAm/liAAnK2bHwXE4N+1K?= =?us-ascii?Q?nhaQn3musgza7T6rtlgCRFA2jeM2+NDHtggtILtAJdDLVc2tdY2j2UNfoOR2?= =?us-ascii?Q?RQX6oenQtZe2N5vhARUywUaVlEkiScf/ga8cadEPAmFzJiWwoH++HZf0ldPe?= =?us-ascii?Q?KU6VzaWkmP6MAnjgAZL8j24jVJAs4YKmuLZNhcGWEZo477bTm3WzeEh7ciLV?= =?us-ascii?Q?8EXPXiaArxOIrUFKA/BFOaRvjv4JnEw3xIHs43OzttEKvvDhCAxIm1iRmTS2?= =?us-ascii?Q?7iulAA07fxUPUavq7dPOco6wcwsJxqM6g+bFT0dS/9t7ArEzdAQZVooQilRI?= =?us-ascii?Q?pHU5gXSnY9nEWmIvu0a+LiBbgRiW2Ztl2eAT1j6rEBZ+M7KGRDD6LgBhkD7S?= =?us-ascii?Q?X3f5N1zM8fjet9/eD8yYt+5X/Y6CL/mUfqsVN/ZxxLl37ut8r/s4Dmcfd7FD?= =?us-ascii?Q?DG28pdtMFfV3YeEPV4DNx3kuVWofRNqBm/hQw7I2fOsox25qbu/abN1+T/A9?= =?us-ascii?Q?BZmHSANSgfyDWOgUOr7dQlt+WufYdk+Eko0AZM0fgFkxqs+Wl2v8GxkKaSvO?= =?us-ascii?Q?mbhGea/r8pz8+7Wz1Gtmt4rCJEimvqLEZtxViIGzWUMdQvBc07O6RrmxHRfx?= =?us-ascii?Q?ymrFrQfH9koVNSI4rxPtGA0jmeWwL7hUvVOKTYvyfQB0OtwNe55xuhvcDHV3?= =?us-ascii?Q?DTbgdEVi6l056lJPMBo775fF5Q3K0Tuu0i11ojWf1Z2dblT0NbZVQTRuiuYy?= =?us-ascii?Q?U6XiQeHCnZGRc56Nfg9QIqYOB2NZdaqIy3/NmuMGgU3mBW/JNZf8IBFCsOWG?= =?us-ascii?Q?/ZaKFCFiX7gbUOZkwXenJHFfQqnBc9xlVS1NncYu+BMMGeVUa0SduJqEB2ew?= =?us-ascii?Q?0+PDs786jw07/agkR9qhlsKLHjW9pfP1n7qHTUcCk0BFg/BSjV9B9efs60Mf?= =?us-ascii?Q?BTlIQzA2lqIKmcMVW1JOkC2ZRrndKeD/iFaPlwI4rUeNrQroQEZDk7IU0VG/?= =?us-ascii?Q?G1S5+Oszs3xE6afG64oUzxAwZXizyI9ier27cVjLi2w0YzIiue6ayZd3iIJk?= =?us-ascii?Q?/Z4JA2+Utt/T9nZFZpLskxUt4/xGPZMrF0NXRUa2?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 219c9b1e-b2c4-4692-8da2-08da746d9be6 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:54.3587 (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: XbUbVGGO3CBWraDX6qkrzPjjNmBRvqTX9hINUUh2Of1C44RobwJOOdDpd+US+wC7bKn0V4ldQp0PDyx8NceGXg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add DMABUF_HEAPS_SECURE in defconfig Signed-off-by: Olivier Masse --- arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts | 11 +++++++++++ arch/arm64/configs/defconfig | 4 ++++ 2 files changed, 15 insertions(+) diff --git a/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts b/arch/arm64/bo= ot/dts/hisilicon/hi6220-hikey.dts index 3df2afb2f637..e4af0d914279 100644 --- a/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts +++ b/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts @@ -258,6 +258,17 @@ optee { }; }; =20 + reserved-memory { + #address-cells =3D <2>; + #size-cells =3D <2>; + + sdp@3e800000 { + compatible =3D "linaro,secure-heap"; + no-map; + reg =3D <0 0x3E800000 0 0x00400000>; + }; + }; + sound_card { compatible =3D "audio-graph-card"; dais =3D <&i2s0_port0>; diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig index c09b07c22d57..4b625043313d 100644 --- a/arch/arm64/configs/defconfig +++ b/arch/arm64/configs/defconfig @@ -1465,6 +1465,10 @@ CONFIG_CRYPTO_DEV_HISI_SEC2=3Dm CONFIG_CRYPTO_DEV_HISI_ZIP=3Dm CONFIG_CRYPTO_DEV_HISI_HPRE=3Dm CONFIG_CRYPTO_DEV_HISI_TRNG=3Dm +CONFIG_DMABUF_HEAPS=3Dy +CONFIG_DMABUF_HEAPS_DEFERRED_FREE=3Dy +CONFIG_DMABUF_HEAPS_PAGE_POOL=3Dy +CONFIG_DMABUF_HEAPS_SECURE=3Dy CONFIG_CMA_SIZE_MBYTES=3D32 CONFIG_PRINTK_TIME=3Dy CONFIG_DEBUG_KERNEL=3Dy --=20 2.25.0