2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2014-08-29 04:12:28 -06:00
|
|
|
* Legacy: Generic DRM Buffer Management
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
|
|
|
|
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
2014-08-29 04:12:28 -06:00
|
|
|
* Author: Rickard E. (Rik) Faith <faith@valinux.com>
|
|
|
|
* Author: Gareth Hughes <gareth@valinux.com>
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* 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 (including the next
|
|
|
|
* paragraph) 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
|
|
|
|
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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 <linux/vmalloc.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
#include <linux/log2.h>
|
2011-08-30 16:16:33 -06:00
|
|
|
#include <linux/export.h>
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
#include <asm/shmparam.h>
|
2012-10-02 11:01:07 -06:00
|
|
|
#include <drm/drmP.h>
|
2014-08-29 04:12:28 -06:00
|
|
|
#include "drm_legacy.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-11 00:53:40 -06:00
|
|
|
static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
|
2009-02-01 22:55:46 -07:00
|
|
|
struct drm_local_map *map)
|
2005-07-10 03:27:04 -06:00
|
|
|
{
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *entry;
|
2007-05-25 13:01:51 -06:00
|
|
|
list_for_each_entry(entry, &dev->maplist, head) {
|
2009-02-01 22:55:47 -07:00
|
|
|
/*
|
|
|
|
* Because the kernel-userspace ABI is fixed at a 32-bit offset
|
2011-05-30 13:45:43 -06:00
|
|
|
* while PCI resources may live above that, we only compare the
|
|
|
|
* lower 32 bits of the map offset for maps of type
|
|
|
|
* _DRM_FRAMEBUFFER or _DRM_REGISTERS.
|
|
|
|
* It is assumed that if a driver have more than one resource
|
|
|
|
* of each type, the lower 32 bits are different.
|
2009-02-01 22:55:47 -07:00
|
|
|
*/
|
|
|
|
if (!entry->map ||
|
|
|
|
map->type != entry->map->type ||
|
2016-06-21 02:54:12 -06:00
|
|
|
entry->master != dev->master)
|
2009-02-01 22:55:47 -07:00
|
|
|
continue;
|
|
|
|
switch (map->type) {
|
|
|
|
case _DRM_SHM:
|
|
|
|
if (map->flags != _DRM_CONTAINS_LOCK)
|
|
|
|
break;
|
2011-05-30 13:45:43 -06:00
|
|
|
return entry;
|
2009-02-01 22:55:47 -07:00
|
|
|
case _DRM_REGISTERS:
|
|
|
|
case _DRM_FRAME_BUFFER:
|
2011-05-30 13:45:43 -06:00
|
|
|
if ((entry->map->offset & 0xffffffff) ==
|
|
|
|
(map->offset & 0xffffffff))
|
|
|
|
return entry;
|
2009-02-01 22:55:47 -07:00
|
|
|
default: /* Make gcc happy */
|
|
|
|
;
|
2005-07-10 03:27:04 -06:00
|
|
|
}
|
2009-02-01 22:55:47 -07:00
|
|
|
if (entry->map->offset == map->offset)
|
|
|
|
return entry;
|
2005-07-10 03:27:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-11 18:26:44 -06:00
|
|
|
static int drm_map_handle(struct drm_device *dev, struct drm_hash_item *hash,
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
unsigned long user_token, int hashed_handle, int shm)
|
2005-08-05 06:11:22 -06:00
|
|
|
{
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
int use_hashed_handle, shift;
|
|
|
|
unsigned long add;
|
|
|
|
|
2006-08-12 00:03:26 -06:00
|
|
|
#if (BITS_PER_LONG == 64)
|
2006-08-07 06:36:47 -06:00
|
|
|
use_hashed_handle = ((user_token & 0xFFFFFFFF00000000UL) || hashed_handle);
|
|
|
|
#elif (BITS_PER_LONG == 32)
|
|
|
|
use_hashed_handle = hashed_handle;
|
|
|
|
#else
|
|
|
|
#error Unsupported long size. Neither 64 nor 32 bits.
|
|
|
|
#endif
|
2005-08-05 06:11:22 -06:00
|
|
|
|
2006-09-21 12:18:37 -06:00
|
|
|
if (!use_hashed_handle) {
|
|
|
|
int ret;
|
2007-02-07 22:14:05 -07:00
|
|
|
hash->key = user_token >> PAGE_SHIFT;
|
2006-09-21 12:18:37 -06:00
|
|
|
ret = drm_ht_insert_item(&dev->map_hash, hash);
|
|
|
|
if (ret != -EINVAL)
|
|
|
|
return ret;
|
2005-08-05 06:11:22 -06:00
|
|
|
}
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
|
|
|
|
shift = 0;
|
|
|
|
add = DRM_MAP_HASH_OFFSET >> PAGE_SHIFT;
|
|
|
|
if (shm && (SHMLBA > PAGE_SIZE)) {
|
|
|
|
int bits = ilog2(SHMLBA >> PAGE_SHIFT) + 1;
|
|
|
|
|
|
|
|
/* For shared memory, we have to preserve the SHMLBA
|
|
|
|
* bits of the eventual vma->vm_pgoff value during
|
|
|
|
* mmap(). Otherwise we run into cache aliasing problems
|
|
|
|
* on some platforms. On these platforms, the pgoff of
|
|
|
|
* a mmap() request is used to pick a suitable virtual
|
|
|
|
* address for the mmap() region such that it will not
|
|
|
|
* cause cache aliasing problems.
|
|
|
|
*
|
|
|
|
* Therefore, make sure the SHMLBA relevant bits of the
|
|
|
|
* hash value we use are equal to those in the original
|
|
|
|
* kernel virtual address.
|
|
|
|
*/
|
|
|
|
shift = bits;
|
|
|
|
add |= ((user_token >> PAGE_SHIFT) & ((1UL << bits) - 1UL));
|
|
|
|
}
|
|
|
|
|
2006-09-21 12:18:37 -06:00
|
|
|
return drm_ht_just_insert_please(&dev->map_hash, hash,
|
|
|
|
user_token, 32 - PAGE_SHIFT - 3,
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
shift, add);
|
2005-08-05 06:11:22 -06:00
|
|
|
}
|
drm: 32/64-bit DRM ioctl compatibility patch
The patch is against a 2.6.11 kernel tree. I am running this with a
32-bit X server (compiled up from X.org CVS as of a couple of weeks
ago) and 32-bit DRI libraries and clients. All the userland stuff is
identical to what I am using under a 32-bit kernel on my G4 powerbook
(which is a 32-bit machine of course). I haven't tried compiling up a
64-bit X server or clients yet.
In the compatibility routines I have assumed that the kernel can
safely access user addresses after set_fs(KERNEL_DS). That is, where
an ioctl argument structure contains pointers to other structures, and
those other structures are already compatible between the 32-bit and
64-bit ABIs (i.e. they only contain things like chars, shorts or
ints), I just check the address with access_ok() and then pass it
through to the 64-bit ioctl code. I believe this approach may not
work on sparc64, but it does work on ppc64 and x86_64 at least.
One tricky area which may need to be revisited is the question of how
to handle the handles which we pass back to userspace to identify
mappings. These handles are generated in the ADDMAP ioctl and then
passed in as the offset value to mmap. However, offset values for
mmap seem to be generated in other ways as well, particularly for AGP
mappings.
The approach I have ended up with is to generate a fake 32-bit handle
only for _DRM_SHM mappings. The handles for other mappings (AGP, REG,
FB) are physical addresses which are already limited to 32 bits, and
generating fake handles for them created all sorts of problems in the
mmap/nopage code.
This patch has been updated to use the new compatibility ioctls.
From: Paul Mackerras <paulus@samba.org>
Signed-off-by: Dave Airlie <airlied@linux.ie>
2005-06-23 05:29:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2009-02-01 22:55:46 -07:00
|
|
|
* Core function to create a range of memory available for mapping by a
|
|
|
|
* non-root process.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Adjusts the memory offset to its absolute value according to the mapping
|
|
|
|
* type. Adds the map to the map list drm_device::maplist. Adds MTRR's where
|
|
|
|
* applicable and if supported by the kernel.
|
|
|
|
*/
|
2018-03-18 18:52:22 -06:00
|
|
|
static int drm_addmap_core(struct drm_device *dev, resource_size_t offset,
|
2007-07-10 23:27:12 -06:00
|
|
|
unsigned int size, enum drm_map_type type,
|
2007-07-11 00:53:40 -06:00
|
|
|
enum drm_map_flags flags,
|
2018-03-18 18:52:22 -06:00
|
|
|
struct drm_map_list **maplist)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-02-01 22:55:46 -07:00
|
|
|
struct drm_local_map *map;
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *list;
|
2005-07-09 23:38:56 -06:00
|
|
|
drm_dma_handle_t *dmah;
|
2006-08-07 06:36:47 -06:00
|
|
|
unsigned long user_token;
|
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
map = kmalloc(sizeof(*map), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!map)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2005-07-10 00:56:52 -06:00
|
|
|
map->offset = offset;
|
|
|
|
map->size = size;
|
|
|
|
map->flags = flags;
|
|
|
|
map->type = type;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Only allow shared memory to be removable since we only keep enough
|
|
|
|
* book keeping information about shared memory to allow for removal
|
|
|
|
* when processes fork.
|
|
|
|
*/
|
2005-09-24 22:28:13 -06:00
|
|
|
if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-02-01 22:55:47 -07:00
|
|
|
DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n",
|
|
|
|
(unsigned long long)map->offset, map->size, map->type);
|
2009-05-17 19:56:16 -06:00
|
|
|
|
|
|
|
/* page-align _DRM_SHM maps. They are allocated here so there is no security
|
|
|
|
* hole created by that and it works around various broken drivers that use
|
|
|
|
* a non-aligned quantity to map the SAREA. --BenH
|
|
|
|
*/
|
|
|
|
if (map->type == _DRM_SHM)
|
|
|
|
map->size = PAGE_ALIGN(map->size);
|
|
|
|
|
2009-02-01 22:55:47 -07:00
|
|
|
if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
map->mtrr = -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
map->handle = NULL;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
switch (map->type) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case _DRM_REGISTERS:
|
|
|
|
case _DRM_FRAME_BUFFER:
|
2010-05-27 13:40:26 -06:00
|
|
|
#if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__) && !defined(__arm__)
|
2006-01-11 02:48:09 -07:00
|
|
|
if (map->offset + (map->size-1) < map->offset ||
|
2005-09-24 22:28:13 -06:00
|
|
|
map->offset < virt_to_phys(high_memory)) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
#endif
|
2005-07-10 03:27:04 -06:00
|
|
|
/* Some drivers preinitialize some maps, without the X Server
|
|
|
|
* needing to be aware of it. Therefore, we just return success
|
|
|
|
* when the server tries to create a duplicate map.
|
|
|
|
*/
|
2005-09-05 05:23:23 -06:00
|
|
|
list = drm_find_matching_map(dev, map);
|
|
|
|
if (list != NULL) {
|
|
|
|
if (list->map->size != map->size) {
|
2005-07-10 03:27:04 -06:00
|
|
|
DRM_DEBUG("Matching maps of type %d with "
|
2005-09-24 22:28:13 -06:00
|
|
|
"mismatched sizes, (%ld vs %ld)\n",
|
|
|
|
map->type, map->size,
|
|
|
|
list->map->size);
|
2005-09-05 05:23:23 -06:00
|
|
|
list->map->size = map->size;
|
2005-07-10 03:27:04 -06:00
|
|
|
}
|
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-09-05 05:23:23 -06:00
|
|
|
*maplist = list;
|
2005-07-10 03:27:04 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm: rip out drm_core_has_MTRR checks
The new arch_phys_wc_add/del functions do the right thing both with
and without MTRR support in the kernel. So we can drop these
additional checks.
David Herrmann suggest to also kill the DRIVER_USE_MTRR flag since
it's now unused, which spurred me to do a bit a better audit of the
affected drivers. David helped a lot in that. Quoting our mail
discussion:
On Wed, Jul 10, 2013 at 5:41 PM, David Herrmann <dh.herrmann@gmail.com> wrote:
> On Wed, Jul 10, 2013 at 5:22 PM, Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
>> On Wed, Jul 10, 2013 at 3:51 PM, David Herrmann <dh.herrmann@gmail.com> wrote:
>>>> -#if __OS_HAS_MTRR
>>>> -static inline int drm_core_has_MTRR(struct drm_device *dev)
>>>> -{
>>>> - return drm_core_check_feature(dev, DRIVER_USE_MTRR);
>>>> -}
>>>> -#else
>>>> -#define drm_core_has_MTRR(dev) (0)
>>>> -#endif
>>>> -
>>>
>>> That was the last user of DRIVER_USE_MTRR (apart from drivers setting
>>> it in .driver_features). Any reason to keep it around?
>>
>> Yeah, I guess we could rip things out. Which will also force me to
>> properly audit drivers for the eventual behaviour change this could
>> entail (in case there's an x86 driver which did not ask for an mtrr,
>> but iirc there isn't).
>
> david@david-mb ~/dev/kernel/linux $ for i in drivers/gpu/drm/* ; do if
> test -d "$i" ; then if ! grep -q USE_MTRR -r $i ; then echo $i ; fi ;
> fi ; done
> drivers/gpu/drm/exynos
> drivers/gpu/drm/gma500
> drivers/gpu/drm/i2c
> drivers/gpu/drm/nouveau
> drivers/gpu/drm/omapdrm
> drivers/gpu/drm/qxl
> drivers/gpu/drm/rcar-du
> drivers/gpu/drm/shmobile
> drivers/gpu/drm/tilcdc
> drivers/gpu/drm/ttm
> drivers/gpu/drm/udl
> drivers/gpu/drm/vmwgfx
> david@david-mb ~/dev/kernel/linux $
>
> So for x86 gma500,nouveau,qxl,udl,vmwgfx don't set DRIVER_USE_MTRR.
> But I cannot tell whether they break if we call arch_phys_wc_add/del,
> anyway. At least nouveau seemed to work here, but it doesn't use AGP
> or drm_bufs, I guess.
Cool, thanks a lot for stitching together the list of drivers to look
at. So for real KMS drivers it's the drives responsibility to add an
mtrr if it needs one. nouvea, radeon, mgag200, i915 and vmwgfx do that
already. Somehow the savage driver also ends up doing that, I have no
idea why.
Note that gma500 as a pure KMS driver doesn't need MTRR setup since
the platforms that it supports all support PAT. So no MTRRs needed to
get wc iomappings.
The mtrr support in the drm core is all for legacy mappings of garts,
framebuffers and registers. All legacy drivers set the USE_MTRR flag,
so we're good there.
All in all I think we can really just ditch this
/endquote
v2: Also kill DRIVER_USE_MTRR as suggested by David Herrmann
v3: Rebase on top of David Herrmann's agp setup/cleanup changes.
Cc: David Herrmann <dh.herrmann@gmail.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-08 07:41:27 -06:00
|
|
|
if (map->type == _DRM_FRAME_BUFFER ||
|
|
|
|
(map->flags & _DRM_WRITE_COMBINING)) {
|
|
|
|
map->mtrr =
|
|
|
|
arch_phys_wc_add(map->offset, map->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-08-25 02:17:49 -06:00
|
|
|
if (map->type == _DRM_REGISTERS) {
|
2013-05-13 17:58:42 -06:00
|
|
|
if (map->flags & _DRM_WRITE_COMBINING)
|
|
|
|
map->handle = ioremap_wc(map->offset,
|
|
|
|
map->size);
|
|
|
|
else
|
|
|
|
map->handle = ioremap(map->offset, map->size);
|
2007-08-25 02:17:49 -06:00
|
|
|
if (!map->handle) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2007-08-25 02:17:49 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
2007-11-04 19:50:58 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case _DRM_SHM:
|
2007-02-09 18:07:47 -07:00
|
|
|
list = drm_find_matching_map(dev, map);
|
|
|
|
if (list != NULL) {
|
2018-03-18 18:52:22 -06:00
|
|
|
if (list->map->size != map->size) {
|
2007-02-09 18:07:47 -07:00
|
|
|
DRM_DEBUG("Matching maps of type %d with "
|
|
|
|
"mismatched sizes, (%ld vs %ld)\n",
|
|
|
|
map->type, map->size, list->map->size);
|
|
|
|
list->map->size = map->size;
|
|
|
|
}
|
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2007-02-09 18:07:47 -07:00
|
|
|
*maplist = list;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-01-08 03:22:50 -07:00
|
|
|
map->handle = vmalloc_user(map->size);
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("%lu %d %p\n",
|
2013-07-10 06:11:57 -06:00
|
|
|
map->size, order_base_2(map->size), map->handle);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!map->handle) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
map->offset = (unsigned long)map->handle;
|
2005-09-24 22:28:13 -06:00
|
|
|
if (map->flags & _DRM_CONTAINS_LOCK) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Prevent a 2nd X Server from creating a 2nd lock */
|
2016-06-21 02:54:12 -06:00
|
|
|
if (dev->master->lock.hw_lock != NULL) {
|
2005-09-24 22:28:13 -06:00
|
|
|
vfree(map->handle);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2016-06-21 02:54:12 -06:00
|
|
|
dev->sigdata.lock = dev->master->lock.hw_lock = map->handle; /* Pointer to lock */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
2007-02-09 18:07:47 -07:00
|
|
|
case _DRM_AGP: {
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_agp_mem *entry;
|
2007-02-09 18:07:47 -07:00
|
|
|
int valid = 0;
|
|
|
|
|
2013-12-11 03:34:35 -07:00
|
|
|
if (!dev->agp) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2007-02-09 18:07:47 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef __alpha__
|
2007-02-09 18:07:47 -07:00
|
|
|
map->offset += dev->hose->mem_space->start;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-11-21 23:55:15 -07:00
|
|
|
/* In some cases (i810 driver), user space may have already
|
|
|
|
* added the AGP base itself, because dev->agp->base previously
|
|
|
|
* only got set during AGP enable. So, only add the base
|
|
|
|
* address if the map's offset isn't already within the
|
|
|
|
* aperture.
|
2007-02-09 18:07:47 -07:00
|
|
|
*/
|
2007-11-21 23:55:15 -07:00
|
|
|
if (map->offset < dev->agp->base ||
|
|
|
|
map->offset > dev->agp->base +
|
|
|
|
dev->agp->agp_info.aper_size * 1024 * 1024 - 1) {
|
|
|
|
map->offset += dev->agp->base;
|
|
|
|
}
|
2007-02-09 18:07:47 -07:00
|
|
|
map->mtrr = dev->agp->agp_mtrr; /* for getmap */
|
|
|
|
|
|
|
|
/* This assumes the DRM is in total control of AGP space.
|
|
|
|
* It's not always the case as AGP can be in the control
|
|
|
|
* of user space (i.e. i810 driver). So this loop will get
|
|
|
|
* skipped and we double check that dev->agp->memory is
|
|
|
|
* actually set as well as being invalid before EPERM'ing
|
|
|
|
*/
|
2007-05-25 13:01:51 -06:00
|
|
|
list_for_each_entry(entry, &dev->agp->memory, head) {
|
2007-02-09 18:07:47 -07:00
|
|
|
if ((map->offset >= entry->bound) &&
|
|
|
|
(map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {
|
|
|
|
valid = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-25 13:01:51 -06:00
|
|
|
if (!list_empty(&dev->agp->memory) && !valid) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2007-02-09 18:07:47 -07:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2009-02-01 22:55:47 -07:00
|
|
|
DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n",
|
|
|
|
(unsigned long long)map->offset, map->size);
|
2007-02-09 18:07:47 -07:00
|
|
|
|
2008-11-05 11:31:53 -07:00
|
|
|
break;
|
2009-09-17 13:59:54 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
case _DRM_SCATTER_GATHER:
|
|
|
|
if (!dev->sg) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-08-05 06:11:22 -06:00
|
|
|
map->offset += (unsigned long)dev->sg->virtual;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2005-09-24 22:28:13 -06:00
|
|
|
case _DRM_CONSISTENT:
|
2005-07-09 22:34:13 -06:00
|
|
|
/* dma_addr_t is 64bit on i386 with CONFIG_HIGHMEM64G,
|
2005-07-09 23:38:56 -06:00
|
|
|
* As we're limiting the address to 2^32-1 (or less),
|
2005-07-09 22:34:13 -06:00
|
|
|
* casting it down to 32 bits is no problem, but we
|
|
|
|
* need to point to a 64bit variable first. */
|
2010-01-04 20:25:05 -07:00
|
|
|
dmah = drm_pci_alloc(dev, map->size, map->size);
|
2005-07-09 23:38:56 -06:00
|
|
|
if (!dmah) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-07-09 22:34:13 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-07-09 23:38:56 -06:00
|
|
|
map->handle = dmah->vaddr;
|
|
|
|
map->offset = (unsigned long)dmah->busaddr;
|
|
|
|
kfree(dmah);
|
2005-07-09 22:34:13 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-08-11 07:18:52 -06:00
|
|
|
list = kzalloc(sizeof(*list), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!list) {
|
2006-10-25 10:55:34 -06:00
|
|
|
if (map->type == _DRM_REGISTERS)
|
2007-01-08 03:56:59 -07:00
|
|
|
iounmap(map->handle);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
list->map = map;
|
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2007-05-25 13:01:51 -06:00
|
|
|
list_add(&list->head, &dev->maplist);
|
2006-08-07 06:36:47 -06:00
|
|
|
|
2005-08-05 06:11:22 -06:00
|
|
|
/* Assign a 32-bit handle */
|
2006-02-02 01:37:46 -07:00
|
|
|
/* We do it here so that dev->struct_mutex protects the increment */
|
2006-08-07 06:36:47 -06:00
|
|
|
user_token = (map->type == _DRM_SHM) ? (unsigned long)map->handle :
|
|
|
|
map->offset;
|
drm: Preserve SHMLBA bits in hash key for _DRM_SHM mappings.
Platforms such as sparc64 have D-cache aliasing issues. We
cannot allow virtual mappings in different contexts to be such
that two cache lines can be loaded for the same backing data.
Updates to one cache line won't be seen by accesses to the other
cache line.
Code in sparc64 and other architectures solve this problem by
making sure that all userland mappings of MAP_SHARED objects have
the same virtual address base. They implement this by keying
off of the page offset, and using that to choose a suitably
consistent virtual address for mmap() requests.
Making things even worse, getting this wrong on sparc64 can result
in hangs during DRM lock acquisition. This is because, at least on
UltraSPARC-III, normal loads consult the D-cache but atomics such
as 'cas' (which is what cmpxchg() is implement using) only consult
the L2 cache. So if a D-cache alias is inserted, the load can
see different data than the atomic, and we'll loop forever because
the atomic compare-and-exchange will never complete successfully.
So to make this all work properly, we need to make sure that the
hash address computed by drm_map_handle() preserves the SHMLBA
relevant bits, and that's what this patch does for _DRM_SHM mappings.
As a historical note, many years ago this bug didn't exist because we
used to just use the low 32-bits of the address as the hash and just
hope for the best. This preserved the SHMLBA bits properly. But when
the hashtab code was added to DRM, this was no longer the case.
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-02-18 16:41:02 -07:00
|
|
|
ret = drm_map_handle(dev, &list->hash, user_token, 0,
|
|
|
|
(map->type == _DRM_SHM));
|
2006-08-07 06:36:47 -06:00
|
|
|
if (ret) {
|
2006-10-25 10:55:34 -06:00
|
|
|
if (map->type == _DRM_REGISTERS)
|
2007-01-08 03:56:59 -07:00
|
|
|
iounmap(map->handle);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
|
|
|
kfree(list);
|
2006-08-07 06:36:47 -06:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-02-07 22:14:05 -07:00
|
|
|
list->user_token = list->hash.key << PAGE_SHIFT;
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-05-25 18:35:52 -06:00
|
|
|
if (!(map->flags & _DRM_DRIVER))
|
2016-06-21 02:54:12 -06:00
|
|
|
list->master = dev->master;
|
2005-09-05 05:23:23 -06:00
|
|
|
*maplist = list;
|
2005-07-10 00:56:52 -06:00
|
|
|
return 0;
|
2014-04-29 03:44:38 -06:00
|
|
|
}
|
2005-09-05 05:23:23 -06:00
|
|
|
|
2018-03-18 18:52:22 -06:00
|
|
|
int drm_legacy_addmap(struct drm_device *dev, resource_size_t offset,
|
2014-08-29 04:12:28 -06:00
|
|
|
unsigned int size, enum drm_map_type type,
|
|
|
|
enum drm_map_flags flags, struct drm_local_map **map_ptr)
|
2005-09-05 05:23:23 -06:00
|
|
|
{
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *list;
|
2005-09-05 05:23:23 -06:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = drm_addmap_core(dev, offset, size, type, flags, &list);
|
|
|
|
if (!rc)
|
|
|
|
*map_ptr = list->map;
|
|
|
|
return rc;
|
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_addmap);
|
2005-07-10 00:56:52 -06:00
|
|
|
|
2009-02-01 22:55:46 -07:00
|
|
|
/**
|
|
|
|
* Ioctl to specify a range of memory that is available for mapping by a
|
|
|
|
* non-root process.
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
|
|
|
* \param file_priv DRM file private.
|
|
|
|
* \param cmd command.
|
|
|
|
* \param arg pointer to a drm_map structure.
|
|
|
|
* \return zero on success or a negative value on error.
|
|
|
|
*
|
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_addmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
2005-07-10 00:56:52 -06:00
|
|
|
{
|
2007-09-02 20:06:45 -06:00
|
|
|
struct drm_map *map = data;
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *maplist;
|
2005-07-10 00:56:52 -06:00
|
|
|
int err;
|
|
|
|
|
2008-11-27 21:22:24 -07:00
|
|
|
if (!(capable(CAP_SYS_ADMIN) || map->type == _DRM_AGP || map->type == _DRM_SHM))
|
2006-01-02 03:32:48 -07:00
|
|
|
return -EPERM;
|
|
|
|
|
2016-04-26 11:29:37 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
|
2016-08-03 13:11:10 -06:00
|
|
|
!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2016-04-26 11:29:37 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2007-09-02 20:06:45 -06:00
|
|
|
err = drm_addmap_core(dev, map->offset, map->size, map->type,
|
|
|
|
map->flags, &maplist);
|
2005-07-10 00:56:52 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (err)
|
2005-07-10 00:56:52 -06:00
|
|
|
return err;
|
2005-08-05 06:11:22 -06:00
|
|
|
|
2005-10-24 02:41:39 -06:00
|
|
|
/* avoid a warning on 64-bit, this casting isn't very nice, but the API is set so too late */
|
2007-09-02 20:06:45 -06:00
|
|
|
map->handle = (void *)(unsigned long)maplist->user_token;
|
2013-05-13 17:58:48 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It appears that there are no users of this value whatsoever --
|
|
|
|
* drmAddMap just discards it. Let's not encourage its use.
|
|
|
|
* (Keeping drm_addmap_core's returned mtrr value would be wrong --
|
|
|
|
* it's not a real mtrr index anymore.)
|
|
|
|
*/
|
|
|
|
map->mtrr = -1;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2005-08-20 01:43:33 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-04-26 11:29:36 -06:00
|
|
|
/*
|
|
|
|
* Get a mapping information.
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
|
|
|
* \param file_priv DRM file private.
|
|
|
|
* \param cmd command.
|
|
|
|
* \param arg user argument, pointing to a drm_map structure.
|
|
|
|
*
|
|
|
|
* \return zero on success or a negative number on failure.
|
|
|
|
*
|
|
|
|
* Searches for the mapping with the specified offset and copies its information
|
|
|
|
* into userspace
|
|
|
|
*/
|
|
|
|
int drm_legacy_getmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_map *map = data;
|
|
|
|
struct drm_map_list *r_list = NULL;
|
|
|
|
struct list_head *list;
|
|
|
|
int idx;
|
|
|
|
int i;
|
|
|
|
|
2016-04-26 11:29:37 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
|
2016-08-03 13:11:10 -06:00
|
|
|
!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2016-04-26 11:29:37 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-26 11:29:36 -06:00
|
|
|
idx = map->offset;
|
|
|
|
if (idx < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
list_for_each(list, &dev->maplist) {
|
|
|
|
if (i == idx) {
|
|
|
|
r_list = list_entry(list, struct drm_map_list, head);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (!r_list || !r_list->map) {
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
map->offset = r_list->map->offset;
|
|
|
|
map->size = r_list->map->size;
|
|
|
|
map->type = r_list->map->type;
|
|
|
|
map->flags = r_list->map->flags;
|
|
|
|
map->handle = (void *)(unsigned long) r_list->user_token;
|
|
|
|
map->mtrr = arch_phys_wc_index(r_list->map->mtrr);
|
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* Remove a map private from list and deallocate resources if the mapping
|
|
|
|
* isn't in use.
|
|
|
|
*
|
|
|
|
* Searches the map on drm_device::maplist, removes it from the list, see if
|
|
|
|
* its being used, and free any associate resource (such as MTRR's) if it's not
|
|
|
|
* being on use.
|
|
|
|
*
|
2014-08-29 04:12:28 -06:00
|
|
|
* \sa drm_legacy_addmap
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *r_list = NULL, *list_t;
|
2005-07-10 03:27:04 -06:00
|
|
|
drm_dma_handle_t dmah;
|
2007-05-25 13:01:51 -06:00
|
|
|
int found = 0;
|
2008-11-27 21:22:24 -07:00
|
|
|
struct drm_master *master;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-10 03:27:04 -06:00
|
|
|
/* Find the list entry for the map and remove it */
|
2007-05-25 13:01:51 -06:00
|
|
|
list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
|
2005-07-10 03:27:04 -06:00
|
|
|
if (r_list->map == map) {
|
2008-11-27 21:22:24 -07:00
|
|
|
master = r_list->master;
|
2007-05-25 13:01:51 -06:00
|
|
|
list_del(&r_list->head);
|
2007-02-07 22:14:05 -07:00
|
|
|
drm_ht_remove_key(&dev->map_hash,
|
|
|
|
r_list->user_token >> PAGE_SHIFT);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(r_list);
|
2007-05-25 13:01:51 -06:00
|
|
|
found = 1;
|
2005-07-10 03:27:04 -06:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-25 13:01:51 -06:00
|
|
|
if (!found)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-07-10 03:27:04 -06:00
|
|
|
switch (map->type) {
|
|
|
|
case _DRM_REGISTERS:
|
2007-01-08 03:56:59 -07:00
|
|
|
iounmap(map->handle);
|
2005-07-10 03:27:04 -06:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
case _DRM_FRAME_BUFFER:
|
drm: rip out drm_core_has_MTRR checks
The new arch_phys_wc_add/del functions do the right thing both with
and without MTRR support in the kernel. So we can drop these
additional checks.
David Herrmann suggest to also kill the DRIVER_USE_MTRR flag since
it's now unused, which spurred me to do a bit a better audit of the
affected drivers. David helped a lot in that. Quoting our mail
discussion:
On Wed, Jul 10, 2013 at 5:41 PM, David Herrmann <dh.herrmann@gmail.com> wrote:
> On Wed, Jul 10, 2013 at 5:22 PM, Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
>> On Wed, Jul 10, 2013 at 3:51 PM, David Herrmann <dh.herrmann@gmail.com> wrote:
>>>> -#if __OS_HAS_MTRR
>>>> -static inline int drm_core_has_MTRR(struct drm_device *dev)
>>>> -{
>>>> - return drm_core_check_feature(dev, DRIVER_USE_MTRR);
>>>> -}
>>>> -#else
>>>> -#define drm_core_has_MTRR(dev) (0)
>>>> -#endif
>>>> -
>>>
>>> That was the last user of DRIVER_USE_MTRR (apart from drivers setting
>>> it in .driver_features). Any reason to keep it around?
>>
>> Yeah, I guess we could rip things out. Which will also force me to
>> properly audit drivers for the eventual behaviour change this could
>> entail (in case there's an x86 driver which did not ask for an mtrr,
>> but iirc there isn't).
>
> david@david-mb ~/dev/kernel/linux $ for i in drivers/gpu/drm/* ; do if
> test -d "$i" ; then if ! grep -q USE_MTRR -r $i ; then echo $i ; fi ;
> fi ; done
> drivers/gpu/drm/exynos
> drivers/gpu/drm/gma500
> drivers/gpu/drm/i2c
> drivers/gpu/drm/nouveau
> drivers/gpu/drm/omapdrm
> drivers/gpu/drm/qxl
> drivers/gpu/drm/rcar-du
> drivers/gpu/drm/shmobile
> drivers/gpu/drm/tilcdc
> drivers/gpu/drm/ttm
> drivers/gpu/drm/udl
> drivers/gpu/drm/vmwgfx
> david@david-mb ~/dev/kernel/linux $
>
> So for x86 gma500,nouveau,qxl,udl,vmwgfx don't set DRIVER_USE_MTRR.
> But I cannot tell whether they break if we call arch_phys_wc_add/del,
> anyway. At least nouveau seemed to work here, but it doesn't use AGP
> or drm_bufs, I guess.
Cool, thanks a lot for stitching together the list of drivers to look
at. So for real KMS drivers it's the drives responsibility to add an
mtrr if it needs one. nouvea, radeon, mgag200, i915 and vmwgfx do that
already. Somehow the savage driver also ends up doing that, I have no
idea why.
Note that gma500 as a pure KMS driver doesn't need MTRR setup since
the platforms that it supports all support PAT. So no MTRRs needed to
get wc iomappings.
The mtrr support in the drm core is all for legacy mappings of garts,
framebuffers and registers. All legacy drivers set the USE_MTRR flag,
so we're good there.
All in all I think we can really just ditch this
/endquote
v2: Also kill DRIVER_USE_MTRR as suggested by David Herrmann
v3: Rebase on top of David Herrmann's agp setup/cleanup changes.
Cc: David Herrmann <dh.herrmann@gmail.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-08 07:41:27 -06:00
|
|
|
arch_phys_wc_del(map->mtrr);
|
2005-07-10 03:27:04 -06:00
|
|
|
break;
|
|
|
|
case _DRM_SHM:
|
|
|
|
vfree(map->handle);
|
2008-11-27 21:22:24 -07:00
|
|
|
if (master) {
|
|
|
|
if (dev->sigdata.lock == master->lock.hw_lock)
|
|
|
|
dev->sigdata.lock = NULL;
|
|
|
|
master->lock.hw_lock = NULL; /* SHM removed */
|
|
|
|
master->lock.file_priv = NULL;
|
2009-03-02 03:10:55 -07:00
|
|
|
wake_up_interruptible_all(&master->lock.lock_queue);
|
2008-11-27 21:22:24 -07:00
|
|
|
}
|
2005-07-10 03:27:04 -06:00
|
|
|
break;
|
|
|
|
case _DRM_AGP:
|
|
|
|
case _DRM_SCATTER_GATHER:
|
|
|
|
break;
|
|
|
|
case _DRM_CONSISTENT:
|
|
|
|
dmah.vaddr = map->handle;
|
|
|
|
dmah.busaddr = map->offset;
|
|
|
|
dmah.size = map->size;
|
2014-09-10 04:43:51 -06:00
|
|
|
__drm_legacy_pci_free(dev, &dmah);
|
2005-07-10 03:27:04 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(map);
|
2005-07-10 03:27:04 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_rmmap_locked);
|
2005-07-10 03:27:04 -06:00
|
|
|
|
2016-04-27 01:20:18 -06:00
|
|
|
void drm_legacy_rmmap(struct drm_device *dev, struct drm_local_map *map)
|
2005-07-10 03:27:04 -06:00
|
|
|
{
|
2016-04-27 01:20:18 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
|
2016-08-03 13:11:10 -06:00
|
|
|
!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2016-04-27 01:20:18 -06:00
|
|
|
return;
|
2005-07-10 03:27:04 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2016-04-27 01:20:18 -06:00
|
|
|
drm_legacy_rmmap_locked(dev, map);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-07-10 03:27:04 -06:00
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_rmmap);
|
2005-07-10 00:56:52 -06:00
|
|
|
|
2016-04-27 01:20:18 -06:00
|
|
|
void drm_legacy_master_rmmaps(struct drm_device *dev, struct drm_master *master)
|
|
|
|
{
|
|
|
|
struct drm_map_list *r_list, *list_temp;
|
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2016-04-27 01:20:18 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
|
|
|
|
if (r_list->master == master) {
|
|
|
|
drm_legacy_rmmap_locked(dev, r_list->map);
|
|
|
|
r_list = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
}
|
|
|
|
|
2005-07-10 03:27:04 -06:00
|
|
|
/* The rmmap ioctl appears to be unnecessary. All mappings are torn down on
|
|
|
|
* the last close of the device, and this is necessary for cleanup when things
|
|
|
|
* exit uncleanly. Therefore, having userland manually remove mappings seems
|
|
|
|
* like a pointless exercise since they're going away anyway.
|
|
|
|
*
|
|
|
|
* One use case might be after addmap is allowed for normal users for SHM and
|
|
|
|
* gets used by drivers that the server doesn't need to care about. This seems
|
|
|
|
* unlikely.
|
2009-02-01 22:55:46 -07:00
|
|
|
*
|
|
|
|
* \param inode device inode.
|
|
|
|
* \param file_priv DRM file private.
|
|
|
|
* \param cmd command.
|
|
|
|
* \param arg pointer to a struct drm_map structure.
|
|
|
|
* \return zero on success or a negative value on error.
|
2005-07-10 03:27:04 -06:00
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_rmmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
2005-07-10 00:56:52 -06:00
|
|
|
{
|
2007-09-02 20:06:45 -06:00
|
|
|
struct drm_map *request = data;
|
2009-02-01 22:55:46 -07:00
|
|
|
struct drm_local_map *map = NULL;
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_map_list *r_list;
|
2005-07-10 03:27:04 -06:00
|
|
|
int ret;
|
2005-07-10 00:56:52 -06:00
|
|
|
|
2016-04-26 11:29:37 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
|
2016-08-03 13:11:10 -06:00
|
|
|
!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2016-04-26 11:29:37 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2007-05-25 13:01:51 -06:00
|
|
|
list_for_each_entry(r_list, &dev->maplist, head) {
|
2005-07-10 03:27:04 -06:00
|
|
|
if (r_list->map &&
|
2007-09-02 20:06:45 -06:00
|
|
|
r_list->user_token == (unsigned long)request->handle &&
|
2005-07-10 03:27:04 -06:00
|
|
|
r_list->map->flags & _DRM_REMOVABLE) {
|
|
|
|
map = r_list->map;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* List has wrapped around to the head pointer, or its empty we didn't
|
|
|
|
* find anything.
|
|
|
|
*/
|
2007-05-25 13:01:51 -06:00
|
|
|
if (list_empty(&dev->maplist) || !map) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-07-10 03:27:04 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register and framebuffer maps are permanent */
|
|
|
|
if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-07-10 03:27:04 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-29 04:12:28 -06:00
|
|
|
ret = drm_legacy_rmmap_locked(dev, map);
|
2005-07-10 03:27:04 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-07-10 03:27:04 -06:00
|
|
|
|
|
|
|
return ret;
|
2005-07-10 00:56:52 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Cleanup after an error on one of the addbufs() functions.
|
|
|
|
*
|
2005-07-10 03:27:04 -06:00
|
|
|
* \param dev DRM device.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param entry buffer entry where the error occurred.
|
|
|
|
*
|
|
|
|
* Frees any pages and buffers associated with the given entry.
|
|
|
|
*/
|
2018-03-18 18:52:22 -06:00
|
|
|
static void drm_cleanup_buf_error(struct drm_device *dev,
|
|
|
|
struct drm_buf_entry *entry)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (entry->seg_count) {
|
|
|
|
for (i = 0; i < entry->seg_count; i++) {
|
|
|
|
if (entry->seglist[i]) {
|
2006-03-19 00:56:12 -07:00
|
|
|
drm_pci_free(dev, entry->seglist[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(entry->seglist);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
entry->seg_count = 0;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (entry->buf_count) {
|
|
|
|
for (i = 0; i < entry->buf_count; i++) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(entry->buflist[i].dev_private);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(entry->buflist);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
entry->buf_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-09 08:45:52 -06:00
|
|
|
#if IS_ENABLED(CONFIG_AGP)
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2005-07-09 23:00:06 -06:00
|
|
|
* Add AGP buffers for DMA transfers.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-07-10 23:53:27 -06:00
|
|
|
* \param dev struct drm_device to which the buffers are to be added.
|
2007-07-10 23:27:12 -06:00
|
|
|
* \param request pointer to a struct drm_buf_desc describing the request.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \return zero on success or a negative number on failure.
|
2005-09-24 22:28:13 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* After some sanity checks creates a drm_buf structure for each buffer and
|
|
|
|
* reallocates the buffer list of the same size order to accommodate the new
|
|
|
|
* buffers.
|
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_addbufs_agp(struct drm_device *dev,
|
|
|
|
struct drm_buf_desc *request)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
|
|
|
struct drm_buf_entry *entry;
|
2007-07-11 00:53:40 -06:00
|
|
|
struct drm_agp_mem *agp_entry;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf *buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long offset;
|
|
|
|
unsigned long agp_offset;
|
|
|
|
int count;
|
|
|
|
int order;
|
|
|
|
int size;
|
|
|
|
int alignment;
|
|
|
|
int page_order;
|
|
|
|
int total;
|
|
|
|
int byte_count;
|
2007-02-09 18:07:47 -07:00
|
|
|
int i, valid;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf **temp_buflist;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
count = request->count;
|
2013-07-10 06:11:57 -06:00
|
|
|
order = order_base_2(request->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
size = 1 << order;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
alignment = (request->flags & _DRM_PAGE_ALIGN)
|
|
|
|
? PAGE_ALIGN(size) : size;
|
2005-04-16 16:20:36 -06:00
|
|
|
page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
|
|
|
|
total = PAGE_SIZE << page_order;
|
|
|
|
|
|
|
|
byte_count = 0;
|
2005-07-09 23:00:06 -06:00
|
|
|
agp_offset = dev->agp->base + request->agp_start;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("count: %d\n", count);
|
|
|
|
DRM_DEBUG("order: %d\n", order);
|
|
|
|
DRM_DEBUG("size: %d\n", size);
|
2006-01-02 03:32:48 -07:00
|
|
|
DRM_DEBUG("agp_offset: %lx\n", agp_offset);
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("alignment: %d\n", alignment);
|
|
|
|
DRM_DEBUG("page_order: %d\n", page_order);
|
|
|
|
DRM_DEBUG("total: %d\n", total);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-09 18:07:47 -07:00
|
|
|
/* Make sure buffers are located in AGP memory that we own */
|
|
|
|
valid = 0;
|
2007-05-25 13:01:51 -06:00
|
|
|
list_for_each_entry(agp_entry, &dev->agp->memory, head) {
|
2007-02-09 18:07:47 -07:00
|
|
|
if ((agp_offset >= agp_entry->bound) &&
|
|
|
|
(agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
|
|
|
|
valid = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-05-25 13:01:51 -06:00
|
|
|
if (!list_empty(&dev->agp->memory) && !valid) {
|
2007-02-09 18:07:47 -07:00
|
|
|
DRM_DEBUG("zone invalid\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_lock(&dev->buf_lock);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (dev->buf_use) {
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_inc(&dev->buf_alloc);
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry = &dma->bufs[order];
|
2005-09-24 22:28:13 -06:00
|
|
|
if (entry->buf_count) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
|
|
|
return -ENOMEM; /* May only call once for each order */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count < 0 || count > 4096) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-09-19 09:24:20 -06:00
|
|
|
entry->buflist = kcalloc(count, sizeof(*entry->buflist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!entry->buflist) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->buf_size = size;
|
|
|
|
entry->page_order = page_order;
|
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
while (entry->buf_count < count) {
|
|
|
|
buf = &entry->buflist[entry->buf_count];
|
|
|
|
buf->idx = dma->buf_count + entry->buf_count;
|
|
|
|
buf->total = alignment;
|
|
|
|
buf->order = order;
|
|
|
|
buf->used = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->offset = (dma->byte_count + offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->bus_address = agp_offset + offset;
|
|
|
|
buf->address = (void *)(agp_offset + offset);
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->next = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->waiting = 0;
|
|
|
|
buf->pending = 0;
|
2007-08-25 04:23:09 -06:00
|
|
|
buf->file_priv = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
buf->dev_priv_size = dev->driver->dev_priv_size;
|
2010-08-11 07:18:52 -06:00
|
|
|
buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!buf->dev_private) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Set count correctly so we free the proper amount. */
|
|
|
|
entry->buf_count = count;
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
offset += alignment;
|
|
|
|
entry->buf_count++;
|
|
|
|
byte_count += PAGE_SIZE << page_order;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("byte_count: %d\n", byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
temp_buflist = krealloc(dma->buflist,
|
|
|
|
(dma->buf_count + entry->buf_count) *
|
|
|
|
sizeof(*dma->buflist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!temp_buflist) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Free the entry because it isn't valid */
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
dma->buflist = temp_buflist;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0; i < entry->buf_count; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dma->buflist[i + dma->buf_count] = &entry->buflist[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
dma->buf_count += entry->buf_count;
|
2006-01-02 03:32:48 -07:00
|
|
|
dma->seg_count += entry->seg_count;
|
|
|
|
dma->page_count += byte_count >> PAGE_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
dma->byte_count += byte_count;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
|
|
|
|
DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
request->count = entry->buf_count;
|
|
|
|
request->size = size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dma->flags = _DRM_DMA_USE_AGP;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_addbufs_agp);
|
2015-09-09 08:45:52 -06:00
|
|
|
#endif /* CONFIG_AGP */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_addbufs_pci(struct drm_device *dev,
|
|
|
|
struct drm_buf_desc *request)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
2005-04-16 16:20:36 -06:00
|
|
|
int count;
|
|
|
|
int order;
|
|
|
|
int size;
|
|
|
|
int total;
|
|
|
|
int page_order;
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_buf_entry *entry;
|
2006-03-19 00:56:12 -07:00
|
|
|
drm_dma_handle_t *dmah;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf *buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
int alignment;
|
|
|
|
unsigned long offset;
|
|
|
|
int i;
|
|
|
|
int byte_count;
|
|
|
|
int page_count;
|
|
|
|
unsigned long *temp_pagelist;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf **temp_buflist;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_PCI_DMA))
|
|
|
|
return -EINVAL;
|
2006-01-02 03:32:48 -07:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-02 03:32:48 -07:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
count = request->count;
|
2013-07-10 06:11:57 -06:00
|
|
|
order = order_base_2(request->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
size = 1 << order;
|
|
|
|
|
2011-10-25 16:54:41 -06:00
|
|
|
DRM_DEBUG("count=%d, size=%d (%d), order=%d\n",
|
|
|
|
request->count, request->size, size, order);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
alignment = (request->flags & _DRM_PAGE_ALIGN)
|
2005-09-24 22:28:13 -06:00
|
|
|
? PAGE_ALIGN(size) : size;
|
2005-04-16 16:20:36 -06:00
|
|
|
page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
|
|
|
|
total = PAGE_SIZE << page_order;
|
|
|
|
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_lock(&dev->buf_lock);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (dev->buf_use) {
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_inc(&dev->buf_alloc);
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry = &dma->bufs[order];
|
2005-09-24 22:28:13 -06:00
|
|
|
if (entry->buf_count) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM; /* May only call once for each order */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (count < 0 || count > 4096) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-09-19 09:17:34 -06:00
|
|
|
entry->buflist = kcalloc(count, sizeof(*entry->buflist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!entry->buflist) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
|
2016-09-19 09:17:34 -06:00
|
|
|
entry->seglist = kcalloc(count, sizeof(*entry->seglist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!entry->seglist) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(entry->buflist);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Keep the original pagelist until we know all the allocations
|
|
|
|
* have succeeded
|
|
|
|
*/
|
2016-09-19 09:07:06 -06:00
|
|
|
temp_pagelist = kmalloc_array(dma->page_count + (count << page_order),
|
|
|
|
sizeof(*dma->pagelist),
|
|
|
|
GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!temp_pagelist) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(entry->buflist);
|
|
|
|
kfree(entry->seglist);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
memcpy(temp_pagelist,
|
2005-09-24 22:28:13 -06:00
|
|
|
dma->pagelist, dma->page_count * sizeof(*dma->pagelist));
|
|
|
|
DRM_DEBUG("pagelist: %d entries\n",
|
|
|
|
dma->page_count + (count << page_order));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
entry->buf_size = size;
|
2005-04-16 16:20:36 -06:00
|
|
|
entry->page_order = page_order;
|
|
|
|
byte_count = 0;
|
|
|
|
page_count = 0;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
while (entry->buf_count < count) {
|
2007-11-04 19:50:58 -07:00
|
|
|
|
2010-01-04 20:25:05 -07:00
|
|
|
dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000);
|
2007-11-04 19:50:58 -07:00
|
|
|
|
2006-03-19 00:56:12 -07:00
|
|
|
if (!dmah) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Set count correctly so we free the proper amount. */
|
|
|
|
entry->buf_count = count;
|
|
|
|
entry->seg_count = count;
|
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(temp_pagelist);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2006-03-19 00:56:12 -07:00
|
|
|
entry->seglist[entry->seg_count++] = dmah;
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0; i < (1 << page_order); i++) {
|
|
|
|
DRM_DEBUG("page %d @ 0x%08lx\n",
|
|
|
|
dma->page_count + page_count,
|
2006-03-19 00:56:12 -07:00
|
|
|
(unsigned long)dmah->vaddr + PAGE_SIZE * i);
|
2005-04-16 16:20:36 -06:00
|
|
|
temp_pagelist[dma->page_count + page_count++]
|
2006-03-19 00:56:12 -07:00
|
|
|
= (unsigned long)dmah->vaddr + PAGE_SIZE * i;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
for (offset = 0;
|
|
|
|
offset + size <= total && entry->buf_count < count;
|
|
|
|
offset += alignment, ++entry->buf_count) {
|
|
|
|
buf = &entry->buflist[entry->buf_count];
|
|
|
|
buf->idx = dma->buf_count + entry->buf_count;
|
|
|
|
buf->total = alignment;
|
|
|
|
buf->order = order;
|
|
|
|
buf->used = 0;
|
|
|
|
buf->offset = (dma->byte_count + byte_count + offset);
|
2006-03-19 00:56:12 -07:00
|
|
|
buf->address = (void *)(dmah->vaddr + offset);
|
|
|
|
buf->bus_address = dmah->busaddr + offset;
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->next = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->waiting = 0;
|
|
|
|
buf->pending = 0;
|
2007-08-25 04:23:09 -06:00
|
|
|
buf->file_priv = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
buf->dev_priv_size = dev->driver->dev_priv_size;
|
2010-08-11 07:18:52 -06:00
|
|
|
buf->dev_private = kzalloc(buf->dev_priv_size,
|
|
|
|
GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!buf->dev_private) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Set count correctly so we free the proper amount. */
|
|
|
|
entry->buf_count = count;
|
|
|
|
entry->seg_count = count;
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(temp_pagelist);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("buffer %d @ %p\n",
|
|
|
|
entry->buf_count, buf->address);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
byte_count += PAGE_SIZE << page_order;
|
|
|
|
}
|
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
temp_buflist = krealloc(dma->buflist,
|
|
|
|
(dma->buf_count + entry->buf_count) *
|
|
|
|
sizeof(*dma->buflist), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!temp_buflist) {
|
|
|
|
/* Free the entry because it isn't valid */
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(temp_pagelist);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
dma->buflist = temp_buflist;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0; i < entry->buf_count; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dma->buflist[i + dma->buf_count] = &entry->buflist[i];
|
|
|
|
}
|
|
|
|
|
2010-03-16 04:47:56 -06:00
|
|
|
/* No allocations failed, so now we can replace the original pagelist
|
2005-04-16 16:20:36 -06:00
|
|
|
* with the new one.
|
|
|
|
*/
|
|
|
|
if (dma->page_count) {
|
2009-03-24 13:23:04 -06:00
|
|
|
kfree(dma->pagelist);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
dma->pagelist = temp_pagelist;
|
|
|
|
|
|
|
|
dma->buf_count += entry->buf_count;
|
|
|
|
dma->seg_count += entry->seg_count;
|
|
|
|
dma->page_count += entry->seg_count << page_order;
|
|
|
|
dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
|
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
request->count = entry->buf_count;
|
|
|
|
request->size = size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-24 13:03:04 -06:00
|
|
|
if (request->flags & _DRM_PCI_BUFFER_RO)
|
|
|
|
dma->flags = _DRM_DMA_USE_PCI_RO;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_addbufs_pci);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-08-29 04:12:28 -06:00
|
|
|
static int drm_legacy_addbufs_sg(struct drm_device *dev,
|
|
|
|
struct drm_buf_desc *request)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
|
|
|
struct drm_buf_entry *entry;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf *buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long offset;
|
|
|
|
unsigned long agp_offset;
|
|
|
|
int count;
|
|
|
|
int order;
|
|
|
|
int size;
|
|
|
|
int alignment;
|
|
|
|
int page_order;
|
|
|
|
int total;
|
|
|
|
int byte_count;
|
|
|
|
int i;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf **temp_buflist;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_SG))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-02 03:32:48 -07:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
count = request->count;
|
2013-07-10 06:11:57 -06:00
|
|
|
order = order_base_2(request->size);
|
2005-04-16 16:20:36 -06:00
|
|
|
size = 1 << order;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
alignment = (request->flags & _DRM_PAGE_ALIGN)
|
|
|
|
? PAGE_ALIGN(size) : size;
|
2005-04-16 16:20:36 -06:00
|
|
|
page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
|
|
|
|
total = PAGE_SIZE << page_order;
|
|
|
|
|
|
|
|
byte_count = 0;
|
2005-07-09 23:00:06 -06:00
|
|
|
agp_offset = request->agp_start;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("count: %d\n", count);
|
|
|
|
DRM_DEBUG("order: %d\n", order);
|
|
|
|
DRM_DEBUG("size: %d\n", size);
|
|
|
|
DRM_DEBUG("agp_offset: %lu\n", agp_offset);
|
|
|
|
DRM_DEBUG("alignment: %d\n", alignment);
|
|
|
|
DRM_DEBUG("page_order: %d\n", page_order);
|
|
|
|
DRM_DEBUG("total: %d\n", total);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_lock(&dev->buf_lock);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (dev->buf_use) {
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_inc(&dev->buf_alloc);
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
entry = &dma->bufs[order];
|
2005-09-24 22:28:13 -06:00
|
|
|
if (entry->buf_count) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
|
|
|
return -ENOMEM; /* May only call once for each order */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count < 0 || count > 4096) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-09-19 09:30:31 -06:00
|
|
|
entry->buflist = kcalloc(count, sizeof(*entry->buflist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!entry->buflist) {
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->buf_size = size;
|
|
|
|
entry->page_order = page_order;
|
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
while (entry->buf_count < count) {
|
|
|
|
buf = &entry->buflist[entry->buf_count];
|
|
|
|
buf->idx = dma->buf_count + entry->buf_count;
|
|
|
|
buf->total = alignment;
|
|
|
|
buf->order = order;
|
|
|
|
buf->used = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->offset = (dma->byte_count + offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->bus_address = agp_offset + offset;
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->address = (void *)(agp_offset + offset
|
2005-08-05 06:11:22 -06:00
|
|
|
+ (unsigned long)dev->sg->virtual);
|
2005-09-24 22:28:13 -06:00
|
|
|
buf->next = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->waiting = 0;
|
|
|
|
buf->pending = 0;
|
2007-08-25 04:23:09 -06:00
|
|
|
buf->file_priv = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
buf->dev_priv_size = dev->driver->dev_priv_size;
|
2010-08-11 07:18:52 -06:00
|
|
|
buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!buf->dev_private) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Set count correctly so we free the proper amount. */
|
|
|
|
entry->buf_count = count;
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
offset += alignment;
|
|
|
|
entry->buf_count++;
|
|
|
|
byte_count += PAGE_SIZE << page_order;
|
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("byte_count: %d\n", byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-24 13:23:04 -06:00
|
|
|
temp_buflist = krealloc(dma->buflist,
|
|
|
|
(dma->buf_count + entry->buf_count) *
|
|
|
|
sizeof(*dma->buflist), GFP_KERNEL);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!temp_buflist) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Free the entry because it isn't valid */
|
2005-09-24 22:28:13 -06:00
|
|
|
drm_cleanup_buf_error(dev, entry);
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
dma->buflist = temp_buflist;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0; i < entry->buf_count; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dma->buflist[i + dma->buf_count] = &entry->buflist[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
dma->buf_count += entry->buf_count;
|
2006-01-02 03:32:48 -07:00
|
|
|
dma->seg_count += entry->seg_count;
|
|
|
|
dma->page_count += byte_count >> PAGE_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
dma->byte_count += byte_count;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
|
|
|
|
DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-02 01:37:46 -07:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-09 23:00:06 -06:00
|
|
|
request->count = entry->buf_count;
|
|
|
|
request->size = size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dma->flags = _DRM_DMA_USE_SG;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
atomic_dec(&dev->buf_alloc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add buffers for DMA transfers (ioctl).
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 04:23:09 -06:00
|
|
|
* \param file_priv DRM file private.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param cmd command.
|
2007-07-10 23:27:12 -06:00
|
|
|
* \param arg pointer to a struct drm_buf_desc request.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \return zero on success or a negative number on failure.
|
|
|
|
*
|
|
|
|
* According with the memory type specified in drm_buf_desc::flags and the
|
|
|
|
* build options, it dispatches the call either to addbufs_agp(),
|
|
|
|
* addbufs_sg() or addbufs_pci() for AGP, scatter-gather or consistent
|
|
|
|
* PCI memory respectively.
|
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_addbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-09-02 20:06:45 -06:00
|
|
|
struct drm_buf_desc *request = data;
|
2005-07-09 23:00:06 -06:00
|
|
|
int ret;
|
2005-09-24 22:28:13 -06:00
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:20 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-09-09 08:45:52 -06:00
|
|
|
#if IS_ENABLED(CONFIG_AGP)
|
2007-09-02 20:06:45 -06:00
|
|
|
if (request->flags & _DRM_AGP_BUFFER)
|
2014-08-29 04:12:28 -06:00
|
|
|
ret = drm_legacy_addbufs_agp(dev, request);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
#endif
|
2007-09-02 20:06:45 -06:00
|
|
|
if (request->flags & _DRM_SG_BUFFER)
|
2014-08-29 04:12:28 -06:00
|
|
|
ret = drm_legacy_addbufs_sg(dev, request);
|
2007-09-02 20:06:45 -06:00
|
|
|
else if (request->flags & _DRM_FB_BUFFER)
|
2013-08-08 07:41:24 -06:00
|
|
|
ret = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2014-08-29 04:12:28 -06:00
|
|
|
ret = drm_legacy_addbufs_pci(dev, request);
|
2005-07-09 23:00:06 -06:00
|
|
|
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get information about the buffer mappings.
|
|
|
|
*
|
|
|
|
* This was originally mean for debugging purposes, or by a sophisticated
|
|
|
|
* client library to determine how best to use the available buffers (e.g.,
|
|
|
|
* large buffers can be used for image transfer).
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 04:23:09 -06:00
|
|
|
* \param file_priv DRM file private.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param cmd command.
|
|
|
|
* \param arg pointer to a drm_buf_info structure.
|
|
|
|
* \return zero on success or a negative number on failure.
|
|
|
|
*
|
2013-12-16 03:21:06 -07:00
|
|
|
* Increments drm_device::buf_use while holding the drm_device::buf_lock
|
2005-04-16 16:20:36 -06:00
|
|
|
* lock, preventing of allocating more buffers after this call. Information
|
|
|
|
* about each requested buffer is then copied into user space.
|
|
|
|
*/
|
2017-05-24 15:54:09 -06:00
|
|
|
int __drm_legacy_infobufs(struct drm_device *dev,
|
|
|
|
void *data, int *p,
|
|
|
|
int (*f)(void *, int, struct drm_buf_entry *))
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
int count;
|
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:20 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_lock(&dev->buf_lock);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (atomic_read(&dev->buf_alloc)) {
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
++dev->buf_use; /* Can't allocate more after this call */
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
|
|
|
|
if (dma->bufs[i].buf_count)
|
|
|
|
++count;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("count = %d\n", count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-05-24 15:54:09 -06:00
|
|
|
if (*p >= count) {
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
|
2017-05-24 15:54:09 -06:00
|
|
|
struct drm_buf_entry *from = &dma->bufs[i];
|
|
|
|
if (from->buf_count) {
|
|
|
|
if (f(data, count, from) < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("%d %d %d %d %d\n",
|
|
|
|
i,
|
|
|
|
dma->bufs[i].buf_count,
|
|
|
|
dma->bufs[i].buf_size,
|
2014-07-23 09:26:36 -06:00
|
|
|
dma->bufs[i].low_mark,
|
|
|
|
dma->bufs[i].high_mark);
|
2005-04-16 16:20:36 -06:00
|
|
|
++count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-05-24 15:54:09 -06:00
|
|
|
*p = count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-24 15:54:09 -06:00
|
|
|
static int copy_one_buf(void *data, int count, struct drm_buf_entry *from)
|
|
|
|
{
|
|
|
|
struct drm_buf_info *request = data;
|
|
|
|
struct drm_buf_desc __user *to = &request->list[count];
|
|
|
|
struct drm_buf_desc v = {.count = from->buf_count,
|
|
|
|
.size = from->buf_size,
|
|
|
|
.low_mark = from->low_mark,
|
|
|
|
.high_mark = from->high_mark};
|
|
|
|
return copy_to_user(to, &v, offsetof(struct drm_buf_desc, flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
int drm_legacy_infobufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_buf_info *request = data;
|
|
|
|
return __drm_legacy_infobufs(dev, data, &request->count, copy_one_buf);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* Specifies a low and high water mark for buffer allocation
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 04:23:09 -06:00
|
|
|
* \param file_priv DRM file private.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param cmd command.
|
|
|
|
* \param arg a pointer to a drm_buf_desc structure.
|
|
|
|
* \return zero on success or a negative number on failure.
|
|
|
|
*
|
|
|
|
* Verifies that the size order is bounded between the admissible orders and
|
|
|
|
* updates the respective drm_device_dma::bufs entry low and high water mark.
|
|
|
|
*
|
|
|
|
* \note This ioctl is deprecated and mostly never used.
|
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_markbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
2007-09-02 20:06:45 -06:00
|
|
|
struct drm_buf_desc *request = data;
|
2005-04-16 16:20:36 -06:00
|
|
|
int order;
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_buf_entry *entry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:20 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_DEBUG("%d, %d, %d\n",
|
2007-09-02 20:06:45 -06:00
|
|
|
request->size, request->low_mark, request->high_mark);
|
2013-07-10 06:11:57 -06:00
|
|
|
order = order_base_2(request->size);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
entry = &dma->bufs[order];
|
|
|
|
|
2007-09-02 20:06:45 -06:00
|
|
|
if (request->low_mark < 0 || request->low_mark > entry->buf_count)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2007-09-02 20:06:45 -06:00
|
|
|
if (request->high_mark < 0 || request->high_mark > entry->buf_count)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-07-23 09:26:36 -06:00
|
|
|
entry->low_mark = request->low_mark;
|
|
|
|
entry->high_mark = request->high_mark;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-09-24 22:28:13 -06:00
|
|
|
* Unreserve the buffers in list, previously reserved using drmDMA.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 04:23:09 -06:00
|
|
|
* \param file_priv DRM file private.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param cmd command.
|
|
|
|
* \param arg pointer to a drm_buf_free structure.
|
|
|
|
* \return zero on success or a negative number on failure.
|
2005-09-24 22:28:13 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Calls free_buffer() for each used buffer.
|
|
|
|
* This function is primarily used for debugging.
|
|
|
|
*/
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_freebufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
2007-09-02 20:06:45 -06:00
|
|
|
struct drm_buf_free *request = data;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
int idx;
|
2007-07-11 00:17:42 -06:00
|
|
|
struct drm_buf *buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:20 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-02 20:06:45 -06:00
|
|
|
DRM_DEBUG("%d\n", request->count);
|
|
|
|
for (i = 0; i < request->count; i++) {
|
|
|
|
if (copy_from_user(&idx, &request->list[i], sizeof(idx)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2005-09-24 22:28:13 -06:00
|
|
|
if (idx < 0 || idx >= dma->buf_count) {
|
|
|
|
DRM_ERROR("Index %d (of %d max)\n",
|
|
|
|
idx, dma->buf_count - 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
buf = dma->buflist[idx];
|
2007-08-25 04:23:09 -06:00
|
|
|
if (buf->file_priv != file_priv) {
|
2005-09-24 22:28:13 -06:00
|
|
|
DRM_ERROR("Process %d freeing buffer not owned\n",
|
2007-10-19 00:40:40 -06:00
|
|
|
task_pid_nr(current));
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2014-09-10 23:41:51 -06:00
|
|
|
drm_legacy_free_buffer(dev, buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Maps all of the DMA buffers into client-virtual space (ioctl).
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 04:23:09 -06:00
|
|
|
* \param file_priv DRM file private.
|
2005-04-16 16:20:36 -06:00
|
|
|
* \param cmd command.
|
|
|
|
* \param arg pointer to a drm_buf_map structure.
|
|
|
|
* \return zero on success or a negative number on failure.
|
|
|
|
*
|
2012-04-20 18:13:58 -06:00
|
|
|
* Maps the AGP, SG or PCI buffer region with vm_mmap(), and copies information
|
|
|
|
* about each buffer into user space. For PCI buffers, it calls vm_mmap() with
|
2006-10-24 13:03:04 -06:00
|
|
|
* offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
|
|
|
|
* drm_mmap_dma().
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2017-05-25 14:24:20 -06:00
|
|
|
int __drm_legacy_mapbufs(struct drm_device *dev, void *data, int *p,
|
|
|
|
void __user **v,
|
|
|
|
int (*f)(void *, int, unsigned long,
|
2018-03-18 18:52:22 -06:00
|
|
|
struct drm_buf *),
|
|
|
|
struct drm_file *file_priv)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-11 00:32:08 -06:00
|
|
|
struct drm_device_dma *dma = dev->dma;
|
2005-04-16 16:20:36 -06:00
|
|
|
int retcode = 0;
|
|
|
|
unsigned long virtual;
|
|
|
|
int i;
|
|
|
|
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:20 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!dma)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_lock(&dev->buf_lock);
|
2005-09-24 22:28:13 -06:00
|
|
|
if (atomic_read(&dev->buf_alloc)) {
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
dev->buf_use++; /* Can't allocate more after this call */
|
2013-12-16 03:21:06 -07:00
|
|
|
spin_unlock(&dev->buf_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-05-25 14:24:20 -06:00
|
|
|
if (*p >= dma->buf_count) {
|
2013-12-11 03:34:35 -07:00
|
|
|
if ((dev->agp && (dma->flags & _DRM_DMA_USE_AGP))
|
2005-09-24 22:28:13 -06:00
|
|
|
|| (drm_core_check_feature(dev, DRIVER_SG)
|
2013-08-08 07:41:24 -06:00
|
|
|
&& (dma->flags & _DRM_DMA_USE_SG))) {
|
2009-02-01 22:55:46 -07:00
|
|
|
struct drm_local_map *map = dev->agp_buffer_map;
|
2005-08-05 06:11:22 -06:00
|
|
|
unsigned long token = dev->agp_buffer_token;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
if (!map) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retcode = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
2012-04-20 18:13:58 -06:00
|
|
|
virtual = vm_mmap(file_priv->filp, 0, map->size,
|
2005-09-24 22:28:13 -06:00
|
|
|
PROT_READ | PROT_WRITE,
|
2007-09-02 20:06:45 -06:00
|
|
|
MAP_SHARED,
|
|
|
|
token);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-04-20 18:13:58 -06:00
|
|
|
virtual = vm_mmap(file_priv->filp, 0, dma->byte_count,
|
2005-09-24 22:28:13 -06:00
|
|
|
PROT_READ | PROT_WRITE,
|
|
|
|
MAP_SHARED, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
if (virtual > -1024UL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Real error */
|
|
|
|
retcode = (signed long)virtual;
|
|
|
|
goto done;
|
|
|
|
}
|
2017-05-25 14:24:20 -06:00
|
|
|
*v = (void __user *)virtual;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-24 22:28:13 -06:00
|
|
|
for (i = 0; i < dma->buf_count; i++) {
|
2017-05-25 14:24:20 -06:00
|
|
|
if (f(data, i, virtual, dma->buflist[i]) < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retcode = -EFAULT;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
done:
|
2017-05-25 14:24:20 -06:00
|
|
|
*p = dma->buf_count;
|
|
|
|
DRM_DEBUG("%d buffers, retcode = %d\n", *p, retcode);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
|
2017-05-25 14:24:20 -06:00
|
|
|
static int map_one_buf(void *data, int idx, unsigned long virtual,
|
|
|
|
struct drm_buf *buf)
|
|
|
|
{
|
|
|
|
struct drm_buf_map *request = data;
|
|
|
|
unsigned long address = virtual + buf->offset; /* *** */
|
|
|
|
|
|
|
|
if (copy_to_user(&request->list[idx].idx, &buf->idx,
|
|
|
|
sizeof(request->list[0].idx)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (copy_to_user(&request->list[idx].total, &buf->total,
|
|
|
|
sizeof(request->list[0].total)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (clear_user(&request->list[idx].used, sizeof(int)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (copy_to_user(&request->list[idx].address, &address,
|
|
|
|
sizeof(address)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int drm_legacy_mapbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_buf_map *request = data;
|
|
|
|
return __drm_legacy_mapbufs(dev, data, &request->count,
|
|
|
|
&request->virtual, map_one_buf,
|
|
|
|
file_priv);
|
|
|
|
}
|
|
|
|
|
2014-08-29 04:12:28 -06:00
|
|
|
int drm_legacy_dma_ioctl(struct drm_device *dev, void *data,
|
2013-08-08 07:41:29 -06:00
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
2016-08-03 13:11:10 -06:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_LEGACY))
|
2013-08-08 07:41:29 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (dev->driver->dma_ioctl)
|
|
|
|
return dev->driver->dma_ioctl(dev, data, file_priv);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-08-29 04:12:28 -06:00
|
|
|
struct drm_local_map *drm_legacy_getsarea(struct drm_device *dev)
|
2013-07-10 06:11:56 -06:00
|
|
|
{
|
|
|
|
struct drm_map_list *entry;
|
|
|
|
|
|
|
|
list_for_each_entry(entry, &dev->maplist, head) {
|
|
|
|
if (entry->map && entry->map->type == _DRM_SHM &&
|
|
|
|
(entry->map->flags & _DRM_CONTAINS_LOCK)) {
|
|
|
|
return entry->map;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-08-29 04:12:28 -06:00
|
|
|
EXPORT_SYMBOL(drm_legacy_getsarea);
|