blob: 0128147265f3620204495e5853c78d4e2d9e4c4a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/**
Dave Airlieb5e89ed2005-09-25 14:28:13 +10002 * \file drm_bufs.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Generic buffer template
Dave Airlieb5e89ed2005-09-25 14:28:13 +10004 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8
9/*
10 * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
11 *
12 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14 * All Rights Reserved.
15 *
16 * Permission is hereby granted, free of charge, to any person obtaining a
17 * copy of this software and associated documentation files (the "Software"),
18 * to deal in the Software without restriction, including without limitation
19 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20 * and/or sell copies of the Software, and to permit persons to whom the
21 * Software is furnished to do so, subject to the following conditions:
22 *
23 * The above copyright notice and this permission notice (including the next
24 * paragraph) shall be included in all copies or substantial portions of the
25 * Software.
26 *
27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33 * OTHER DEALINGS IN THE SOFTWARE.
34 */
35
36#include <linux/vmalloc.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
David Millerf1a2a9b2009-02-18 15:41:02 -080038#include <linux/log2.h>
Paul Gortmaker2d1a8a42011-08-30 18:16:33 -040039#include <linux/export.h>
David Millerf1a2a9b2009-02-18 15:41:02 -080040#include <asm/shmparam.h>
David Howells760285e2012-10-02 18:01:07 +010041#include <drm/drmP.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Dave Airlie55910512007-07-11 16:53:40 +100043static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +110044 struct drm_local_map *map)
Dave Airlie836cf042005-07-10 19:27:04 +100045{
Dave Airlie55910512007-07-11 16:53:40 +100046 struct drm_map_list *entry;
Dave Airliebd1b3312007-05-26 05:01:51 +100047 list_for_each_entry(entry, &dev->maplist, head) {
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +110048 /*
49 * Because the kernel-userspace ABI is fixed at a 32-bit offset
Tormod Volden66aa6962011-05-30 19:45:43 +000050 * while PCI resources may live above that, we only compare the
51 * lower 32 bits of the map offset for maps of type
52 * _DRM_FRAMEBUFFER or _DRM_REGISTERS.
53 * It is assumed that if a driver have more than one resource
54 * of each type, the lower 32 bits are different.
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +110055 */
56 if (!entry->map ||
57 map->type != entry->map->type ||
58 entry->master != dev->primary->master)
59 continue;
60 switch (map->type) {
61 case _DRM_SHM:
62 if (map->flags != _DRM_CONTAINS_LOCK)
63 break;
Tormod Volden66aa6962011-05-30 19:45:43 +000064 return entry;
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +110065 case _DRM_REGISTERS:
66 case _DRM_FRAME_BUFFER:
Tormod Volden66aa6962011-05-30 19:45:43 +000067 if ((entry->map->offset & 0xffffffff) ==
68 (map->offset & 0xffffffff))
69 return entry;
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +110070 default: /* Make gcc happy */
71 ;
Dave Airlie836cf042005-07-10 19:27:04 +100072 }
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +110073 if (entry->map->offset == map->offset)
74 return entry;
Dave Airlie836cf042005-07-10 19:27:04 +100075 }
76
77 return NULL;
78}
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Dave Airliee0be4282007-07-12 10:26:44 +100080static int drm_map_handle(struct drm_device *dev, struct drm_hash_item *hash,
David Millerf1a2a9b2009-02-18 15:41:02 -080081 unsigned long user_token, int hashed_handle, int shm)
Dave Airlied1f2b552005-08-05 22:11:22 +100082{
David Millerf1a2a9b2009-02-18 15:41:02 -080083 int use_hashed_handle, shift;
84 unsigned long add;
85
Dave Airliec2604ce2006-08-12 16:03:26 +100086#if (BITS_PER_LONG == 64)
Thomas Hellstrom8d153f72006-08-07 22:36:47 +100087 use_hashed_handle = ((user_token & 0xFFFFFFFF00000000UL) || hashed_handle);
88#elif (BITS_PER_LONG == 32)
89 use_hashed_handle = hashed_handle;
90#else
91#error Unsupported long size. Neither 64 nor 32 bits.
92#endif
Dave Airlied1f2b552005-08-05 22:11:22 +100093
Thomas Hellstrome08870c2006-09-22 04:18:37 +100094 if (!use_hashed_handle) {
95 int ret;
Thomas Hellstrom15450852007-02-08 16:14:05 +110096 hash->key = user_token >> PAGE_SHIFT;
Thomas Hellstrome08870c2006-09-22 04:18:37 +100097 ret = drm_ht_insert_item(&dev->map_hash, hash);
98 if (ret != -EINVAL)
99 return ret;
Dave Airlied1f2b552005-08-05 22:11:22 +1000100 }
David Millerf1a2a9b2009-02-18 15:41:02 -0800101
102 shift = 0;
103 add = DRM_MAP_HASH_OFFSET >> PAGE_SHIFT;
104 if (shm && (SHMLBA > PAGE_SIZE)) {
105 int bits = ilog2(SHMLBA >> PAGE_SHIFT) + 1;
106
107 /* For shared memory, we have to preserve the SHMLBA
108 * bits of the eventual vma->vm_pgoff value during
109 * mmap(). Otherwise we run into cache aliasing problems
110 * on some platforms. On these platforms, the pgoff of
111 * a mmap() request is used to pick a suitable virtual
112 * address for the mmap() region such that it will not
113 * cause cache aliasing problems.
114 *
115 * Therefore, make sure the SHMLBA relevant bits of the
116 * hash value we use are equal to those in the original
117 * kernel virtual address.
118 */
119 shift = bits;
120 add |= ((user_token >> PAGE_SHIFT) & ((1UL << bits) - 1UL));
121 }
122
Thomas Hellstrome08870c2006-09-22 04:18:37 +1000123 return drm_ht_just_insert_please(&dev->map_hash, hash,
124 user_token, 32 - PAGE_SHIFT - 3,
David Millerf1a2a9b2009-02-18 15:41:02 -0800125 shift, add);
Dave Airlied1f2b552005-08-05 22:11:22 +1000126}
Dave Airlie9a186642005-06-23 21:29:18 +1000127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/**
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100129 * Core function to create a range of memory available for mapping by a
130 * non-root process.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 *
132 * Adjusts the memory offset to its absolute value according to the mapping
133 * type. Adds the map to the map list drm_device::maplist. Adds MTRR's where
134 * applicable and if supported by the kernel.
135 */
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100136static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
Dave Airliec60ce622007-07-11 15:27:12 +1000137 unsigned int size, enum drm_map_type type,
Dave Airlie55910512007-07-11 16:53:40 +1000138 enum drm_map_flags flags,
139 struct drm_map_list ** maplist)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100141 struct drm_local_map *map;
Dave Airlie55910512007-07-11 16:53:40 +1000142 struct drm_map_list *list;
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000143 drm_dma_handle_t *dmah;
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000144 unsigned long user_token;
145 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Eric Anholt9a298b22009-03-24 12:23:04 -0700147 map = kmalloc(sizeof(*map), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000148 if (!map)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 return -ENOMEM;
150
Dave Airlie7ab98402005-07-10 16:56:52 +1000151 map->offset = offset;
152 map->size = size;
153 map->flags = flags;
154 map->type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
156 /* Only allow shared memory to be removable since we only keep enough
157 * book keeping information about shared memory to allow for removal
158 * when processes fork.
159 */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000160 if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700161 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return -EINVAL;
163 }
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100164 DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n",
165 (unsigned long long)map->offset, map->size, map->type);
Benjamin Herrenschmidtb6741372009-05-18 11:56:16 +1000166
167 /* page-align _DRM_SHM maps. They are allocated here so there is no security
168 * hole created by that and it works around various broken drivers that use
169 * a non-aligned quantity to map the SAREA. --BenH
170 */
171 if (map->type == _DRM_SHM)
172 map->size = PAGE_ALIGN(map->size);
173
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100174 if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700175 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return -EINVAL;
177 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000178 map->mtrr = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 map->handle = NULL;
180
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000181 switch (map->type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 case _DRM_REGISTERS:
183 case _DRM_FRAME_BUFFER:
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600184#if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__) && !defined(__arm__)
Dave Airlie8d2ea622006-01-11 20:48:09 +1100185 if (map->offset + (map->size-1) < map->offset ||
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000186 map->offset < virt_to_phys(high_memory)) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700187 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 return -EINVAL;
189 }
190#endif
Dave Airlie836cf042005-07-10 19:27:04 +1000191 /* Some drivers preinitialize some maps, without the X Server
192 * needing to be aware of it. Therefore, we just return success
193 * when the server tries to create a duplicate map.
194 */
Dave Airlie89625eb2005-09-05 21:23:23 +1000195 list = drm_find_matching_map(dev, map);
196 if (list != NULL) {
197 if (list->map->size != map->size) {
Dave Airlie836cf042005-07-10 19:27:04 +1000198 DRM_DEBUG("Matching maps of type %d with "
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000199 "mismatched sizes, (%ld vs %ld)\n",
200 map->type, map->size,
201 list->map->size);
Dave Airlie89625eb2005-09-05 21:23:23 +1000202 list->map->size = map->size;
Dave Airlie836cf042005-07-10 19:27:04 +1000203 }
204
Eric Anholt9a298b22009-03-24 12:23:04 -0700205 kfree(map);
Dave Airlie89625eb2005-09-05 21:23:23 +1000206 *maplist = list;
Dave Airlie836cf042005-07-10 19:27:04 +1000207 return 0;
208 }
209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 if (drm_core_has_MTRR(dev)) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000211 if (map->type == _DRM_FRAME_BUFFER ||
212 (map->flags & _DRM_WRITE_COMBINING)) {
213 map->mtrr = mtrr_add(map->offset, map->size,
214 MTRR_TYPE_WRCOMB, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 }
216 }
Scott Thompson0769d392007-08-25 18:17:49 +1000217 if (map->type == _DRM_REGISTERS) {
Christoph Hellwig004a7722007-01-08 21:56:59 +1100218 map->handle = ioremap(map->offset, map->size);
Scott Thompson0769d392007-08-25 18:17:49 +1000219 if (!map->handle) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700220 kfree(map);
Scott Thompson0769d392007-08-25 18:17:49 +1000221 return -ENOMEM;
222 }
223 }
Dave Airliebc5f4522007-11-05 12:50:58 +1000224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 case _DRM_SHM:
Dave Airlie54ba2f72007-02-10 12:07:47 +1100227 list = drm_find_matching_map(dev, map);
228 if (list != NULL) {
229 if(list->map->size != map->size) {
230 DRM_DEBUG("Matching maps of type %d with "
231 "mismatched sizes, (%ld vs %ld)\n",
232 map->type, map->size, list->map->size);
233 list->map->size = map->size;
234 }
235
Eric Anholt9a298b22009-03-24 12:23:04 -0700236 kfree(map);
Dave Airlie54ba2f72007-02-10 12:07:47 +1100237 *maplist = list;
238 return 0;
239 }
Thomas Hellstromf239b7b2007-01-08 21:22:50 +1100240 map->handle = vmalloc_user(map->size);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000241 DRM_DEBUG("%lu %d %p\n",
242 map->size, drm_order(map->size), map->handle);
243 if (!map->handle) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700244 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 return -ENOMEM;
246 }
247 map->offset = (unsigned long)map->handle;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000248 if (map->flags & _DRM_CONTAINS_LOCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 /* Prevent a 2nd X Server from creating a 2nd lock */
Dave Airlie7c1c2872008-11-28 14:22:24 +1000250 if (dev->primary->master->lock.hw_lock != NULL) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000251 vfree(map->handle);
Eric Anholt9a298b22009-03-24 12:23:04 -0700252 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 return -EBUSY;
254 }
Dave Airlie7c1c2872008-11-28 14:22:24 +1000255 dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle; /* Pointer to lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 }
257 break;
Dave Airlie54ba2f72007-02-10 12:07:47 +1100258 case _DRM_AGP: {
Dave Airlie55910512007-07-11 16:53:40 +1000259 struct drm_agp_mem *entry;
Dave Airlie54ba2f72007-02-10 12:07:47 +1100260 int valid = 0;
261
262 if (!drm_core_has_AGP(dev)) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700263 kfree(map);
Dave Airlie54ba2f72007-02-10 12:07:47 +1100264 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 }
Dave Airlie54ba2f72007-02-10 12:07:47 +1100266#ifdef __alpha__
267 map->offset += dev->hose->mem_space->start;
268#endif
Eric Anholt47a184a2007-11-22 16:55:15 +1000269 /* In some cases (i810 driver), user space may have already
270 * added the AGP base itself, because dev->agp->base previously
271 * only got set during AGP enable. So, only add the base
272 * address if the map's offset isn't already within the
273 * aperture.
Dave Airlie54ba2f72007-02-10 12:07:47 +1100274 */
Eric Anholt47a184a2007-11-22 16:55:15 +1000275 if (map->offset < dev->agp->base ||
276 map->offset > dev->agp->base +
277 dev->agp->agp_info.aper_size * 1024 * 1024 - 1) {
278 map->offset += dev->agp->base;
279 }
Dave Airlie54ba2f72007-02-10 12:07:47 +1100280 map->mtrr = dev->agp->agp_mtrr; /* for getmap */
281
282 /* This assumes the DRM is in total control of AGP space.
283 * It's not always the case as AGP can be in the control
284 * of user space (i.e. i810 driver). So this loop will get
285 * skipped and we double check that dev->agp->memory is
286 * actually set as well as being invalid before EPERM'ing
287 */
Dave Airliebd1b3312007-05-26 05:01:51 +1000288 list_for_each_entry(entry, &dev->agp->memory, head) {
Dave Airlie54ba2f72007-02-10 12:07:47 +1100289 if ((map->offset >= entry->bound) &&
290 (map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {
291 valid = 1;
292 break;
293 }
294 }
Dave Airliebd1b3312007-05-26 05:01:51 +1000295 if (!list_empty(&dev->agp->memory) && !valid) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700296 kfree(map);
Dave Airlie54ba2f72007-02-10 12:07:47 +1100297 return -EPERM;
298 }
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100299 DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n",
300 (unsigned long long)map->offset, map->size);
Dave Airlie54ba2f72007-02-10 12:07:47 +1100301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 break;
Dave Airlie54ba2f72007-02-10 12:07:47 +1100303 }
Pekka Paalanen812c3692009-09-17 22:59:54 +0300304 case _DRM_GEM:
305 DRM_ERROR("tried to addmap GEM object\n");
306 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 case _DRM_SCATTER_GATHER:
308 if (!dev->sg) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700309 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return -EINVAL;
311 }
Dave Airlied1f2b552005-08-05 22:11:22 +1000312 map->offset += (unsigned long)dev->sg->virtual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 break;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000314 case _DRM_CONSISTENT:
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000315 /* dma_addr_t is 64bit on i386 with CONFIG_HIGHMEM64G,
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000316 * As we're limiting the address to 2^32-1 (or less),
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000317 * casting it down to 32 bits is no problem, but we
318 * need to point to a 64bit variable first. */
Zhenyu Wange6be8d92010-01-05 11:25:05 +0800319 dmah = drm_pci_alloc(dev, map->size, map->size);
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000320 if (!dmah) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700321 kfree(map);
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000322 return -ENOMEM;
323 }
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000324 map->handle = dmah->vaddr;
325 map->offset = (unsigned long)dmah->busaddr;
326 kfree(dmah);
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000327 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 default:
Eric Anholt9a298b22009-03-24 12:23:04 -0700329 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return -EINVAL;
331 }
332
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400333 list = kzalloc(sizeof(*list), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000334 if (!list) {
Amol Lad85abb3f2006-10-25 09:55:34 -0700335 if (map->type == _DRM_REGISTERS)
Christoph Hellwig004a7722007-01-08 21:56:59 +1100336 iounmap(map->handle);
Eric Anholt9a298b22009-03-24 12:23:04 -0700337 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return -EINVAL;
339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 list->map = map;
341
Dave Airlie30e2fb12006-02-02 19:37:46 +1100342 mutex_lock(&dev->struct_mutex);
Dave Airliebd1b3312007-05-26 05:01:51 +1000343 list_add(&list->head, &dev->maplist);
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000344
Dave Airlied1f2b552005-08-05 22:11:22 +1000345 /* Assign a 32-bit handle */
Dave Airlie30e2fb12006-02-02 19:37:46 +1100346 /* We do it here so that dev->struct_mutex protects the increment */
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000347 user_token = (map->type == _DRM_SHM) ? (unsigned long)map->handle :
348 map->offset;
David Millerf1a2a9b2009-02-18 15:41:02 -0800349 ret = drm_map_handle(dev, &list->hash, user_token, 0,
350 (map->type == _DRM_SHM));
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000351 if (ret) {
Amol Lad85abb3f2006-10-25 09:55:34 -0700352 if (map->type == _DRM_REGISTERS)
Christoph Hellwig004a7722007-01-08 21:56:59 +1100353 iounmap(map->handle);
Eric Anholt9a298b22009-03-24 12:23:04 -0700354 kfree(map);
355 kfree(list);
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000356 mutex_unlock(&dev->struct_mutex);
357 return ret;
358 }
359
Thomas Hellstrom15450852007-02-08 16:14:05 +1100360 list->user_token = list->hash.key << PAGE_SHIFT;
Dave Airlie30e2fb12006-02-02 19:37:46 +1100361 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Ben Skeggs2ff2e8a2009-05-26 10:35:52 +1000363 if (!(map->flags & _DRM_DRIVER))
364 list->master = dev->primary->master;
Dave Airlie89625eb2005-09-05 21:23:23 +1000365 *maplist = list;
Dave Airlie7ab98402005-07-10 16:56:52 +1000366 return 0;
Dave Airlie54ba2f72007-02-10 12:07:47 +1100367 }
Dave Airlie89625eb2005-09-05 21:23:23 +1000368
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100369int drm_addmap(struct drm_device * dev, resource_size_t offset,
Dave Airliec60ce622007-07-11 15:27:12 +1000370 unsigned int size, enum drm_map_type type,
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100371 enum drm_map_flags flags, struct drm_local_map ** map_ptr)
Dave Airlie89625eb2005-09-05 21:23:23 +1000372{
Dave Airlie55910512007-07-11 16:53:40 +1000373 struct drm_map_list *list;
Dave Airlie89625eb2005-09-05 21:23:23 +1000374 int rc;
375
376 rc = drm_addmap_core(dev, offset, size, type, flags, &list);
377 if (!rc)
378 *map_ptr = list->map;
379 return rc;
380}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000381
Dave Airlie7ab98402005-07-10 16:56:52 +1000382EXPORT_SYMBOL(drm_addmap);
383
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100384/**
385 * Ioctl to specify a range of memory that is available for mapping by a
386 * non-root process.
387 *
388 * \param inode device inode.
389 * \param file_priv DRM file private.
390 * \param cmd command.
391 * \param arg pointer to a drm_map structure.
392 * \return zero on success or a negative value on error.
393 *
394 */
Eric Anholtc153f452007-09-03 12:06:45 +1000395int drm_addmap_ioctl(struct drm_device *dev, void *data,
396 struct drm_file *file_priv)
Dave Airlie7ab98402005-07-10 16:56:52 +1000397{
Eric Anholtc153f452007-09-03 12:06:45 +1000398 struct drm_map *map = data;
Dave Airlie55910512007-07-11 16:53:40 +1000399 struct drm_map_list *maplist;
Dave Airlie7ab98402005-07-10 16:56:52 +1000400 int err;
401
Dave Airlie7c1c2872008-11-28 14:22:24 +1000402 if (!(capable(CAP_SYS_ADMIN) || map->type == _DRM_AGP || map->type == _DRM_SHM))
Dave Airlied985c102006-01-02 21:32:48 +1100403 return -EPERM;
404
Eric Anholtc153f452007-09-03 12:06:45 +1000405 err = drm_addmap_core(dev, map->offset, map->size, map->type,
406 map->flags, &maplist);
Dave Airlie7ab98402005-07-10 16:56:52 +1000407
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000408 if (err)
Dave Airlie7ab98402005-07-10 16:56:52 +1000409 return err;
Dave Airlie7ab98402005-07-10 16:56:52 +1000410
Dave Airlie67e1a012005-10-24 18:41:39 +1000411 /* avoid a warning on 64-bit, this casting isn't very nice, but the API is set so too late */
Eric Anholtc153f452007-09-03 12:06:45 +1000412 map->handle = (void *)(unsigned long)maplist->user_token;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 return 0;
Dave Airlie88f399c2005-08-20 17:43:33 +1000414}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416/**
417 * Remove a map private from list and deallocate resources if the mapping
418 * isn't in use.
419 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 * Searches the map on drm_device::maplist, removes it from the list, see if
421 * its being used, and free any associate resource (such as MTRR's) if it's not
422 * being on use.
423 *
Dave Airlie7ab98402005-07-10 16:56:52 +1000424 * \sa drm_addmap
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 */
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100426int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
Dave Airlie55910512007-07-11 16:53:40 +1000428 struct drm_map_list *r_list = NULL, *list_t;
Dave Airlie836cf042005-07-10 19:27:04 +1000429 drm_dma_handle_t dmah;
Dave Airliebd1b3312007-05-26 05:01:51 +1000430 int found = 0;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000431 struct drm_master *master;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Dave Airlie836cf042005-07-10 19:27:04 +1000433 /* Find the list entry for the map and remove it */
Dave Airliebd1b3312007-05-26 05:01:51 +1000434 list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
Dave Airlie836cf042005-07-10 19:27:04 +1000435 if (r_list->map == map) {
Dave Airlie7c1c2872008-11-28 14:22:24 +1000436 master = r_list->master;
Dave Airliebd1b3312007-05-26 05:01:51 +1000437 list_del(&r_list->head);
Thomas Hellstrom15450852007-02-08 16:14:05 +1100438 drm_ht_remove_key(&dev->map_hash,
439 r_list->user_token >> PAGE_SHIFT);
Eric Anholt9a298b22009-03-24 12:23:04 -0700440 kfree(r_list);
Dave Airliebd1b3312007-05-26 05:01:51 +1000441 found = 1;
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000442 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Dave Airlie836cf042005-07-10 19:27:04 +1000445
Dave Airliebd1b3312007-05-26 05:01:51 +1000446 if (!found)
Dave Airlie836cf042005-07-10 19:27:04 +1000447 return -EINVAL;
Dave Airlie836cf042005-07-10 19:27:04 +1000448
449 switch (map->type) {
450 case _DRM_REGISTERS:
Christoph Hellwig004a7722007-01-08 21:56:59 +1100451 iounmap(map->handle);
Dave Airlie836cf042005-07-10 19:27:04 +1000452 /* FALLTHROUGH */
453 case _DRM_FRAME_BUFFER:
454 if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {
455 int retcode;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000456 retcode = mtrr_del(map->mtrr, map->offset, map->size);
457 DRM_DEBUG("mtrr_del=%d\n", retcode);
Dave Airlie836cf042005-07-10 19:27:04 +1000458 }
459 break;
460 case _DRM_SHM:
461 vfree(map->handle);
Dave Airlie7c1c2872008-11-28 14:22:24 +1000462 if (master) {
463 if (dev->sigdata.lock == master->lock.hw_lock)
464 dev->sigdata.lock = NULL;
465 master->lock.hw_lock = NULL; /* SHM removed */
466 master->lock.file_priv = NULL;
Thomas Hellstrom171901d2009-03-02 11:10:55 +0100467 wake_up_interruptible_all(&master->lock.lock_queue);
Dave Airlie7c1c2872008-11-28 14:22:24 +1000468 }
Dave Airlie836cf042005-07-10 19:27:04 +1000469 break;
470 case _DRM_AGP:
471 case _DRM_SCATTER_GATHER:
472 break;
473 case _DRM_CONSISTENT:
474 dmah.vaddr = map->handle;
475 dmah.busaddr = map->offset;
476 dmah.size = map->size;
477 __drm_pci_free(dev, &dmah);
478 break;
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800479 case _DRM_GEM:
480 DRM_ERROR("tried to rmmap GEM object\n");
481 break;
Dave Airlie836cf042005-07-10 19:27:04 +1000482 }
Eric Anholt9a298b22009-03-24 12:23:04 -0700483 kfree(map);
Dave Airlie836cf042005-07-10 19:27:04 +1000484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 return 0;
486}
Dave Airlie4e74f362008-12-19 10:23:14 +1100487EXPORT_SYMBOL(drm_rmmap_locked);
Dave Airlie836cf042005-07-10 19:27:04 +1000488
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100489int drm_rmmap(struct drm_device *dev, struct drm_local_map *map)
Dave Airlie836cf042005-07-10 19:27:04 +1000490{
491 int ret;
492
Dave Airlie30e2fb12006-02-02 19:37:46 +1100493 mutex_lock(&dev->struct_mutex);
Dave Airlie836cf042005-07-10 19:27:04 +1000494 ret = drm_rmmap_locked(dev, map);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100495 mutex_unlock(&dev->struct_mutex);
Dave Airlie836cf042005-07-10 19:27:04 +1000496
497 return ret;
498}
Jesse Barnesba8bbcf2007-11-22 14:14:14 +1000499EXPORT_SYMBOL(drm_rmmap);
Dave Airlie7ab98402005-07-10 16:56:52 +1000500
Dave Airlie836cf042005-07-10 19:27:04 +1000501/* The rmmap ioctl appears to be unnecessary. All mappings are torn down on
502 * the last close of the device, and this is necessary for cleanup when things
503 * exit uncleanly. Therefore, having userland manually remove mappings seems
504 * like a pointless exercise since they're going away anyway.
505 *
506 * One use case might be after addmap is allowed for normal users for SHM and
507 * gets used by drivers that the server doesn't need to care about. This seems
508 * unlikely.
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100509 *
510 * \param inode device inode.
511 * \param file_priv DRM file private.
512 * \param cmd command.
513 * \param arg pointer to a struct drm_map structure.
514 * \return zero on success or a negative value on error.
Dave Airlie836cf042005-07-10 19:27:04 +1000515 */
Eric Anholtc153f452007-09-03 12:06:45 +1000516int drm_rmmap_ioctl(struct drm_device *dev, void *data,
517 struct drm_file *file_priv)
Dave Airlie7ab98402005-07-10 16:56:52 +1000518{
Eric Anholtc153f452007-09-03 12:06:45 +1000519 struct drm_map *request = data;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100520 struct drm_local_map *map = NULL;
Dave Airlie55910512007-07-11 16:53:40 +1000521 struct drm_map_list *r_list;
Dave Airlie836cf042005-07-10 19:27:04 +1000522 int ret;
Dave Airlie7ab98402005-07-10 16:56:52 +1000523
Dave Airlie30e2fb12006-02-02 19:37:46 +1100524 mutex_lock(&dev->struct_mutex);
Dave Airliebd1b3312007-05-26 05:01:51 +1000525 list_for_each_entry(r_list, &dev->maplist, head) {
Dave Airlie836cf042005-07-10 19:27:04 +1000526 if (r_list->map &&
Eric Anholtc153f452007-09-03 12:06:45 +1000527 r_list->user_token == (unsigned long)request->handle &&
Dave Airlie836cf042005-07-10 19:27:04 +1000528 r_list->map->flags & _DRM_REMOVABLE) {
529 map = r_list->map;
530 break;
531 }
532 }
533
534 /* List has wrapped around to the head pointer, or its empty we didn't
535 * find anything.
536 */
Dave Airliebd1b3312007-05-26 05:01:51 +1000537 if (list_empty(&dev->maplist) || !map) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100538 mutex_unlock(&dev->struct_mutex);
Dave Airlie836cf042005-07-10 19:27:04 +1000539 return -EINVAL;
540 }
541
Dave Airlie836cf042005-07-10 19:27:04 +1000542 /* Register and framebuffer maps are permanent */
543 if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100544 mutex_unlock(&dev->struct_mutex);
Dave Airlie836cf042005-07-10 19:27:04 +1000545 return 0;
546 }
547
548 ret = drm_rmmap_locked(dev, map);
549
Dave Airlie30e2fb12006-02-02 19:37:46 +1100550 mutex_unlock(&dev->struct_mutex);
Dave Airlie836cf042005-07-10 19:27:04 +1000551
552 return ret;
Dave Airlie7ab98402005-07-10 16:56:52 +1000553}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555/**
556 * Cleanup after an error on one of the addbufs() functions.
557 *
Dave Airlie836cf042005-07-10 19:27:04 +1000558 * \param dev DRM device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 * \param entry buffer entry where the error occurred.
560 *
561 * Frees any pages and buffers associated with the given entry.
562 */
Dave Airliecdd55a22007-07-11 16:32:08 +1000563static void drm_cleanup_buf_error(struct drm_device * dev,
564 struct drm_buf_entry * entry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
566 int i;
567
568 if (entry->seg_count) {
569 for (i = 0; i < entry->seg_count; i++) {
570 if (entry->seglist[i]) {
Dave Airlieddf19b92006-03-19 18:56:12 +1100571 drm_pci_free(dev, entry->seglist[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 }
573 }
Eric Anholt9a298b22009-03-24 12:23:04 -0700574 kfree(entry->seglist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 entry->seg_count = 0;
577 }
578
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000579 if (entry->buf_count) {
580 for (i = 0; i < entry->buf_count; i++) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700581 kfree(entry->buflist[i].dev_private);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 }
Eric Anholt9a298b22009-03-24 12:23:04 -0700583 kfree(entry->buflist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 entry->buf_count = 0;
586 }
587}
588
589#if __OS_HAS_AGP
590/**
Dave Airlied59431b2005-07-10 15:00:06 +1000591 * Add AGP buffers for DMA transfers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 *
Dave Airlie84b1fd12007-07-11 15:53:27 +1000593 * \param dev struct drm_device to which the buffers are to be added.
Dave Airliec60ce622007-07-11 15:27:12 +1000594 * \param request pointer to a struct drm_buf_desc describing the request.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000596 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 * After some sanity checks creates a drm_buf structure for each buffer and
598 * reallocates the buffer list of the same size order to accommodate the new
599 * buffers.
600 */
Dave Airlie84b1fd12007-07-11 15:53:27 +1000601int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
Dave Airliecdd55a22007-07-11 16:32:08 +1000603 struct drm_device_dma *dma = dev->dma;
604 struct drm_buf_entry *entry;
Dave Airlie55910512007-07-11 16:53:40 +1000605 struct drm_agp_mem *agp_entry;
Dave Airlie056219e2007-07-11 16:17:42 +1000606 struct drm_buf *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 unsigned long offset;
608 unsigned long agp_offset;
609 int count;
610 int order;
611 int size;
612 int alignment;
613 int page_order;
614 int total;
615 int byte_count;
Dave Airlie54ba2f72007-02-10 12:07:47 +1100616 int i, valid;
Dave Airlie056219e2007-07-11 16:17:42 +1000617 struct drm_buf **temp_buflist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000619 if (!dma)
620 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Dave Airlied59431b2005-07-10 15:00:06 +1000622 count = request->count;
623 order = drm_order(request->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 size = 1 << order;
625
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000626 alignment = (request->flags & _DRM_PAGE_ALIGN)
627 ? PAGE_ALIGN(size) : size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
629 total = PAGE_SIZE << page_order;
630
631 byte_count = 0;
Dave Airlied59431b2005-07-10 15:00:06 +1000632 agp_offset = dev->agp->base + request->agp_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000634 DRM_DEBUG("count: %d\n", count);
635 DRM_DEBUG("order: %d\n", order);
636 DRM_DEBUG("size: %d\n", size);
Dave Airlied985c102006-01-02 21:32:48 +1100637 DRM_DEBUG("agp_offset: %lx\n", agp_offset);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000638 DRM_DEBUG("alignment: %d\n", alignment);
639 DRM_DEBUG("page_order: %d\n", page_order);
640 DRM_DEBUG("total: %d\n", total);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000642 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
643 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Dave Airlie54ba2f72007-02-10 12:07:47 +1100645 /* Make sure buffers are located in AGP memory that we own */
646 valid = 0;
Dave Airliebd1b3312007-05-26 05:01:51 +1000647 list_for_each_entry(agp_entry, &dev->agp->memory, head) {
Dave Airlie54ba2f72007-02-10 12:07:47 +1100648 if ((agp_offset >= agp_entry->bound) &&
649 (agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
650 valid = 1;
651 break;
652 }
653 }
Dave Airliebd1b3312007-05-26 05:01:51 +1000654 if (!list_empty(&dev->agp->memory) && !valid) {
Dave Airlie54ba2f72007-02-10 12:07:47 +1100655 DRM_DEBUG("zone invalid\n");
656 return -EINVAL;
657 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000658 spin_lock(&dev->count_lock);
659 if (dev->buf_use) {
660 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 return -EBUSY;
662 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000663 atomic_inc(&dev->buf_alloc);
664 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Dave Airlie30e2fb12006-02-02 19:37:46 +1100666 mutex_lock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 entry = &dma->bufs[order];
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000668 if (entry->buf_count) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100669 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000670 atomic_dec(&dev->buf_alloc);
671 return -ENOMEM; /* May only call once for each order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
674 if (count < 0 || count > 4096) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100675 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000676 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return -EINVAL;
678 }
679
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400680 entry->buflist = kzalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000681 if (!entry->buflist) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100682 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000683 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 return -ENOMEM;
685 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 entry->buf_size = size;
688 entry->page_order = page_order;
689
690 offset = 0;
691
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000692 while (entry->buf_count < count) {
693 buf = &entry->buflist[entry->buf_count];
694 buf->idx = dma->buf_count + entry->buf_count;
695 buf->total = alignment;
696 buf->order = order;
697 buf->used = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000699 buf->offset = (dma->byte_count + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 buf->bus_address = agp_offset + offset;
701 buf->address = (void *)(agp_offset + offset);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000702 buf->next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 buf->waiting = 0;
704 buf->pending = 0;
Eric Anholt6c340ea2007-08-25 20:23:09 +1000705 buf->file_priv = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
707 buf->dev_priv_size = dev->driver->dev_priv_size;
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400708 buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000709 if (!buf->dev_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 /* Set count correctly so we free the proper amount. */
711 entry->buf_count = count;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000712 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100713 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000714 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 return -ENOMEM;
716 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000718 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 offset += alignment;
721 entry->buf_count++;
722 byte_count += PAGE_SIZE << page_order;
723 }
724
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000725 DRM_DEBUG("byte_count: %d\n", byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Eric Anholt9a298b22009-03-24 12:23:04 -0700727 temp_buflist = krealloc(dma->buflist,
728 (dma->buf_count + entry->buf_count) *
729 sizeof(*dma->buflist), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000730 if (!temp_buflist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 /* Free the entry because it isn't valid */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000732 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100733 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000734 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 return -ENOMEM;
736 }
737 dma->buflist = temp_buflist;
738
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000739 for (i = 0; i < entry->buf_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
741 }
742
743 dma->buf_count += entry->buf_count;
Dave Airlied985c102006-01-02 21:32:48 +1100744 dma->seg_count += entry->seg_count;
745 dma->page_count += byte_count >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 dma->byte_count += byte_count;
747
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000748 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
749 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Dave Airlie30e2fb12006-02-02 19:37:46 +1100751 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
Dave Airlied59431b2005-07-10 15:00:06 +1000753 request->count = entry->buf_count;
754 request->size = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
756 dma->flags = _DRM_DMA_USE_AGP;
757
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000758 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return 0;
760}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000761EXPORT_SYMBOL(drm_addbufs_agp);
762#endif /* __OS_HAS_AGP */
763
Dave Airlie84b1fd12007-07-11 15:53:27 +1000764int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765{
Dave Airliecdd55a22007-07-11 16:32:08 +1000766 struct drm_device_dma *dma = dev->dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 int count;
768 int order;
769 int size;
770 int total;
771 int page_order;
Dave Airliecdd55a22007-07-11 16:32:08 +1000772 struct drm_buf_entry *entry;
Dave Airlieddf19b92006-03-19 18:56:12 +1100773 drm_dma_handle_t *dmah;
Dave Airlie056219e2007-07-11 16:17:42 +1000774 struct drm_buf *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 int alignment;
776 unsigned long offset;
777 int i;
778 int byte_count;
779 int page_count;
780 unsigned long *temp_pagelist;
Dave Airlie056219e2007-07-11 16:17:42 +1000781 struct drm_buf **temp_buflist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000783 if (!drm_core_check_feature(dev, DRIVER_PCI_DMA))
784 return -EINVAL;
Dave Airlied985c102006-01-02 21:32:48 +1100785
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000786 if (!dma)
787 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Dave Airlied985c102006-01-02 21:32:48 +1100789 if (!capable(CAP_SYS_ADMIN))
790 return -EPERM;
791
Dave Airlied59431b2005-07-10 15:00:06 +1000792 count = request->count;
793 order = drm_order(request->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 size = 1 << order;
795
Daniel Vettera344a7e2011-10-26 00:54:41 +0200796 DRM_DEBUG("count=%d, size=%d (%d), order=%d\n",
797 request->count, request->size, size, order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000799 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
800 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Dave Airlied59431b2005-07-10 15:00:06 +1000802 alignment = (request->flags & _DRM_PAGE_ALIGN)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000803 ? PAGE_ALIGN(size) : size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
805 total = PAGE_SIZE << page_order;
806
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000807 spin_lock(&dev->count_lock);
808 if (dev->buf_use) {
809 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 return -EBUSY;
811 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000812 atomic_inc(&dev->buf_alloc);
813 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Dave Airlie30e2fb12006-02-02 19:37:46 +1100815 mutex_lock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 entry = &dma->bufs[order];
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000817 if (entry->buf_count) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100818 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000819 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 return -ENOMEM; /* May only call once for each order */
821 }
822
823 if (count < 0 || count > 4096) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100824 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000825 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 return -EINVAL;
827 }
828
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400829 entry->buflist = kzalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000830 if (!entry->buflist) {
Dave Airlie30e2fb12006-02-02 19:37:46 +1100831 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000832 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 return -ENOMEM;
834 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400836 entry->seglist = kzalloc(count * sizeof(*entry->seglist), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000837 if (!entry->seglist) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700838 kfree(entry->buflist);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100839 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000840 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return -ENOMEM;
842 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 /* Keep the original pagelist until we know all the allocations
845 * have succeeded
846 */
Eric Anholt9a298b22009-03-24 12:23:04 -0700847 temp_pagelist = kmalloc((dma->page_count + (count << page_order)) *
848 sizeof(*dma->pagelist), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 if (!temp_pagelist) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700850 kfree(entry->buflist);
851 kfree(entry->seglist);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100852 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000853 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 return -ENOMEM;
855 }
856 memcpy(temp_pagelist,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000857 dma->pagelist, dma->page_count * sizeof(*dma->pagelist));
858 DRM_DEBUG("pagelist: %d entries\n",
859 dma->page_count + (count << page_order));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000861 entry->buf_size = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 entry->page_order = page_order;
863 byte_count = 0;
864 page_count = 0;
865
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000866 while (entry->buf_count < count) {
Dave Airliebc5f4522007-11-05 12:50:58 +1000867
Zhenyu Wange6be8d92010-01-05 11:25:05 +0800868 dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000);
Dave Airliebc5f4522007-11-05 12:50:58 +1000869
Dave Airlieddf19b92006-03-19 18:56:12 +1100870 if (!dmah) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 /* Set count correctly so we free the proper amount. */
872 entry->buf_count = count;
873 entry->seg_count = count;
874 drm_cleanup_buf_error(dev, entry);
Eric Anholt9a298b22009-03-24 12:23:04 -0700875 kfree(temp_pagelist);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100876 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000877 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 return -ENOMEM;
879 }
Dave Airlieddf19b92006-03-19 18:56:12 +1100880 entry->seglist[entry->seg_count++] = dmah;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000881 for (i = 0; i < (1 << page_order); i++) {
882 DRM_DEBUG("page %d @ 0x%08lx\n",
883 dma->page_count + page_count,
Dave Airlieddf19b92006-03-19 18:56:12 +1100884 (unsigned long)dmah->vaddr + PAGE_SIZE * i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 temp_pagelist[dma->page_count + page_count++]
Dave Airlieddf19b92006-03-19 18:56:12 +1100886 = (unsigned long)dmah->vaddr + PAGE_SIZE * i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000888 for (offset = 0;
889 offset + size <= total && entry->buf_count < count;
890 offset += alignment, ++entry->buf_count) {
891 buf = &entry->buflist[entry->buf_count];
892 buf->idx = dma->buf_count + entry->buf_count;
893 buf->total = alignment;
894 buf->order = order;
895 buf->used = 0;
896 buf->offset = (dma->byte_count + byte_count + offset);
Dave Airlieddf19b92006-03-19 18:56:12 +1100897 buf->address = (void *)(dmah->vaddr + offset);
898 buf->bus_address = dmah->busaddr + offset;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000899 buf->next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 buf->waiting = 0;
901 buf->pending = 0;
Eric Anholt6c340ea2007-08-25 20:23:09 +1000902 buf->file_priv = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904 buf->dev_priv_size = dev->driver->dev_priv_size;
Davidlohr Bueso94e33702010-08-11 09:18:52 -0400905 buf->dev_private = kzalloc(buf->dev_priv_size,
906 GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000907 if (!buf->dev_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 /* Set count correctly so we free the proper amount. */
909 entry->buf_count = count;
910 entry->seg_count = count;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000911 drm_cleanup_buf_error(dev, entry);
Eric Anholt9a298b22009-03-24 12:23:04 -0700912 kfree(temp_pagelist);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100913 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000914 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 return -ENOMEM;
916 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000918 DRM_DEBUG("buffer %d @ %p\n",
919 entry->buf_count, buf->address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
921 byte_count += PAGE_SIZE << page_order;
922 }
923
Eric Anholt9a298b22009-03-24 12:23:04 -0700924 temp_buflist = krealloc(dma->buflist,
925 (dma->buf_count + entry->buf_count) *
926 sizeof(*dma->buflist), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (!temp_buflist) {
928 /* Free the entry because it isn't valid */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000929 drm_cleanup_buf_error(dev, entry);
Eric Anholt9a298b22009-03-24 12:23:04 -0700930 kfree(temp_pagelist);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100931 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000932 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return -ENOMEM;
934 }
935 dma->buflist = temp_buflist;
936
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000937 for (i = 0; i < entry->buf_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
939 }
940
Thomas Weber88393162010-03-16 11:47:56 +0100941 /* No allocations failed, so now we can replace the original pagelist
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 * with the new one.
943 */
944 if (dma->page_count) {
Eric Anholt9a298b22009-03-24 12:23:04 -0700945 kfree(dma->pagelist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 }
947 dma->pagelist = temp_pagelist;
948
949 dma->buf_count += entry->buf_count;
950 dma->seg_count += entry->seg_count;
951 dma->page_count += entry->seg_count << page_order;
952 dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
953
Dave Airlie30e2fb12006-02-02 19:37:46 +1100954 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Dave Airlied59431b2005-07-10 15:00:06 +1000956 request->count = entry->buf_count;
957 request->size = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
George Sapountzis3417f332006-10-24 12:03:04 -0700959 if (request->flags & _DRM_PCI_BUFFER_RO)
960 dma->flags = _DRM_DMA_USE_PCI_RO;
961
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000962 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 return 0;
964
965}
Dave Airlied84f76d2005-07-10 17:04:22 +1000966EXPORT_SYMBOL(drm_addbufs_pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Dave Airlie84b1fd12007-07-11 15:53:27 +1000968static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969{
Dave Airliecdd55a22007-07-11 16:32:08 +1000970 struct drm_device_dma *dma = dev->dma;
971 struct drm_buf_entry *entry;
Dave Airlie056219e2007-07-11 16:17:42 +1000972 struct drm_buf *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 unsigned long offset;
974 unsigned long agp_offset;
975 int count;
976 int order;
977 int size;
978 int alignment;
979 int page_order;
980 int total;
981 int byte_count;
982 int i;
Dave Airlie056219e2007-07-11 16:17:42 +1000983 struct drm_buf **temp_buflist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000985 if (!drm_core_check_feature(dev, DRIVER_SG))
986 return -EINVAL;
987
988 if (!dma)
989 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Dave Airlied985c102006-01-02 21:32:48 +1100991 if (!capable(CAP_SYS_ADMIN))
992 return -EPERM;
993
Dave Airlied59431b2005-07-10 15:00:06 +1000994 count = request->count;
995 order = drm_order(request->size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 size = 1 << order;
997
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000998 alignment = (request->flags & _DRM_PAGE_ALIGN)
999 ? PAGE_ALIGN(size) : size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
1001 total = PAGE_SIZE << page_order;
1002
1003 byte_count = 0;
Dave Airlied59431b2005-07-10 15:00:06 +10001004 agp_offset = request->agp_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001006 DRM_DEBUG("count: %d\n", count);
1007 DRM_DEBUG("order: %d\n", order);
1008 DRM_DEBUG("size: %d\n", size);
1009 DRM_DEBUG("agp_offset: %lu\n", agp_offset);
1010 DRM_DEBUG("alignment: %d\n", alignment);
1011 DRM_DEBUG("page_order: %d\n", page_order);
1012 DRM_DEBUG("total: %d\n", total);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001014 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1015 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001017 spin_lock(&dev->count_lock);
1018 if (dev->buf_use) {
1019 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 return -EBUSY;
1021 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001022 atomic_inc(&dev->buf_alloc);
1023 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
Dave Airlie30e2fb12006-02-02 19:37:46 +11001025 mutex_lock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 entry = &dma->bufs[order];
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001027 if (entry->buf_count) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001028 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001029 atomic_dec(&dev->buf_alloc);
1030 return -ENOMEM; /* May only call once for each order */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
1032
1033 if (count < 0 || count > 4096) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001034 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001035 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 return -EINVAL;
1037 }
1038
Davidlohr Bueso94e33702010-08-11 09:18:52 -04001039 entry->buflist = kzalloc(count * sizeof(*entry->buflist),
Eric Anholt9a298b22009-03-24 12:23:04 -07001040 GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001041 if (!entry->buflist) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001042 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001043 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 return -ENOMEM;
1045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
1047 entry->buf_size = size;
1048 entry->page_order = page_order;
1049
1050 offset = 0;
1051
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001052 while (entry->buf_count < count) {
1053 buf = &entry->buflist[entry->buf_count];
1054 buf->idx = dma->buf_count + entry->buf_count;
1055 buf->total = alignment;
1056 buf->order = order;
1057 buf->used = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001059 buf->offset = (dma->byte_count + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 buf->bus_address = agp_offset + offset;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001061 buf->address = (void *)(agp_offset + offset
Dave Airlied1f2b552005-08-05 22:11:22 +10001062 + (unsigned long)dev->sg->virtual);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001063 buf->next = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 buf->waiting = 0;
1065 buf->pending = 0;
Eric Anholt6c340ea2007-08-25 20:23:09 +10001066 buf->file_priv = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068 buf->dev_priv_size = dev->driver->dev_priv_size;
Davidlohr Bueso94e33702010-08-11 09:18:52 -04001069 buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001070 if (!buf->dev_private) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 /* Set count correctly so we free the proper amount. */
1072 entry->buf_count = count;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001073 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +11001074 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001075 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 return -ENOMEM;
1077 }
1078
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001079 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 offset += alignment;
1082 entry->buf_count++;
1083 byte_count += PAGE_SIZE << page_order;
1084 }
1085
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001086 DRM_DEBUG("byte_count: %d\n", byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Eric Anholt9a298b22009-03-24 12:23:04 -07001088 temp_buflist = krealloc(dma->buflist,
1089 (dma->buf_count + entry->buf_count) *
1090 sizeof(*dma->buflist), GFP_KERNEL);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001091 if (!temp_buflist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 /* Free the entry because it isn't valid */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001093 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +11001094 mutex_unlock(&dev->struct_mutex);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001095 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 return -ENOMEM;
1097 }
1098 dma->buflist = temp_buflist;
1099
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001100 for (i = 0; i < entry->buf_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
1102 }
1103
1104 dma->buf_count += entry->buf_count;
Dave Airlied985c102006-01-02 21:32:48 +11001105 dma->seg_count += entry->seg_count;
1106 dma->page_count += byte_count >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 dma->byte_count += byte_count;
1108
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001109 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
1110 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Dave Airlie30e2fb12006-02-02 19:37:46 +11001112 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Dave Airlied59431b2005-07-10 15:00:06 +10001114 request->count = entry->buf_count;
1115 request->size = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117 dma->flags = _DRM_DMA_USE_SG;
1118
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001119 atomic_dec(&dev->buf_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 return 0;
1121}
1122
Dave Airlie84b1fd12007-07-11 15:53:27 +10001123static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request)
Dave Airlieb84397d62005-07-10 14:46:12 +10001124{
Dave Airliecdd55a22007-07-11 16:32:08 +10001125 struct drm_device_dma *dma = dev->dma;
1126 struct drm_buf_entry *entry;
Dave Airlie056219e2007-07-11 16:17:42 +10001127 struct drm_buf *buf;
Dave Airlieb84397d62005-07-10 14:46:12 +10001128 unsigned long offset;
1129 unsigned long agp_offset;
1130 int count;
1131 int order;
1132 int size;
1133 int alignment;
1134 int page_order;
1135 int total;
1136 int byte_count;
1137 int i;
Dave Airlie056219e2007-07-11 16:17:42 +10001138 struct drm_buf **temp_buflist;
Dave Airlieb84397d62005-07-10 14:46:12 +10001139
1140 if (!drm_core_check_feature(dev, DRIVER_FB_DMA))
1141 return -EINVAL;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001142
Dave Airlieb84397d62005-07-10 14:46:12 +10001143 if (!dma)
1144 return -EINVAL;
1145
Dave Airlied985c102006-01-02 21:32:48 +11001146 if (!capable(CAP_SYS_ADMIN))
1147 return -EPERM;
1148
Dave Airlied59431b2005-07-10 15:00:06 +10001149 count = request->count;
1150 order = drm_order(request->size);
Dave Airlieb84397d62005-07-10 14:46:12 +10001151 size = 1 << order;
1152
Dave Airlied59431b2005-07-10 15:00:06 +10001153 alignment = (request->flags & _DRM_PAGE_ALIGN)
Dave Airlieb84397d62005-07-10 14:46:12 +10001154 ? PAGE_ALIGN(size) : size;
1155 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
1156 total = PAGE_SIZE << page_order;
1157
1158 byte_count = 0;
Dave Airlied59431b2005-07-10 15:00:06 +10001159 agp_offset = request->agp_start;
Dave Airlieb84397d62005-07-10 14:46:12 +10001160
1161 DRM_DEBUG("count: %d\n", count);
1162 DRM_DEBUG("order: %d\n", order);
1163 DRM_DEBUG("size: %d\n", size);
1164 DRM_DEBUG("agp_offset: %lu\n", agp_offset);
1165 DRM_DEBUG("alignment: %d\n", alignment);
1166 DRM_DEBUG("page_order: %d\n", page_order);
1167 DRM_DEBUG("total: %d\n", total);
1168
1169 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1170 return -EINVAL;
Dave Airlieb84397d62005-07-10 14:46:12 +10001171
1172 spin_lock(&dev->count_lock);
1173 if (dev->buf_use) {
1174 spin_unlock(&dev->count_lock);
1175 return -EBUSY;
1176 }
1177 atomic_inc(&dev->buf_alloc);
1178 spin_unlock(&dev->count_lock);
1179
Dave Airlie30e2fb12006-02-02 19:37:46 +11001180 mutex_lock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001181 entry = &dma->bufs[order];
1182 if (entry->buf_count) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001183 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001184 atomic_dec(&dev->buf_alloc);
1185 return -ENOMEM; /* May only call once for each order */
1186 }
1187
1188 if (count < 0 || count > 4096) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001189 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001190 atomic_dec(&dev->buf_alloc);
1191 return -EINVAL;
1192 }
1193
Davidlohr Bueso94e33702010-08-11 09:18:52 -04001194 entry->buflist = kzalloc(count * sizeof(*entry->buflist),
Eric Anholt9a298b22009-03-24 12:23:04 -07001195 GFP_KERNEL);
Dave Airlieb84397d62005-07-10 14:46:12 +10001196 if (!entry->buflist) {
Dave Airlie30e2fb12006-02-02 19:37:46 +11001197 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001198 atomic_dec(&dev->buf_alloc);
1199 return -ENOMEM;
1200 }
Dave Airlieb84397d62005-07-10 14:46:12 +10001201
1202 entry->buf_size = size;
1203 entry->page_order = page_order;
1204
1205 offset = 0;
1206
1207 while (entry->buf_count < count) {
1208 buf = &entry->buflist[entry->buf_count];
1209 buf->idx = dma->buf_count + entry->buf_count;
1210 buf->total = alignment;
1211 buf->order = order;
1212 buf->used = 0;
1213
1214 buf->offset = (dma->byte_count + offset);
1215 buf->bus_address = agp_offset + offset;
1216 buf->address = (void *)(agp_offset + offset);
1217 buf->next = NULL;
1218 buf->waiting = 0;
1219 buf->pending = 0;
Eric Anholt6c340ea2007-08-25 20:23:09 +10001220 buf->file_priv = NULL;
Dave Airlieb84397d62005-07-10 14:46:12 +10001221
1222 buf->dev_priv_size = dev->driver->dev_priv_size;
Davidlohr Bueso94e33702010-08-11 09:18:52 -04001223 buf->dev_private = kzalloc(buf->dev_priv_size, GFP_KERNEL);
Dave Airlieb84397d62005-07-10 14:46:12 +10001224 if (!buf->dev_private) {
1225 /* Set count correctly so we free the proper amount. */
1226 entry->buf_count = count;
1227 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +11001228 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001229 atomic_dec(&dev->buf_alloc);
1230 return -ENOMEM;
1231 }
Dave Airlieb84397d62005-07-10 14:46:12 +10001232
1233 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
1234
1235 offset += alignment;
1236 entry->buf_count++;
1237 byte_count += PAGE_SIZE << page_order;
1238 }
1239
1240 DRM_DEBUG("byte_count: %d\n", byte_count);
1241
Eric Anholt9a298b22009-03-24 12:23:04 -07001242 temp_buflist = krealloc(dma->buflist,
1243 (dma->buf_count + entry->buf_count) *
1244 sizeof(*dma->buflist), GFP_KERNEL);
Dave Airlieb84397d62005-07-10 14:46:12 +10001245 if (!temp_buflist) {
1246 /* Free the entry because it isn't valid */
1247 drm_cleanup_buf_error(dev, entry);
Dave Airlie30e2fb12006-02-02 19:37:46 +11001248 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001249 atomic_dec(&dev->buf_alloc);
1250 return -ENOMEM;
1251 }
1252 dma->buflist = temp_buflist;
1253
1254 for (i = 0; i < entry->buf_count; i++) {
1255 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
1256 }
1257
1258 dma->buf_count += entry->buf_count;
Dave Airlied985c102006-01-02 21:32:48 +11001259 dma->seg_count += entry->seg_count;
1260 dma->page_count += byte_count >> PAGE_SHIFT;
Dave Airlieb84397d62005-07-10 14:46:12 +10001261 dma->byte_count += byte_count;
1262
1263 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
1264 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
1265
Dave Airlie30e2fb12006-02-02 19:37:46 +11001266 mutex_unlock(&dev->struct_mutex);
Dave Airlieb84397d62005-07-10 14:46:12 +10001267
Dave Airlied59431b2005-07-10 15:00:06 +10001268 request->count = entry->buf_count;
1269 request->size = size;
Dave Airlieb84397d62005-07-10 14:46:12 +10001270
1271 dma->flags = _DRM_DMA_USE_FB;
1272
1273 atomic_dec(&dev->buf_alloc);
1274 return 0;
1275}
Dave Airlied985c102006-01-02 21:32:48 +11001276
Dave Airlieb84397d62005-07-10 14:46:12 +10001277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278/**
1279 * Add buffers for DMA transfers (ioctl).
1280 *
1281 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001282 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 * \param cmd command.
Dave Airliec60ce622007-07-11 15:27:12 +10001284 * \param arg pointer to a struct drm_buf_desc request.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 * \return zero on success or a negative number on failure.
1286 *
1287 * According with the memory type specified in drm_buf_desc::flags and the
1288 * build options, it dispatches the call either to addbufs_agp(),
1289 * addbufs_sg() or addbufs_pci() for AGP, scatter-gather or consistent
1290 * PCI memory respectively.
1291 */
Eric Anholtc153f452007-09-03 12:06:45 +10001292int drm_addbufs(struct drm_device *dev, void *data,
1293 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294{
Eric Anholtc153f452007-09-03 12:06:45 +10001295 struct drm_buf_desc *request = data;
Dave Airlied59431b2005-07-10 15:00:06 +10001296 int ret;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001297
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1299 return -EINVAL;
1300
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301#if __OS_HAS_AGP
Eric Anholtc153f452007-09-03 12:06:45 +10001302 if (request->flags & _DRM_AGP_BUFFER)
1303 ret = drm_addbufs_agp(dev, request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 else
1305#endif
Eric Anholtc153f452007-09-03 12:06:45 +10001306 if (request->flags & _DRM_SG_BUFFER)
1307 ret = drm_addbufs_sg(dev, request);
1308 else if (request->flags & _DRM_FB_BUFFER)
1309 ret = drm_addbufs_fb(dev, request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 else
Eric Anholtc153f452007-09-03 12:06:45 +10001311 ret = drm_addbufs_pci(dev, request);
Dave Airlied59431b2005-07-10 15:00:06 +10001312
Dave Airlied59431b2005-07-10 15:00:06 +10001313 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
1315
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316/**
1317 * Get information about the buffer mappings.
1318 *
1319 * This was originally mean for debugging purposes, or by a sophisticated
1320 * client library to determine how best to use the available buffers (e.g.,
1321 * large buffers can be used for image transfer).
1322 *
1323 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001324 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 * \param cmd command.
1326 * \param arg pointer to a drm_buf_info structure.
1327 * \return zero on success or a negative number on failure.
1328 *
1329 * Increments drm_device::buf_use while holding the drm_device::count_lock
1330 * lock, preventing of allocating more buffers after this call. Information
1331 * about each requested buffer is then copied into user space.
1332 */
Eric Anholtc153f452007-09-03 12:06:45 +10001333int drm_infobufs(struct drm_device *dev, void *data,
1334 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335{
Dave Airliecdd55a22007-07-11 16:32:08 +10001336 struct drm_device_dma *dma = dev->dma;
Eric Anholtc153f452007-09-03 12:06:45 +10001337 struct drm_buf_info *request = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 int i;
1339 int count;
1340
1341 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1342 return -EINVAL;
1343
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001344 if (!dma)
1345 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001347 spin_lock(&dev->count_lock);
1348 if (atomic_read(&dev->buf_alloc)) {
1349 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 return -EBUSY;
1351 }
1352 ++dev->buf_use; /* Can't allocate more after this call */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001353 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001355 for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
1356 if (dma->bufs[i].buf_count)
1357 ++count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 }
1359
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001360 DRM_DEBUG("count = %d\n", count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361
Eric Anholtc153f452007-09-03 12:06:45 +10001362 if (request->count >= count) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001363 for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
1364 if (dma->bufs[i].buf_count) {
Dave Airliec60ce622007-07-11 15:27:12 +10001365 struct drm_buf_desc __user *to =
Eric Anholtc153f452007-09-03 12:06:45 +10001366 &request->list[count];
Dave Airliecdd55a22007-07-11 16:32:08 +10001367 struct drm_buf_entry *from = &dma->bufs[i];
1368 struct drm_freelist *list = &dma->bufs[i].freelist;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001369 if (copy_to_user(&to->count,
1370 &from->buf_count,
1371 sizeof(from->buf_count)) ||
1372 copy_to_user(&to->size,
1373 &from->buf_size,
1374 sizeof(from->buf_size)) ||
1375 copy_to_user(&to->low_mark,
1376 &list->low_mark,
1377 sizeof(list->low_mark)) ||
1378 copy_to_user(&to->high_mark,
1379 &list->high_mark,
1380 sizeof(list->high_mark)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 return -EFAULT;
1382
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001383 DRM_DEBUG("%d %d %d %d %d\n",
1384 i,
1385 dma->bufs[i].buf_count,
1386 dma->bufs[i].buf_size,
1387 dma->bufs[i].freelist.low_mark,
1388 dma->bufs[i].freelist.high_mark);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 ++count;
1390 }
1391 }
1392 }
Eric Anholtc153f452007-09-03 12:06:45 +10001393 request->count = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 return 0;
1396}
1397
1398/**
1399 * Specifies a low and high water mark for buffer allocation
1400 *
1401 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001402 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 * \param cmd command.
1404 * \param arg a pointer to a drm_buf_desc structure.
1405 * \return zero on success or a negative number on failure.
1406 *
1407 * Verifies that the size order is bounded between the admissible orders and
1408 * updates the respective drm_device_dma::bufs entry low and high water mark.
1409 *
1410 * \note This ioctl is deprecated and mostly never used.
1411 */
Eric Anholtc153f452007-09-03 12:06:45 +10001412int drm_markbufs(struct drm_device *dev, void *data,
1413 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414{
Dave Airliecdd55a22007-07-11 16:32:08 +10001415 struct drm_device_dma *dma = dev->dma;
Eric Anholtc153f452007-09-03 12:06:45 +10001416 struct drm_buf_desc *request = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 int order;
Dave Airliecdd55a22007-07-11 16:32:08 +10001418 struct drm_buf_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
1420 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1421 return -EINVAL;
1422
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001423 if (!dma)
1424 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001426 DRM_DEBUG("%d, %d, %d\n",
Eric Anholtc153f452007-09-03 12:06:45 +10001427 request->size, request->low_mark, request->high_mark);
1428 order = drm_order(request->size);
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001429 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1430 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 entry = &dma->bufs[order];
1432
Eric Anholtc153f452007-09-03 12:06:45 +10001433 if (request->low_mark < 0 || request->low_mark > entry->buf_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 return -EINVAL;
Eric Anholtc153f452007-09-03 12:06:45 +10001435 if (request->high_mark < 0 || request->high_mark > entry->buf_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 return -EINVAL;
1437
Eric Anholtc153f452007-09-03 12:06:45 +10001438 entry->freelist.low_mark = request->low_mark;
1439 entry->freelist.high_mark = request->high_mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441 return 0;
1442}
1443
1444/**
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001445 * Unreserve the buffers in list, previously reserved using drmDMA.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 *
1447 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001448 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 * \param cmd command.
1450 * \param arg pointer to a drm_buf_free structure.
1451 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001452 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 * Calls free_buffer() for each used buffer.
1454 * This function is primarily used for debugging.
1455 */
Eric Anholtc153f452007-09-03 12:06:45 +10001456int drm_freebufs(struct drm_device *dev, void *data,
1457 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
Dave Airliecdd55a22007-07-11 16:32:08 +10001459 struct drm_device_dma *dma = dev->dma;
Eric Anholtc153f452007-09-03 12:06:45 +10001460 struct drm_buf_free *request = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 int i;
1462 int idx;
Dave Airlie056219e2007-07-11 16:17:42 +10001463 struct drm_buf *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
1465 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1466 return -EINVAL;
1467
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001468 if (!dma)
1469 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Eric Anholtc153f452007-09-03 12:06:45 +10001471 DRM_DEBUG("%d\n", request->count);
1472 for (i = 0; i < request->count; i++) {
1473 if (copy_from_user(&idx, &request->list[i], sizeof(idx)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 return -EFAULT;
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001475 if (idx < 0 || idx >= dma->buf_count) {
1476 DRM_ERROR("Index %d (of %d max)\n",
1477 idx, dma->buf_count - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 return -EINVAL;
1479 }
1480 buf = dma->buflist[idx];
Eric Anholt6c340ea2007-08-25 20:23:09 +10001481 if (buf->file_priv != file_priv) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001482 DRM_ERROR("Process %d freeing buffer not owned\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -07001483 task_pid_nr(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 return -EINVAL;
1485 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001486 drm_free_buffer(dev, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 }
1488
1489 return 0;
1490}
1491
1492/**
1493 * Maps all of the DMA buffers into client-virtual space (ioctl).
1494 *
1495 * \param inode device inode.
Eric Anholt6c340ea2007-08-25 20:23:09 +10001496 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 * \param cmd command.
1498 * \param arg pointer to a drm_buf_map structure.
1499 * \return zero on success or a negative number on failure.
1500 *
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001501 * Maps the AGP, SG or PCI buffer region with vm_mmap(), and copies information
1502 * about each buffer into user space. For PCI buffers, it calls vm_mmap() with
George Sapountzis3417f332006-10-24 12:03:04 -07001503 * offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
1504 * drm_mmap_dma().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 */
Eric Anholtc153f452007-09-03 12:06:45 +10001506int drm_mapbufs(struct drm_device *dev, void *data,
1507 struct drm_file *file_priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508{
Dave Airliecdd55a22007-07-11 16:32:08 +10001509 struct drm_device_dma *dma = dev->dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 int retcode = 0;
1511 const int zero = 0;
1512 unsigned long virtual;
1513 unsigned long address;
Eric Anholtc153f452007-09-03 12:06:45 +10001514 struct drm_buf_map *request = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 int i;
1516
1517 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1518 return -EINVAL;
1519
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001520 if (!dma)
1521 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001523 spin_lock(&dev->count_lock);
1524 if (atomic_read(&dev->buf_alloc)) {
1525 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 return -EBUSY;
1527 }
1528 dev->buf_use++; /* Can't allocate more after this call */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001529 spin_unlock(&dev->count_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Eric Anholtc153f452007-09-03 12:06:45 +10001531 if (request->count >= dma->buf_count) {
Dave Airlieb84397d62005-07-10 14:46:12 +10001532 if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP))
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001533 || (drm_core_check_feature(dev, DRIVER_SG)
Dave Airlieb84397d62005-07-10 14:46:12 +10001534 && (dma->flags & _DRM_DMA_USE_SG))
1535 || (drm_core_check_feature(dev, DRIVER_FB_DMA)
1536 && (dma->flags & _DRM_DMA_USE_FB))) {
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +11001537 struct drm_local_map *map = dev->agp_buffer_map;
Dave Airlied1f2b552005-08-05 22:11:22 +10001538 unsigned long token = dev->agp_buffer_token;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001540 if (!map) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 retcode = -EINVAL;
1542 goto done;
1543 }
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001544 virtual = vm_mmap(file_priv->filp, 0, map->size,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001545 PROT_READ | PROT_WRITE,
Eric Anholtc153f452007-09-03 12:06:45 +10001546 MAP_SHARED,
1547 token);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 } else {
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001549 virtual = vm_mmap(file_priv->filp, 0, dma->byte_count,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001550 PROT_READ | PROT_WRITE,
1551 MAP_SHARED, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001553 if (virtual > -1024UL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 /* Real error */
1555 retcode = (signed long)virtual;
1556 goto done;
1557 }
Eric Anholtc153f452007-09-03 12:06:45 +10001558 request->virtual = (void __user *)virtual;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001560 for (i = 0; i < dma->buf_count; i++) {
Eric Anholtc153f452007-09-03 12:06:45 +10001561 if (copy_to_user(&request->list[i].idx,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001562 &dma->buflist[i]->idx,
Eric Anholtc153f452007-09-03 12:06:45 +10001563 sizeof(request->list[0].idx))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 retcode = -EFAULT;
1565 goto done;
1566 }
Eric Anholtc153f452007-09-03 12:06:45 +10001567 if (copy_to_user(&request->list[i].total,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001568 &dma->buflist[i]->total,
Eric Anholtc153f452007-09-03 12:06:45 +10001569 sizeof(request->list[0].total))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 retcode = -EFAULT;
1571 goto done;
1572 }
Eric Anholtc153f452007-09-03 12:06:45 +10001573 if (copy_to_user(&request->list[i].used,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001574 &zero, sizeof(zero))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 retcode = -EFAULT;
1576 goto done;
1577 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001578 address = virtual + dma->buflist[i]->offset; /* *** */
Eric Anholtc153f452007-09-03 12:06:45 +10001579 if (copy_to_user(&request->list[i].address,
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001580 &address, sizeof(address))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 retcode = -EFAULT;
1582 goto done;
1583 }
1584 }
1585 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001586 done:
Eric Anholtc153f452007-09-03 12:06:45 +10001587 request->count = dma->buf_count;
1588 DRM_DEBUG("%d buffers, retcode = %d\n", request->count, retcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 return retcode;
1591}
1592
Dave Airlie836cf042005-07-10 19:27:04 +10001593/**
1594 * Compute size order. Returns the exponent of the smaller power of two which
1595 * is greater or equal to given number.
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001596 *
Dave Airlie836cf042005-07-10 19:27:04 +10001597 * \param size size.
1598 * \return order.
1599 *
1600 * \todo Can be made faster.
1601 */
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001602int drm_order(unsigned long size)
Dave Airlie836cf042005-07-10 19:27:04 +10001603{
1604 int order;
1605 unsigned long tmp;
1606
Dave Airlieb5e89ed2005-09-25 14:28:13 +10001607 for (order = 0, tmp = size >> 1; tmp; tmp >>= 1, order++) ;
Dave Airlie836cf042005-07-10 19:27:04 +10001608
1609 if (size & (size - 1))
1610 ++order;
1611
1612 return order;
1613}
1614EXPORT_SYMBOL(drm_order);