From b3446bc0b6fca6cb992667f80a95f8503b6a652a Mon Sep 17 00:00:00 2001 From: Alex Waterman Date: Thu, 7 Sep 2017 15:27:55 -0700 Subject: gpu: nvgpu: Move dma_buf usage from mm_gk20a.c Move most of the dma_buf usage present in the mm_gk20a.c code out to Linux specific code and some commom/mm code. There's two primary groups of code: 1. dma_buf priv field code (for holding comptag data) 2. Comptag usage that relies on dma_buf pointers For (1) the dma_buf code was simply moved to common/linux/dmabuf.c since most of this code is clearly Linux specific. The comptag code was a bit more complicated since there is two parts to the comptag code. Firstly there's the code that manages the comptag memory. This is essentially a simple allocator. This was moved to common/mm/comptags.c since it can be shared across all chips. The second set of code is moved to common/linux/comptags.c since it is the interface between dma_bufs and the comptag memory. Two other fixes were done as well: - Add struct gk20a to the comptag allocator init so that the proper nvgpu_vzalloc() function could be used. - Add necessary includes to common/linux/vm_priv.h. JIRA NVGPU-30 JIRA NVGPU-138 Change-Id: I96c57f2763e5ebe18a2f2ee4b33e0e1a2597848c Signed-off-by: Alex Waterman Reviewed-on: https://git-master.nvidia.com/r/1566628 Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/common/mm/comptags.c | 95 ++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 drivers/gpu/nvgpu/common/mm/comptags.c (limited to 'drivers/gpu/nvgpu/common/mm') diff --git a/drivers/gpu/nvgpu/common/mm/comptags.c b/drivers/gpu/nvgpu/common/mm/comptags.c new file mode 100644 index 00000000..01ab646a --- /dev/null +++ b/drivers/gpu/nvgpu/common/mm/comptags.c @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include "gk20a/gk20a.h" + +int gk20a_comptaglines_alloc(struct gk20a_comptag_allocator *allocator, + u32 *offset, u32 len) +{ + unsigned long addr; + int err = 0; + + nvgpu_mutex_acquire(&allocator->lock); + addr = bitmap_find_next_zero_area(allocator->bitmap, allocator->size, + 0, len, 0); + if (addr < allocator->size) { + /* number zero is reserved; bitmap base is 1 */ + *offset = 1 + addr; + bitmap_set(allocator->bitmap, addr, len); + } else { + err = -ENOMEM; + } + nvgpu_mutex_release(&allocator->lock); + + return err; +} + +void gk20a_comptaglines_free(struct gk20a_comptag_allocator *allocator, + u32 offset, u32 len) +{ + /* number zero is reserved; bitmap base is 1 */ + u32 addr = offset - 1; + + WARN_ON(offset == 0); + WARN_ON(addr > allocator->size); + WARN_ON(addr + len > allocator->size); + + nvgpu_mutex_acquire(&allocator->lock); + bitmap_clear(allocator->bitmap, addr, len); + nvgpu_mutex_release(&allocator->lock); +} + +int gk20a_comptag_allocator_init(struct gk20a *g, + struct gk20a_comptag_allocator *allocator, + unsigned long size) +{ + nvgpu_mutex_init(&allocator->lock); + + /* + * 0th comptag is special and is never used. The base for this bitmap + * is 1, and its size is one less than the size of comptag store. + */ + size--; + allocator->bitmap = nvgpu_vzalloc(g, + BITS_TO_LONGS(size) * sizeof(long)); + if (!allocator->bitmap) + return -ENOMEM; + + allocator->size = size; + + return 0; +} + +void gk20a_comptag_allocator_destroy(struct gk20a *g, + struct gk20a_comptag_allocator *allocator) +{ + /* + * called only when exiting the driver (gk20a_remove, or unwinding the + * init stage); no users should be active, so taking the mutex is + * unnecessary here. + */ + allocator->size = 0; + nvgpu_vfree(allocator->g, allocator->bitmap); +} -- cgit v1.2.2