From patchwork Fri Aug 14 06:24:57 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 247695 Delivered-To: patches@linaro.org Received: by 2002:a92:cc90:0:0:0:0:0 with SMTP id x16csp127405ilo; Thu, 13 Aug 2020 23:25:02 -0700 (PDT) X-Received: by 2002:a17:902:fe17:: with SMTP id g23mr1047065plj.30.1597386302579; Thu, 13 Aug 2020 23:25:02 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1597386302; cv=none; d=google.com; s=arc-20160816; b=cJID/eHUO0G1BgYBuMqaUU9m5YMo3fkJbyndH5/89OfkGgJY9TP+4lVv7Eb5/klXXu VQb/BtZR/gYjn252qhpwejz3kQm7IAGLLVGSCTMQiBiG7Q2LQBurfr2LZbw7XWqJ1g0G tlZifVuAHIH1vty9ny8VoeVsLK1JBQ1KkESHREvEuIR781kVI+V11ove2fBA3Kx5kLUf r+aUKZGNErYb+amrpGCjRCyMnwGf4kI1koWNCLtnpCeToupF3Q0FkRgvZcmR84a7bRxk PDITVIHn7IUwhe7iOr9yJggznJY6CZF1ewddNJGP197DzwdZ5uB4mfOL8mc9EEAhLLsl gEPw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=message-id:date:subject:cc:to:from:dkim-signature; bh=pwDOHGKYvCi61mHFneVF0EduuTKfnrQsk03HbkNHX20=; b=GJZ+GP5dBJo83+kFh4bjSnlChatIdQtlXsGmcKOL2IHq3InCUO9DLLxgx7WJi274re hjuAcmnyJTwYpdbNwIuslF23s7eOXeGAqKtrxhF0vTYiC1tGBbBy7lfpjKnklQJ+4TYp 5T8KvIE5xCd1+LKsys50fX3j2wAovUvJ2MjbWP+Gn2xhcywQ+NPjRtzMtoXsd97fDkwC h5vcGMkaEfaZaMpV5cKUZd99uYVuYiEBRYy1kh6d6ye4njbYEeVA5DBudOkcP9BAnkJw a7imPsN/M8DevQ5OGSidKbqGBYPjppGPMnhNrSBOP3l4xFu2gRlkc5rr+AvtK0NfVn5+ vizA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="dOPsv7f/"; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id y1sor7870186pjf.13.2020.08.13.23.25.02 for (Google Transport Security); Thu, 13 Aug 2020 23:25:02 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="dOPsv7f/"; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id; bh=pwDOHGKYvCi61mHFneVF0EduuTKfnrQsk03HbkNHX20=; b=dOPsv7f/wEuHeXmKjjFDeLAv02B1ounW5ulazhQV8hHqRYaoJ6XQBCnvtser32aA0E lgWuqqXH8kA0synMTCgHcFY7N2wuxSKoFOHOV6kqBkcKr5CSJ0fDOOolLuankz4PSiHm g+oRPe6gRdVqcAEnDUy6PIBRaTLR1LZZEGpxq4/ei7DQd0f9nkuuUli4Irvpx6e132Ev KKUCcTypG0YxXTabLVsyduvK5KJXFsR2GNAFoPL+SZGzbV9iiCoUhTMcAOa0EfqUFfJT LfhJ8/iUXz/Nfy9Wl7PPWVm2+2qUjp++JKg7RGAM5d8BbrjLDB9TujIrQQZgqMVHr1gt 0Mig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=pwDOHGKYvCi61mHFneVF0EduuTKfnrQsk03HbkNHX20=; b=JuL1l14EXpgi5qmKgcAK9gIpL74iDoeM8ADl3rQkC/JB7OMMnTH/wDW/7DgFuply+I b0qTW71JyBXvcoUvMLVNKPRhbuf0wJLHGqweaW4ySv1aI/Q46b9WRs5Kx9XxedUFe7ug Gyv31a/O42oEfBV3kUsUAXK6QeIzgZ2v9Db8ne0YUaHJi2blOq0Ymq68r/po8aGMRskW aCkYL/gwh8mivyyjAl43G5EUcgAhVdtjoeuFGzRk5VkZNYvwXCXXNGCLrajIvadQ5/iH SbYoaXxltplEAU3pb38K4kCp1mnapRkj45xjAtd3EdEDDgUtvsXEttbGexG14vvACzhh W5Kw== X-Gm-Message-State: AOAM531WnA0IJGg9qOXxa/gPxR5IkeE0EQd37l0KBXq+2T/FIXjANDBD XBtj+P8aGZgOWWW8vaIsY81pdl96 X-Google-Smtp-Source: ABdhPJxnGWB4G0BauuF1CXzPhUUlFpGdCXVBwviMTN5qRwfvr9KZRSe4Mu5Ey8K87w5P6jwDUx+ihA== X-Received: by 2002:a17:90b:1254:: with SMTP id gx20mr1133241pjb.117.1597386302081; Thu, 13 Aug 2020 23:25:02 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id z4sm7651496pfb.55.2020.08.13.23.25.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 13 Aug 2020 23:25:01 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Sumit Semwal , "Andrew F . Davis" , Benjamin Gaignard , Liam Mark , Laura Abbott , Brian Starkey , Hridya Valsaraju , Robin Murphy , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [RFC][PATCH v2 1/2] dma-heap: Keep track of the heap device struct Date: Fri, 14 Aug 2020 06:24:57 +0000 Message-Id: <20200814062458.53049-1-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 Keep track of the heap device struct. This will be useful for special DMA allocations and actions. Cc: Sumit Semwal Cc: Andrew F. Davis Cc: Benjamin Gaignard Cc: Liam Mark Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Robin Murphy Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- drivers/dma-buf/dma-heap.c | 33 +++++++++++++++++++++++++-------- include/linux/dma-heap.h | 9 +++++++++ 2 files changed, 34 insertions(+), 8 deletions(-) -- 2.17.1 diff --git a/drivers/dma-buf/dma-heap.c b/drivers/dma-buf/dma-heap.c index afd22c9dbdcf..72c746755d89 100644 --- a/drivers/dma-buf/dma-heap.c +++ b/drivers/dma-buf/dma-heap.c @@ -30,6 +30,7 @@ * @heap_devt heap device node * @list list head connecting to list of heaps * @heap_cdev heap char device + * @heap_dev heap device struct * * Represents a heap of memory from which buffers can be made. */ @@ -40,6 +41,7 @@ struct dma_heap { dev_t heap_devt; struct list_head list; struct cdev heap_cdev; + struct device *heap_dev; }; static LIST_HEAD(heap_list); @@ -190,10 +192,21 @@ void *dma_heap_get_drvdata(struct dma_heap *heap) return heap->priv; } +/** + * dma_heap_get_dev() - get device struct for the heap + * @heap: DMA-Heap to retrieve device struct from + * + * Returns: + * The device struct for the heap. + */ +struct device *dma_heap_get_dev(struct dma_heap *heap) +{ + return heap->heap_dev; +} + struct dma_heap *dma_heap_add(const struct dma_heap_export_info *exp_info) { struct dma_heap *heap, *h, *err_ret; - struct device *dev_ret; unsigned int minor; int ret; @@ -247,16 +260,20 @@ struct dma_heap *dma_heap_add(const struct dma_heap_export_info *exp_info) goto err1; } - dev_ret = device_create(dma_heap_class, - NULL, - heap->heap_devt, - NULL, - heap->name); - if (IS_ERR(dev_ret)) { + heap->heap_dev = device_create(dma_heap_class, + NULL, + heap->heap_devt, + NULL, + heap->name); + if (IS_ERR(heap->heap_dev)) { pr_err("dma_heap: Unable to create device\n"); - err_ret = ERR_CAST(dev_ret); + err_ret = ERR_CAST(heap->heap_dev); goto err2; } + + /* Make sure it doesn't disappear on us */ + heap->heap_dev = get_device(heap->heap_dev); + /* Add heap to the list */ mutex_lock(&heap_list_lock); list_add(&heap->list, &heap_list); diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h index 454e354d1ffb..82857e096910 100644 --- a/include/linux/dma-heap.h +++ b/include/linux/dma-heap.h @@ -50,6 +50,15 @@ struct dma_heap_export_info { */ void *dma_heap_get_drvdata(struct dma_heap *heap); +/** + * dma_heap_get_dev() - get device struct for the heap + * @heap: DMA-Heap to retrieve device struct from + * + * Returns: + * The device struct for the heap. + */ +struct device *dma_heap_get_dev(struct dma_heap *heap); + /** * dma_heap_add - adds a heap to dmabuf heaps * @exp_info: information needed to register this heap From patchwork Fri Aug 14 06:24:58 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 247696 Delivered-To: patches@linaro.org Received: by 2002:a92:cc90:0:0:0:0:0 with SMTP id x16csp127415ilo; Thu, 13 Aug 2020 23:25:03 -0700 (PDT) X-Received: by 2002:a63:e455:: with SMTP id i21mr797807pgk.202.1597386303647; Thu, 13 Aug 2020 23:25:03 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1597386303; cv=none; d=google.com; s=arc-20160816; b=MmjAhFk1qGWUgsWlHQPVpD0m6VaJQNMCqtzRR7ND4GpTtYih04yQlfg2yfbwm0TMxB GRB4KRLF5cNpiX6rqIEc70GHTr7prOiuTSOgFObfHRwC947BUXDPNcKGp232Zf97sXRn nILpgKpJrkLN25dayN/YCVBb9c196qXUyrqOuKzotH8W0JGZvWxge97ZCEh+aAzipaFH Oaj6crm18bYHcLBmZjEH+5bOcXU8vy34k6oRdVLv75KDlH2WZekCl/AMvIGv6SHOIWu9 srgU7JIZ4A5apEsxQNajQjlZtKVg16oL76ML5qkWFN8YZE8EKmRW6maNwOKhZl/auCkQ EM4w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=yc514AkWycGRwmxm2nApDNeU2mc+4NKToslZzDBRkRs=; b=UYElM2yPt9g3LR5qypXKY8vdTowNizLdGjxT+knLgwe1xpkZrfiEKRiA9Gk9UZbuGa NtMUZpjOn+keDpLWxWVPhM4fIveNDpA50j54Om6kWhplBhAtBKcXQreK3f/VQVASe4Av PGVU4Khw+YhTrbWU6nuDfIhMvl7cjyLQg+jj90rGnyGHwMwbRRYYIFf46cKfgPgOn33w 9Defhjj3pxmMcCt146z0E9XJZk4EhrCphLxZAYDkKRtLNaB0mX7tBjyIYxu3ma3+GuPo m9GZKWZHSxK6peVqUYRpMkBQ7nM+RaxgNsyfi4/Oono70Q4YGyiBNFh+JnJPb+bNDutP ZtzA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=tn1nQuQO; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id g72sor7661945pje.14.2020.08.13.23.25.03 for (Google Transport Security); Thu, 13 Aug 2020 23:25:03 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=tn1nQuQO; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=yc514AkWycGRwmxm2nApDNeU2mc+4NKToslZzDBRkRs=; b=tn1nQuQOUDYrrvjhBTsvpg87EhxQc5Iy653Xjoz0qGHilHL7gTyOkAoVguLaE48+Sh XD8KMbBHd+yzmfBGrx/rmlhiPLobgWCfg6YM1ZUVHNS8fgDb8I/fJLQ4AfClX7Z4Uh2X vboDg9ypgNVKrf33K0oOMjwV6oUzJdZso6BXESICI7WPMuMtYFEYK3ElYTZyqAYUXWUK OOMi8R+Blp4elsbPaU6CTk1iWZJ4dp0yWgvYcT3KCOr805RpWPu2Z0SK8c6G4yzlwppV zD0nb1nYZjTDdbQ56mby4tRca5kEH9aGx5qbIPdJ0e4n+194PP9yok8d88Pj/YNWHo6Q 4t3Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=yc514AkWycGRwmxm2nApDNeU2mc+4NKToslZzDBRkRs=; b=uksZomoXDYCjWbVGvp45Ey4elUw/0USscHj/u3dR8lHej4h3i5iXQ++O9zl8zs2gs5 /RqjCwbDWXCJ/PFwg5pF+l1g1Di08+ic4js2ApUuzW/SxXEPJqT/Lmbe9vdXvj91g68g wo4PdZZbwY+AX7j9zJX+u1UFoknok599HxMR+w6h5v+ovmt4e3jN2cW7WSiL50A0VJxG XJbNjZMuAyAyi8stME8D35fCDwJ2PrrUo5NZNhtmgUDAS/So+iRnEPvsLv+nirEpc6SZ BTqW7RuFOQGt/xmFZFF+yX9hr1dCXuo/6QhT7fgUtyukT36aRBpHyeB800pqzDHSb2sm XWhQ== X-Gm-Message-State: AOAM531yytRo/CN4otto5CL5eH2v2D17kNjPo0YcC2w43AIUXsdsBcov QtmEo62/xjHN8iKkfLbhECFlirAO X-Google-Smtp-Source: ABdhPJzNU46gn814xgDi01obd3TCQeIweoByG8W8g5RWyfburFvjzu2AfA0ZIAlzGulNGUszAdtVVg== X-Received: by 2002:a17:90a:7488:: with SMTP id p8mr1121720pjk.158.1597386303209; Thu, 13 Aug 2020 23:25:03 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id z4sm7651496pfb.55.2020.08.13.23.25.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 13 Aug 2020 23:25:02 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Sumit Semwal , "Andrew F . Davis" , Benjamin Gaignard , Liam Mark , Laura Abbott , Brian Starkey , Hridya Valsaraju , Robin Murphy , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [RFC][PATCH v2 2/2] dma-heap: Add a system-uncached heap Date: Fri, 14 Aug 2020 06:24:58 +0000 Message-Id: <20200814062458.53049-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200814062458.53049-1-john.stultz@linaro.org> References: <20200814062458.53049-1-john.stultz@linaro.org> This adds a heap that allocates non-contiguous buffers that are marked as writecombined, so they are not cached by the CPU. This is useful, as most graphics buffers are usually not touched by the CPU or only written into once by the CPU. So when mapping the buffer over and over between devices, we can skip the CPU syncing, which saves a lot of cache management overhead, greatly improving performance. For folk using ION, there was a ION_FLAG_CACHED flag, which signaled if the returned buffer should be CPU cacheable or not. With DMA-BUF heaps, we have no such flag, and by default the current heaps (system and cma) produce CPU cachable buffers. So for folks transitioning from ION to DMA-BUF Heaps, this fills in some of that missing functionality. This does have a few "ugly" bits that were required to get the buffer properly flushed out initially which I'd like to improve. So feedback would be very welcome! Many thanks to Liam Mark for his help to get this working. Cc: Sumit Semwal Cc: Andrew F. Davis Cc: Benjamin Gaignard Cc: Liam Mark Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Robin Murphy Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v2: * Fix build issue on sh reported-by: kernel test robot * Rework to use for_each_sgtable_sg(), dma_map_sgtable(), and for_each_sg_page() along with numerous other cleanups suggested by Robin Murphy --- drivers/dma-buf/heaps/Kconfig | 10 + drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/system_uncached_heap.c | 371 +++++++++++++++++++ 3 files changed, 382 insertions(+) create mode 100644 drivers/dma-buf/heaps/system_uncached_heap.c -- 2.17.1 diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index a5eef06c4226..420b0ed0a512 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -5,6 +5,16 @@ config DMABUF_HEAPS_SYSTEM Choose this option to enable the system dmabuf heap. The system heap is backed by pages from the buddy allocator. If in doubt, say Y. +config DMABUF_HEAPS_SYSTEM_UNCACHED + bool "DMA-BUF Uncached System Heap" + depends on DMABUF_HEAPS + help + Choose this option to enable the uncached system dmabuf heap. This + heap is backed by pages from the buddy allocator, but pages are setup + for write combining. This avoids cache management overhead, and can + be faster if pages are mostly untouched by the cpu. If in doubt, + say Y. + config DMABUF_HEAPS_CMA bool "DMA-BUF CMA Heap" depends on DMABUF_HEAPS && DMA_CMA diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index 6e54cdec3da0..085685ec478f 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 obj-y += heap-helpers.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o +obj-$(CONFIG_DMABUF_HEAPS_SYSTEM_UNCACHED) += system_uncached_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o diff --git a/drivers/dma-buf/heaps/system_uncached_heap.c b/drivers/dma-buf/heaps/system_uncached_heap.c new file mode 100644 index 000000000000..3b8e699bcae7 --- /dev/null +++ b/drivers/dma-buf/heaps/system_uncached_heap.c @@ -0,0 +1,371 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Uncached System DMA-Heap exporter + * + * Copyright (C) 2020 Linaro Ltd. + * + * Based off of Andrew Davis' SRAM heap: + * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/ + * Andrew F. Davis + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct uncached_heap { + struct dma_heap *heap; +}; + +struct uncached_heap_buffer { + struct dma_heap *heap; + struct list_head attachments; + struct mutex lock; + unsigned long len; + struct sg_table sg_table; + int vmap_cnt; + void *vaddr; +}; + +struct dma_heap_attachment { + struct device *dev; + struct sg_table *table; + struct list_head list; +}; + +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 = kzalloc(sizeof(*new_table), GFP_KERNEL); + if (!new_table) + return ERR_PTR(-ENOMEM); + + ret = sg_alloc_table(new_table, table->nents, GFP_KERNEL); + if (ret) { + kfree(new_table); + return ERR_PTR(-ENOMEM); + } + + new_sg = new_table->sgl; + for_each_sgtable_sg(table, sg, i) { + sg_set_page(new_sg, sg_page(sg), sg->length, sg->offset); + new_sg = sg_next(new_sg); + } + + return new_table; +} + +static int dma_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + struct sg_table *table; + + a = kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + table = dup_sg_table(&buffer->sg_table); + if (IS_ERR(table)) { + kfree(a); + return -ENOMEM; + } + + a->table = table; + a->dev = attachment->dev; + INIT_LIST_HEAD(&a->list); + + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void dma_heap_detatch(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a = 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 *dma_heap_map_dma_buf(struct dma_buf_attachment *attachment, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a = attachment->priv; + struct sg_table *table = a->table; + + if (dma_map_sgtable(attachment->dev, table, direction, DMA_ATTR_SKIP_CPU_SYNC)) + return ERR_PTR(-ENOMEM); + + return table; +} + +static void dma_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + dma_unmap_sgtable(attachment->dev, table, direction, DMA_ATTR_SKIP_CPU_SYNC); +} + +static int dma_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table = &buffer->sg_table; + unsigned long addr = vma->vm_start; + struct sg_page_iter piter; + int ret; + + vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); + + for_each_sgtable_page(table, &piter, vma->vm_pgoff) { + struct page *page = sg_page_iter_page(&piter); + + ret = remap_pfn_range(vma, addr, page_to_pfn(page), PAGE_SIZE, + vma->vm_page_prot); + if (ret) + return ret; + addr += PAGE_SIZE; + if (addr >= vma->vm_end) + return 0; + } + return 0; +} + +static void *dma_heap_do_vmap(struct uncached_heap_buffer *buffer) +{ + struct sg_table *table = &buffer->sg_table; + int npages = PAGE_ALIGN(buffer->len) / PAGE_SIZE; + struct page **pages = vmalloc(sizeof(struct page *) * npages); + struct page **tmp = pages; + struct sg_page_iter piter; + pgprot_t pgprot; + void *vaddr; + + if (!pages) + return ERR_PTR(-ENOMEM); + + pgprot = pgprot_writecombine(PAGE_KERNEL); + + for_each_sgtable_page(table, &piter, 0) { + WARN_ON(tmp - pages >= npages); + *tmp++ = sg_page_iter_page(&piter); + } + + vaddr = vmap(pages, npages, VM_MAP, pgprot); + vfree(pages); + + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +static void *dma_heap_buffer_vmap_get(struct uncached_heap_buffer *buffer) +{ + void *vaddr; + + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + return buffer->vaddr; + } + + vaddr = dma_heap_do_vmap(buffer); + if (IS_ERR(vaddr)) + return vaddr; + + buffer->vaddr = vaddr; + buffer->vmap_cnt++; + return vaddr; +} + +static void dma_heap_buffer_vmap_put(struct uncached_heap_buffer *buffer) +{ + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } +} + +static void *dma_heap_vmap(struct dma_buf *dmabuf) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + void *vaddr; + + mutex_lock(&buffer->lock); + vaddr = dma_heap_buffer_vmap_get(buffer); + mutex_unlock(&buffer->lock); + + return vaddr; +} + +static void dma_heap_vunmap(struct dma_buf *dmabuf, void *vaddr) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + dma_heap_buffer_vmap_put(buffer); + mutex_unlock(&buffer->lock); +} + +static void dma_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct uncached_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table; + struct scatterlist *sg; + int i; + + table = &buffer->sg_table; + dma_unmap_sgtable(dma_heap_get_dev(buffer->heap), table, DMA_BIDIRECTIONAL, 0); + + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); + kfree(buffer); +} + +const struct dma_buf_ops uncached_heap_buf_ops = { + .attach = dma_heap_attach, + .detach = dma_heap_detatch, + .map_dma_buf = dma_heap_map_dma_buf, + .unmap_dma_buf = dma_heap_unmap_dma_buf, + .mmap = dma_heap_mmap, + .vmap = dma_heap_vmap, + .vunmap = dma_heap_vunmap, + .release = dma_heap_dma_buf_release, +}; + +static int uncached_heap_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long fd_flags, + unsigned long heap_flags) +{ + struct uncached_heap_buffer *buffer; + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + struct dma_buf *dmabuf; + struct sg_table *table; + struct scatterlist *sg; + pgoff_t pagecount; + pgoff_t pg; + int i, ret = -ENOMEM; + + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return -ENOMEM; + + INIT_LIST_HEAD(&buffer->attachments); + mutex_init(&buffer->lock); + buffer->heap = heap; + buffer->len = len; + + table = &buffer->sg_table; + pagecount = len / PAGE_SIZE; + if (sg_alloc_table(table, pagecount, GFP_KERNEL)) + goto free_buffer; + + sg = table->sgl; + for (pg = 0; pg < pagecount; pg++) { + struct page *page; + /* + * Avoid trying to allocate memory if the process + * has been killed by SIGKILL + */ + if (fatal_signal_pending(current)) + goto free_pages; + page = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!page) + goto free_pages; + sg_set_page(sg, page, page_size(page), 0); + sg = sg_next(sg); + } + + /* create the dmabuf */ + exp_info.ops = &uncached_heap_buf_ops; + exp_info.size = buffer->len; + exp_info.flags = fd_flags; + exp_info.priv = buffer; + dmabuf = dma_buf_export(&exp_info); + if (IS_ERR(dmabuf)) { + ret = PTR_ERR(dmabuf); + goto free_pages; + } + + ret = dma_buf_fd(dmabuf, fd_flags); + if (ret < 0) { + dma_buf_put(dmabuf); + /* just return, as put will call release and that will free */ + return ret; + } + + /* + * XXX This is hackish. While the buffer will be uncached, we need + * to initially flush cpu cache, since the __GFP_ZERO on the + * allocation means the zeroing was done by the cpu and thus it is + * likely cached. Map (and implicitly flush) it out now so we don't + * get corruption later on. + * + * Ideally we could do this without using the heap device as a dummy dev. + */ + dma_map_sgtable(dma_heap_get_dev(heap), table, DMA_BIDIRECTIONAL, 0); + + return ret; + +free_pages: + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); +free_buffer: + kfree(buffer); + + return ret; +} + +static struct dma_heap_ops uncached_heap_ops = { + .allocate = uncached_heap_allocate, +}; + +static int uncached_heap_create(void) +{ + struct uncached_heap *heap; + struct dma_heap_export_info exp_info; + + heap = kzalloc(sizeof(*heap), GFP_KERNEL); + if (!heap) + return -ENOMEM; + + exp_info.name = "system-uncached"; + exp_info.ops = &uncached_heap_ops; + exp_info.priv = heap; + heap->heap = dma_heap_add(&exp_info); + if (IS_ERR(heap->heap)) { + int ret = PTR_ERR(heap->heap); + + kfree(heap); + return ret; + } + dma_coerce_mask_and_coherent(dma_heap_get_dev(heap->heap), DMA_BIT_MASK(64)); + + return 0; +} +device_initcall(uncached_heap_create);