projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / drm / drm_bufs.c
1 /**
2 * \file drm_bufs.c
3 * Generic buffer template
4 *
5 * \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>
37 #include "drmP.h"
38
39 unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource)
40 {
41 return pci_resource_start(dev->pdev, resource);
42 }
43 EXPORT_SYMBOL(drm_get_resource_start);
44
45 unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource)
46 {
47 return pci_resource_len(dev->pdev, resource);
48 }
49
50 EXPORT_SYMBOL(drm_get_resource_len);
51
52 static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
53 drm_local_map_t *map)
54 {
55 struct list_head *list;
56
57 list_for_each(list, &dev->maplist->head) {
58 drm_map_list_t *entry = list_entry(list, drm_map_list_t, head);
59 if (entry->map && map->type == entry->map->type &&
60 ((entry->map->offset == map->offset) ||
61 (map->type == _DRM_SHM && map->flags==_DRM_CONTAINS_LOCK))) {
62 return entry;
63 }
64 }
65
66 return NULL;
67 }
68
69 static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
70 unsigned long user_token, int hashed_handle)
71 {
72 int use_hashed_handle;
73 #if (BITS_PER_LONG == 64)
74 use_hashed_handle = ((user_token & 0xFFFFFFFF00000000UL) || hashed_handle);
75 #elif (BITS_PER_LONG == 32)
76 use_hashed_handle = hashed_handle;
77 #else
78 #error Unsupported long size. Neither 64 nor 32 bits.
79 #endif
80
81 if (!use_hashed_handle) {
82 int ret;
83 hash->key = user_token >> PAGE_SHIFT;
84 ret = drm_ht_insert_item(&dev->map_hash, hash);
85 if (ret != -EINVAL)
86 return ret;
87 }
88 return drm_ht_just_insert_please(&dev->map_hash, hash,
89 user_token, 32 - PAGE_SHIFT - 3,
90 0, DRM_MAP_HASH_OFFSET >> PAGE_SHIFT);
91 }
92
93 /**
94 * Ioctl to specify a range of memory that is available for mapping by a non-root process.
95 *
96 * \param inode device inode.
97 * \param filp file pointer.
98 * \param cmd command.
99 * \param arg pointer to a drm_map structure.
100 * \return zero on success or a negative value on error.
101 *
102 * Adjusts the memory offset to its absolute value according to the mapping
103 * type. Adds the map to the map list drm_device::maplist. Adds MTRR's where
104 * applicable and if supported by the kernel.
105 */
106 static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
107 unsigned int size, drm_map_type_t type,
108 drm_map_flags_t flags, drm_map_list_t ** maplist)
109 {
110 drm_map_t *map;
111 drm_map_list_t *list;
112 drm_dma_handle_t *dmah;
113 unsigned long user_token;
114 int ret;
115
116 map = drm_alloc(sizeof(*map), DRM_MEM_MAPS);
117 if (!map)
118 return -ENOMEM;
119
120 map->offset = offset;
121 map->size = size;
122 map->flags = flags;
123 map->type = type;
124
125 /* Only allow shared memory to be removable since we only keep enough
126 * book keeping information about shared memory to allow for removal
127 * when processes fork.
128 */
129 if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {
130 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
131 return -EINVAL;
132 }
133 DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n",
134 map->offset, map->size, map->type);
135 if ((map->offset & (~PAGE_MASK)) || (map->size & (~PAGE_MASK))) {
136 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
137 return -EINVAL;
138 }
139 map->mtrr = -1;
140 map->handle = NULL;
141
142 switch (map->type) {
143 case _DRM_REGISTERS:
144 case _DRM_FRAME_BUFFER:
145 #if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__)
146 if (map->offset + (map->size-1) < map->offset ||
147 map->offset < virt_to_phys(high_memory)) {
148 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
149 return -EINVAL;
150 }
151 #endif
152 #ifdef __alpha__
153 map->offset += dev->hose->mem_space->start;
154 #endif
155 /* Some drivers preinitialize some maps, without the X Server
156 * needing to be aware of it. Therefore, we just return success
157 * when the server tries to create a duplicate map.
158 */
159 list = drm_find_matching_map(dev, map);
160 if (list != NULL) {
161 if (list->map->size != map->size) {
162 DRM_DEBUG("Matching maps of type %d with "
163 "mismatched sizes, (%ld vs %ld)\n",
164 map->type, map->size,
165 list->map->size);
166 list->map->size = map->size;
167 }
168
169 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
170 *maplist = list;
171 return 0;
172 }
173
174 if (drm_core_has_MTRR(dev)) {
175 if (map->type == _DRM_FRAME_BUFFER ||
176 (map->flags & _DRM_WRITE_COMBINING)) {
177 map->mtrr = mtrr_add(map->offset, map->size,
178 MTRR_TYPE_WRCOMB, 1);
179 }
180 }
181 if (map->type == _DRM_REGISTERS)
182 map->handle = ioremap(map->offset, map->size);
183 break;
184 case _DRM_SHM:
185 list = drm_find_matching_map(dev, map);
186 if (list != NULL) {
187 if(list->map->size != map->size) {
188 DRM_DEBUG("Matching maps of type %d with "
189 "mismatched sizes, (%ld vs %ld)\n",
190 map->type, map->size, list->map->size);
191 list->map->size = map->size;
192 }
193
194 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
195 *maplist = list;
196 return 0;
197 }
198 map->handle = vmalloc_user(map->size);
199 DRM_DEBUG("%lu %d %p\n",
200 map->size, drm_order(map->size), map->handle);
201 if (!map->handle) {
202 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
203 return -ENOMEM;
204 }
205 map->offset = (unsigned long)map->handle;
206 if (map->flags & _DRM_CONTAINS_LOCK) {
207 /* Prevent a 2nd X Server from creating a 2nd lock */
208 if (dev->lock.hw_lock != NULL) {
209 vfree(map->handle);
210 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
211 return -EBUSY;
212 }
213 dev->sigdata.lock = dev->lock.hw_lock = map->handle; /* Pointer to lock */
214 }
215 break;
216 case _DRM_AGP: {
217 drm_agp_mem_t *entry;
218 int valid = 0;
219
220 if (!drm_core_has_AGP(dev)) {
221 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
222 return -EINVAL;
223 }
224 #ifdef __alpha__
225 map->offset += dev->hose->mem_space->start;
226 #endif
227 /* Note: dev->agp->base may actually be 0 when the DRM
228 * is not in control of AGP space. But if user space is
229 * it should already have added the AGP base itself.
230 */
231 map->offset += dev->agp->base;
232 map->mtrr = dev->agp->agp_mtrr; /* for getmap */
233
234 /* This assumes the DRM is in total control of AGP space.
235 * It's not always the case as AGP can be in the control
236 * of user space (i.e. i810 driver). So this loop will get
237 * skipped and we double check that dev->agp->memory is
238 * actually set as well as being invalid before EPERM'ing
239 */
240 for (entry = dev->agp->memory; entry; entry = entry->next) {
241 if ((map->offset >= entry->bound) &&
242 (map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {
243 valid = 1;
244 break;
245 }
246 }
247 if (dev->agp->memory && !valid) {
248 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
249 return -EPERM;
250 }
251 DRM_DEBUG("AGP offset = 0x%08lx, size = 0x%08lx\n", map->offset, map->size);
252
253 break;
254 }
255 case _DRM_SCATTER_GATHER:
256 if (!dev->sg) {
257 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
258 return -EINVAL;
259 }
260 map->offset += (unsigned long)dev->sg->virtual;
261 break;
262 case _DRM_CONSISTENT:
263 /* dma_addr_t is 64bit on i386 with CONFIG_HIGHMEM64G,
264 * As we're limiting the address to 2^32-1 (or less),
265 * casting it down to 32 bits is no problem, but we
266 * need to point to a 64bit variable first. */
267 dmah = drm_pci_alloc(dev, map->size, map->size, 0xffffffffUL);
268 if (!dmah) {
269 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
270 return -ENOMEM;
271 }
272 map->handle = dmah->vaddr;
273 map->offset = (unsigned long)dmah->busaddr;
274 kfree(dmah);
275 break;
276 default:
277 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
278 return -EINVAL;
279 }
280
281 list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
282 if (!list) {
283 if (map->type == _DRM_REGISTERS)
284 iounmap(map->handle);
285 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
286 return -EINVAL;
287 }
288 memset(list, 0, sizeof(*list));
289 list->map = map;
290
291 mutex_lock(&dev->struct_mutex);
292 list_add(&list->head, &dev->maplist->head);
293
294 /* Assign a 32-bit handle */
295 /* We do it here so that dev->struct_mutex protects the increment */
296 user_token = (map->type == _DRM_SHM) ? (unsigned long)map->handle :
297 map->offset;
298 ret = drm_map_handle(dev, &list->hash, user_token, 0);
299 if (ret) {
300 if (map->type == _DRM_REGISTERS)
301 iounmap(map->handle);
302 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
303 drm_free(list, sizeof(*list), DRM_MEM_MAPS);
304 mutex_unlock(&dev->struct_mutex);
305 return ret;
306 }
307
308 list->user_token = list->hash.key << PAGE_SHIFT;
309 mutex_unlock(&dev->struct_mutex);
310
311 *maplist = list;
312 return 0;
313 }
314
315 int drm_addmap(drm_device_t * dev, unsigned int offset,
316 unsigned int size, drm_map_type_t type,
317 drm_map_flags_t flags, drm_local_map_t ** map_ptr)
318 {
319 drm_map_list_t *list;
320 int rc;
321
322 rc = drm_addmap_core(dev, offset, size, type, flags, &list);
323 if (!rc)
324 *map_ptr = list->map;
325 return rc;
326 }
327
328 EXPORT_SYMBOL(drm_addmap);
329
330 int drm_addmap_ioctl(struct inode *inode, struct file *filp,
331 unsigned int cmd, unsigned long arg)
332 {
333 drm_file_t *priv = filp->private_data;
334 drm_device_t *dev = priv->head->dev;
335 drm_map_t map;
336 drm_map_list_t *maplist;
337 drm_map_t __user *argp = (void __user *)arg;
338 int err;
339
340 if (!(filp->f_mode & 3))
341 return -EACCES; /* Require read/write */
342
343 if (copy_from_user(&map, argp, sizeof(map))) {
344 return -EFAULT;
345 }
346
347 if (!(capable(CAP_SYS_ADMIN) || map.type == _DRM_AGP))
348 return -EPERM;
349
350 err = drm_addmap_core(dev, map.offset, map.size, map.type, map.flags,
351 &maplist);
352
353 if (err)
354 return err;
355
356 if (copy_to_user(argp, maplist->map, sizeof(drm_map_t)))
357 return -EFAULT;
358
359 /* avoid a warning on 64-bit, this casting isn't very nice, but the API is set so too late */
360 if (put_user((void *)(unsigned long)maplist->user_token, &argp->handle))
361 return -EFAULT;
362 return 0;
363 }
364
365 /**
366 * Remove a map private from list and deallocate resources if the mapping
367 * isn't in use.
368 *
369 * \param inode device inode.
370 * \param filp file pointer.
371 * \param cmd command.
372 * \param arg pointer to a drm_map_t structure.
373 * \return zero on success or a negative value on error.
374 *
375 * Searches the map on drm_device::maplist, removes it from the list, see if
376 * its being used, and free any associate resource (such as MTRR's) if it's not
377 * being on use.
378 *
379 * \sa drm_addmap
380 */
381 int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
382 {
383 struct list_head *list;
384 drm_map_list_t *r_list = NULL;
385 drm_dma_handle_t dmah;
386
387 /* Find the list entry for the map and remove it */
388 list_for_each(list, &dev->maplist->head) {
389 r_list = list_entry(list, drm_map_list_t, head);
390
391 if (r_list->map == map) {
392 list_del(list);
393 drm_ht_remove_key(&dev->map_hash,
394 r_list->user_token >> PAGE_SHIFT);
395 drm_free(list, sizeof(*list), DRM_MEM_MAPS);
396 break;
397 }
398 }
399
400 /* List has wrapped around to the head pointer, or it's empty and we
401 * didn't find anything.
402 */
403 if (list == (&dev->maplist->head)) {
404 return -EINVAL;
405 }
406
407 switch (map->type) {
408 case _DRM_REGISTERS:
409 iounmap(map->handle);
410 /* FALLTHROUGH */
411 case _DRM_FRAME_BUFFER:
412 if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {
413 int retcode;
414 retcode = mtrr_del(map->mtrr, map->offset, map->size);
415 DRM_DEBUG("mtrr_del=%d\n", retcode);
416 }
417 break;
418 case _DRM_SHM:
419 vfree(map->handle);
420 break;
421 case _DRM_AGP:
422 case _DRM_SCATTER_GATHER:
423 break;
424 case _DRM_CONSISTENT:
425 dmah.vaddr = map->handle;
426 dmah.busaddr = map->offset;
427 dmah.size = map->size;
428 __drm_pci_free(dev, &dmah);
429 break;
430 }
431 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
432
433 return 0;
434 }
435
436 int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
437 {
438 int ret;
439
440 mutex_lock(&dev->struct_mutex);
441 ret = drm_rmmap_locked(dev, map);
442 mutex_unlock(&dev->struct_mutex);
443
444 return ret;
445 }
446
447 /* The rmmap ioctl appears to be unnecessary. All mappings are torn down on
448 * the last close of the device, and this is necessary for cleanup when things
449 * exit uncleanly. Therefore, having userland manually remove mappings seems
450 * like a pointless exercise since they're going away anyway.
451 *
452 * One use case might be after addmap is allowed for normal users for SHM and
453 * gets used by drivers that the server doesn't need to care about. This seems
454 * unlikely.
455 */
456 int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
457 unsigned int cmd, unsigned long arg)
458 {
459 drm_file_t *priv = filp->private_data;
460 drm_device_t *dev = priv->head->dev;
461 drm_map_t request;
462 drm_local_map_t *map = NULL;
463 struct list_head *list;
464 int ret;
465
466 if (copy_from_user(&request, (drm_map_t __user *) arg, sizeof(request))) {
467 return -EFAULT;
468 }
469
470 mutex_lock(&dev->struct_mutex);
471 list_for_each(list, &dev->maplist->head) {
472 drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
473
474 if (r_list->map &&
475 r_list->user_token == (unsigned long)request.handle &&
476 r_list->map->flags & _DRM_REMOVABLE) {
477 map = r_list->map;
478 break;
479 }
480 }
481
482 /* List has wrapped around to the head pointer, or its empty we didn't
483 * find anything.
484 */
485 if (list == (&dev->maplist->head)) {
486 mutex_unlock(&dev->struct_mutex);
487 return -EINVAL;
488 }
489
490 if (!map) {
491 mutex_unlock(&dev->struct_mutex);
492 return -EINVAL;
493 }
494
495 /* Register and framebuffer maps are permanent */
496 if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
497 mutex_unlock(&dev->struct_mutex);
498 return 0;
499 }
500
501 ret = drm_rmmap_locked(dev, map);
502
503 mutex_unlock(&dev->struct_mutex);
504
505 return ret;
506 }
507
508 /**
509 * Cleanup after an error on one of the addbufs() functions.
510 *
511 * \param dev DRM device.
512 * \param entry buffer entry where the error occurred.
513 *
514 * Frees any pages and buffers associated with the given entry.
515 */
516 static void drm_cleanup_buf_error(drm_device_t * dev, drm_buf_entry_t * entry)
517 {
518 int i;
519
520 if (entry->seg_count) {
521 for (i = 0; i < entry->seg_count; i++) {
522 if (entry->seglist[i]) {
523 drm_pci_free(dev, entry->seglist[i]);
524 }
525 }
526 drm_free(entry->seglist,
527 entry->seg_count *
528 sizeof(*entry->seglist), DRM_MEM_SEGS);
529
530 entry->seg_count = 0;
531 }
532
533 if (entry->buf_count) {
534 for (i = 0; i < entry->buf_count; i++) {
535 if (entry->buflist[i].dev_private) {
536 drm_free(entry->buflist[i].dev_private,
537 entry->buflist[i].dev_priv_size,
538 DRM_MEM_BUFS);
539 }
540 }
541 drm_free(entry->buflist,
542 entry->buf_count *
543 sizeof(*entry->buflist), DRM_MEM_BUFS);
544
545 entry->buf_count = 0;
546 }
547 }
548
549 #if __OS_HAS_AGP
550 /**
551 * Add AGP buffers for DMA transfers.
552 *
553 * \param dev drm_device_t to which the buffers are to be added.
554 * \param request pointer to a drm_buf_desc_t describing the request.
555 * \return zero on success or a negative number on failure.
556 *
557 * After some sanity checks creates a drm_buf structure for each buffer and
558 * reallocates the buffer list of the same size order to accommodate the new
559 * buffers.
560 */
561 int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
562 {
563 drm_device_dma_t *dma = dev->dma;
564 drm_buf_entry_t *entry;
565 drm_agp_mem_t *agp_entry;
566 drm_buf_t *buf;
567 unsigned long offset;
568 unsigned long agp_offset;
569 int count;
570 int order;
571 int size;
572 int alignment;
573 int page_order;
574 int total;
575 int byte_count;
576 int i, valid;
577 drm_buf_t **temp_buflist;
578
579 if (!dma)
580 return -EINVAL;
581
582 count = request->count;
583 order = drm_order(request->size);
584 size = 1 << order;
585
586 alignment = (request->flags & _DRM_PAGE_ALIGN)
587 ? PAGE_ALIGN(size) : size;
588 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
589 total = PAGE_SIZE << page_order;
590
591 byte_count = 0;
592 agp_offset = dev->agp->base + request->agp_start;
593
594 DRM_DEBUG("count: %d\n", count);
595 DRM_DEBUG("order: %d\n", order);
596 DRM_DEBUG("size: %d\n", size);
597 DRM_DEBUG("agp_offset: %lx\n", agp_offset);
598 DRM_DEBUG("alignment: %d\n", alignment);
599 DRM_DEBUG("page_order: %d\n", page_order);
600 DRM_DEBUG("total: %d\n", total);
601
602 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
603 return -EINVAL;
604 if (dev->queue_count)
605 return -EBUSY; /* Not while in use */
606
607 /* Make sure buffers are located in AGP memory that we own */
608 valid = 0;
609 for (agp_entry = dev->agp->memory; agp_entry; agp_entry = agp_entry->next) {
610 if ((agp_offset >= agp_entry->bound) &&
611 (agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
612 valid = 1;
613 break;
614 }
615 }
616 if (dev->agp->memory && !valid) {
617 DRM_DEBUG("zone invalid\n");
618 return -EINVAL;
619 }
620 spin_lock(&dev->count_lock);
621 if (dev->buf_use) {
622 spin_unlock(&dev->count_lock);
623 return -EBUSY;
624 }
625 atomic_inc(&dev->buf_alloc);
626 spin_unlock(&dev->count_lock);
627
628 mutex_lock(&dev->struct_mutex);
629 entry = &dma->bufs[order];
630 if (entry->buf_count) {
631 mutex_unlock(&dev->struct_mutex);
632 atomic_dec(&dev->buf_alloc);
633 return -ENOMEM; /* May only call once for each order */
634 }
635
636 if (count < 0 || count > 4096) {
637 mutex_unlock(&dev->struct_mutex);
638 atomic_dec(&dev->buf_alloc);
639 return -EINVAL;
640 }
641
642 entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
643 DRM_MEM_BUFS);
644 if (!entry->buflist) {
645 mutex_unlock(&dev->struct_mutex);
646 atomic_dec(&dev->buf_alloc);
647 return -ENOMEM;
648 }
649 memset(entry->buflist, 0, count * sizeof(*entry->buflist));
650
651 entry->buf_size = size;
652 entry->page_order = page_order;
653
654 offset = 0;
655
656 while (entry->buf_count < count) {
657 buf = &entry->buflist[entry->buf_count];
658 buf->idx = dma->buf_count + entry->buf_count;
659 buf->total = alignment;
660 buf->order = order;
661 buf->used = 0;
662
663 buf->offset = (dma->byte_count + offset);
664 buf->bus_address = agp_offset + offset;
665 buf->address = (void *)(agp_offset + offset);
666 buf->next = NULL;
667 buf->waiting = 0;
668 buf->pending = 0;
669 init_waitqueue_head(&buf->dma_wait);
670 buf->filp = NULL;
671
672 buf->dev_priv_size = dev->driver->dev_priv_size;
673 buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
674 if (!buf->dev_private) {
675 /* Set count correctly so we free the proper amount. */
676 entry->buf_count = count;
677 drm_cleanup_buf_error(dev, entry);
678 mutex_unlock(&dev->struct_mutex);
679 atomic_dec(&dev->buf_alloc);
680 return -ENOMEM;
681 }
682 memset(buf->dev_private, 0, buf->dev_priv_size);
683
684 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
685
686 offset += alignment;
687 entry->buf_count++;
688 byte_count += PAGE_SIZE << page_order;
689 }
690
691 DRM_DEBUG("byte_count: %d\n", byte_count);
692
693 temp_buflist = drm_realloc(dma->buflist,
694 dma->buf_count * sizeof(*dma->buflist),
695 (dma->buf_count + entry->buf_count)
696 * sizeof(*dma->buflist), DRM_MEM_BUFS);
697 if (!temp_buflist) {
698 /* Free the entry because it isn't valid */
699 drm_cleanup_buf_error(dev, entry);
700 mutex_unlock(&dev->struct_mutex);
701 atomic_dec(&dev->buf_alloc);
702 return -ENOMEM;
703 }
704 dma->buflist = temp_buflist;
705
706 for (i = 0; i < entry->buf_count; i++) {
707 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
708 }
709
710 dma->buf_count += entry->buf_count;
711 dma->seg_count += entry->seg_count;
712 dma->page_count += byte_count >> PAGE_SHIFT;
713 dma->byte_count += byte_count;
714
715 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
716 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
717
718 mutex_unlock(&dev->struct_mutex);
719
720 request->count = entry->buf_count;
721 request->size = size;
722
723 dma->flags = _DRM_DMA_USE_AGP;
724
725 atomic_dec(&dev->buf_alloc);
726 return 0;
727 }
728 EXPORT_SYMBOL(drm_addbufs_agp);
729 #endif /* __OS_HAS_AGP */
730
731 int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
732 {
733 drm_device_dma_t *dma = dev->dma;
734 int count;
735 int order;
736 int size;
737 int total;
738 int page_order;
739 drm_buf_entry_t *entry;
740 drm_dma_handle_t *dmah;
741 drm_buf_t *buf;
742 int alignment;
743 unsigned long offset;
744 int i;
745 int byte_count;
746 int page_count;
747 unsigned long *temp_pagelist;
748 drm_buf_t **temp_buflist;
749
750 if (!drm_core_check_feature(dev, DRIVER_PCI_DMA))
751 return -EINVAL;
752
753 if (!dma)
754 return -EINVAL;
755
756 if (!capable(CAP_SYS_ADMIN))
757 return -EPERM;
758
759 count = request->count;
760 order = drm_order(request->size);
761 size = 1 << order;
762
763 DRM_DEBUG("count=%d, size=%d (%d), order=%d, queue_count=%d\n",
764 request->count, request->size, size, order, dev->queue_count);
765
766 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
767 return -EINVAL;
768 if (dev->queue_count)
769 return -EBUSY; /* Not while in use */
770
771 alignment = (request->flags & _DRM_PAGE_ALIGN)
772 ? PAGE_ALIGN(size) : size;
773 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
774 total = PAGE_SIZE << page_order;
775
776 spin_lock(&dev->count_lock);
777 if (dev->buf_use) {
778 spin_unlock(&dev->count_lock);
779 return -EBUSY;
780 }
781 atomic_inc(&dev->buf_alloc);
782 spin_unlock(&dev->count_lock);
783
784 mutex_lock(&dev->struct_mutex);
785 entry = &dma->bufs[order];
786 if (entry->buf_count) {
787 mutex_unlock(&dev->struct_mutex);
788 atomic_dec(&dev->buf_alloc);
789 return -ENOMEM; /* May only call once for each order */
790 }
791
792 if (count < 0 || count > 4096) {
793 mutex_unlock(&dev->struct_mutex);
794 atomic_dec(&dev->buf_alloc);
795 return -EINVAL;
796 }
797
798 entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
799 DRM_MEM_BUFS);
800 if (!entry->buflist) {
801 mutex_unlock(&dev->struct_mutex);
802 atomic_dec(&dev->buf_alloc);
803 return -ENOMEM;
804 }
805 memset(entry->buflist, 0, count * sizeof(*entry->buflist));
806
807 entry->seglist = drm_alloc(count * sizeof(*entry->seglist),
808 DRM_MEM_SEGS);
809 if (!entry->seglist) {
810 drm_free(entry->buflist,
811 count * sizeof(*entry->buflist), DRM_MEM_BUFS);
812 mutex_unlock(&dev->struct_mutex);
813 atomic_dec(&dev->buf_alloc);
814 return -ENOMEM;
815 }
816 memset(entry->seglist, 0, count * sizeof(*entry->seglist));
817
818 /* Keep the original pagelist until we know all the allocations
819 * have succeeded
820 */
821 temp_pagelist = drm_alloc((dma->page_count + (count << page_order))
822 * sizeof(*dma->pagelist), DRM_MEM_PAGES);
823 if (!temp_pagelist) {
824 drm_free(entry->buflist,
825 count * sizeof(*entry->buflist), DRM_MEM_BUFS);
826 drm_free(entry->seglist,
827 count * sizeof(*entry->seglist), DRM_MEM_SEGS);
828 mutex_unlock(&dev->struct_mutex);
829 atomic_dec(&dev->buf_alloc);
830 return -ENOMEM;
831 }
832 memcpy(temp_pagelist,
833 dma->pagelist, dma->page_count * sizeof(*dma->pagelist));
834 DRM_DEBUG("pagelist: %d entries\n",
835 dma->page_count + (count << page_order));
836
837 entry->buf_size = size;
838 entry->page_order = page_order;
839 byte_count = 0;
840 page_count = 0;
841
842 while (entry->buf_count < count) {
843
844 dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000, 0xfffffffful);
845
846 if (!dmah) {
847 /* Set count correctly so we free the proper amount. */
848 entry->buf_count = count;
849 entry->seg_count = count;
850 drm_cleanup_buf_error(dev, entry);
851 drm_free(temp_pagelist,
852 (dma->page_count + (count << page_order))
853 * sizeof(*dma->pagelist), DRM_MEM_PAGES);
854 mutex_unlock(&dev->struct_mutex);
855 atomic_dec(&dev->buf_alloc);
856 return -ENOMEM;
857 }
858 entry->seglist[entry->seg_count++] = dmah;
859 for (i = 0; i < (1 << page_order); i++) {
860 DRM_DEBUG("page %d @ 0x%08lx\n",
861 dma->page_count + page_count,
862 (unsigned long)dmah->vaddr + PAGE_SIZE * i);
863 temp_pagelist[dma->page_count + page_count++]
864 = (unsigned long)dmah->vaddr + PAGE_SIZE * i;
865 }
866 for (offset = 0;
867 offset + size <= total && entry->buf_count < count;
868 offset += alignment, ++entry->buf_count) {
869 buf = &entry->buflist[entry->buf_count];
870 buf->idx = dma->buf_count + entry->buf_count;
871 buf->total = alignment;
872 buf->order = order;
873 buf->used = 0;
874 buf->offset = (dma->byte_count + byte_count + offset);
875 buf->address = (void *)(dmah->vaddr + offset);
876 buf->bus_address = dmah->busaddr + offset;
877 buf->next = NULL;
878 buf->waiting = 0;
879 buf->pending = 0;
880 init_waitqueue_head(&buf->dma_wait);
881 buf->filp = NULL;
882
883 buf->dev_priv_size = dev->driver->dev_priv_size;
884 buf->dev_private = drm_alloc(buf->dev_priv_size,
885 DRM_MEM_BUFS);
886 if (!buf->dev_private) {
887 /* Set count correctly so we free the proper amount. */
888 entry->buf_count = count;
889 entry->seg_count = count;
890 drm_cleanup_buf_error(dev, entry);
891 drm_free(temp_pagelist,
892 (dma->page_count +
893 (count << page_order))
894 * sizeof(*dma->pagelist),
895 DRM_MEM_PAGES);
896 mutex_unlock(&dev->struct_mutex);
897 atomic_dec(&dev->buf_alloc);
898 return -ENOMEM;
899 }
900 memset(buf->dev_private, 0, buf->dev_priv_size);
901
902 DRM_DEBUG("buffer %d @ %p\n",
903 entry->buf_count, buf->address);
904 }
905 byte_count += PAGE_SIZE << page_order;
906 }
907
908 temp_buflist = drm_realloc(dma->buflist,
909 dma->buf_count * sizeof(*dma->buflist),
910 (dma->buf_count + entry->buf_count)
911 * sizeof(*dma->buflist), DRM_MEM_BUFS);
912 if (!temp_buflist) {
913 /* Free the entry because it isn't valid */
914 drm_cleanup_buf_error(dev, entry);
915 drm_free(temp_pagelist,
916 (dma->page_count + (count << page_order))
917 * sizeof(*dma->pagelist), DRM_MEM_PAGES);
918 mutex_unlock(&dev->struct_mutex);
919 atomic_dec(&dev->buf_alloc);
920 return -ENOMEM;
921 }
922 dma->buflist = temp_buflist;
923
924 for (i = 0; i < entry->buf_count; i++) {
925 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
926 }
927
928 /* No allocations failed, so now we can replace the orginal pagelist
929 * with the new one.
930 */
931 if (dma->page_count) {
932 drm_free(dma->pagelist,
933 dma->page_count * sizeof(*dma->pagelist),
934 DRM_MEM_PAGES);
935 }
936 dma->pagelist = temp_pagelist;
937
938 dma->buf_count += entry->buf_count;
939 dma->seg_count += entry->seg_count;
940 dma->page_count += entry->seg_count << page_order;
941 dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
942
943 mutex_unlock(&dev->struct_mutex);
944
945 request->count = entry->buf_count;
946 request->size = size;
947
948 if (request->flags & _DRM_PCI_BUFFER_RO)
949 dma->flags = _DRM_DMA_USE_PCI_RO;
950
951 atomic_dec(&dev->buf_alloc);
952 return 0;
953
954 }
955 EXPORT_SYMBOL(drm_addbufs_pci);
956
957 static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
958 {
959 drm_device_dma_t *dma = dev->dma;
960 drm_buf_entry_t *entry;
961 drm_buf_t *buf;
962 unsigned long offset;
963 unsigned long agp_offset;
964 int count;
965 int order;
966 int size;
967 int alignment;
968 int page_order;
969 int total;
970 int byte_count;
971 int i;
972 drm_buf_t **temp_buflist;
973
974 if (!drm_core_check_feature(dev, DRIVER_SG))
975 return -EINVAL;
976
977 if (!dma)
978 return -EINVAL;
979
980 if (!capable(CAP_SYS_ADMIN))
981 return -EPERM;
982
983 count = request->count;
984 order = drm_order(request->size);
985 size = 1 << order;
986
987 alignment = (request->flags & _DRM_PAGE_ALIGN)
988 ? PAGE_ALIGN(size) : size;
989 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
990 total = PAGE_SIZE << page_order;
991
992 byte_count = 0;
993 agp_offset = request->agp_start;
994
995 DRM_DEBUG("count: %d\n", count);
996 DRM_DEBUG("order: %d\n", order);
997 DRM_DEBUG("size: %d\n", size);
998 DRM_DEBUG("agp_offset: %lu\n", agp_offset);
999 DRM_DEBUG("alignment: %d\n", alignment);
1000 DRM_DEBUG("page_order: %d\n", page_order);
1001 DRM_DEBUG("total: %d\n", total);
1002
1003 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1004 return -EINVAL;
1005 if (dev->queue_count)
1006 return -EBUSY; /* Not while in use */
1007
1008 spin_lock(&dev->count_lock);
1009 if (dev->buf_use) {
1010 spin_unlock(&dev->count_lock);
1011 return -EBUSY;
1012 }
1013 atomic_inc(&dev->buf_alloc);
1014 spin_unlock(&dev->count_lock);
1015
1016 mutex_lock(&dev->struct_mutex);
1017 entry = &dma->bufs[order];
1018 if (entry->buf_count) {
1019 mutex_unlock(&dev->struct_mutex);
1020 atomic_dec(&dev->buf_alloc);
1021 return -ENOMEM; /* May only call once for each order */
1022 }
1023
1024 if (count < 0 || count > 4096) {
1025 mutex_unlock(&dev->struct_mutex);
1026 atomic_dec(&dev->buf_alloc);
1027 return -EINVAL;
1028 }
1029
1030 entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
1031 DRM_MEM_BUFS);
1032 if (!entry->buflist) {
1033 mutex_unlock(&dev->struct_mutex);
1034 atomic_dec(&dev->buf_alloc);
1035 return -ENOMEM;
1036 }
1037 memset(entry->buflist, 0, count * sizeof(*entry->buflist));
1038
1039 entry->buf_size = size;
1040 entry->page_order = page_order;
1041
1042 offset = 0;
1043
1044 while (entry->buf_count < count) {
1045 buf = &entry->buflist[entry->buf_count];
1046 buf->idx = dma->buf_count + entry->buf_count;
1047 buf->total = alignment;
1048 buf->order = order;
1049 buf->used = 0;
1050
1051 buf->offset = (dma->byte_count + offset);
1052 buf->bus_address = agp_offset + offset;
1053 buf->address = (void *)(agp_offset + offset
1054 + (unsigned long)dev->sg->virtual);
1055 buf->next = NULL;
1056 buf->waiting = 0;
1057 buf->pending = 0;
1058 init_waitqueue_head(&buf->dma_wait);
1059 buf->filp = NULL;
1060
1061 buf->dev_priv_size = dev->driver->dev_priv_size;
1062 buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
1063 if (!buf->dev_private) {
1064 /* Set count correctly so we free the proper amount. */
1065 entry->buf_count = count;
1066 drm_cleanup_buf_error(dev, entry);
1067 mutex_unlock(&dev->struct_mutex);
1068 atomic_dec(&dev->buf_alloc);
1069 return -ENOMEM;
1070 }
1071
1072 memset(buf->dev_private, 0, buf->dev_priv_size);
1073
1074 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
1075
1076 offset += alignment;
1077 entry->buf_count++;
1078 byte_count += PAGE_SIZE << page_order;
1079 }
1080
1081 DRM_DEBUG("byte_count: %d\n", byte_count);
1082
1083 temp_buflist = drm_realloc(dma->buflist,
1084 dma->buf_count * sizeof(*dma->buflist),
1085 (dma->buf_count + entry->buf_count)
1086 * sizeof(*dma->buflist), DRM_MEM_BUFS);
1087 if (!temp_buflist) {
1088 /* Free the entry because it isn't valid */
1089 drm_cleanup_buf_error(dev, entry);
1090 mutex_unlock(&dev->struct_mutex);
1091 atomic_dec(&dev->buf_alloc);
1092 return -ENOMEM;
1093 }
1094 dma->buflist = temp_buflist;
1095
1096 for (i = 0; i < entry->buf_count; i++) {
1097 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
1098 }
1099
1100 dma->buf_count += entry->buf_count;
1101 dma->seg_count += entry->seg_count;
1102 dma->page_count += byte_count >> PAGE_SHIFT;
1103 dma->byte_count += byte_count;
1104
1105 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
1106 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
1107
1108 mutex_unlock(&dev->struct_mutex);
1109
1110 request->count = entry->buf_count;
1111 request->size = size;
1112
1113 dma->flags = _DRM_DMA_USE_SG;
1114
1115 atomic_dec(&dev->buf_alloc);
1116 return 0;
1117 }
1118
1119 static int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
1120 {
1121 drm_device_dma_t *dma = dev->dma;
1122 drm_buf_entry_t *entry;
1123 drm_buf_t *buf;
1124 unsigned long offset;
1125 unsigned long agp_offset;
1126 int count;
1127 int order;
1128 int size;
1129 int alignment;
1130 int page_order;
1131 int total;
1132 int byte_count;
1133 int i;
1134 drm_buf_t **temp_buflist;
1135
1136 if (!drm_core_check_feature(dev, DRIVER_FB_DMA))
1137 return -EINVAL;
1138
1139 if (!dma)
1140 return -EINVAL;
1141
1142 if (!capable(CAP_SYS_ADMIN))
1143 return -EPERM;
1144
1145 count = request->count;
1146 order = drm_order(request->size);
1147 size = 1 << order;
1148
1149 alignment = (request->flags & _DRM_PAGE_ALIGN)
1150 ? PAGE_ALIGN(size) : size;
1151 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
1152 total = PAGE_SIZE << page_order;
1153
1154 byte_count = 0;
1155 agp_offset = request->agp_start;
1156
1157 DRM_DEBUG("count: %d\n", count);
1158 DRM_DEBUG("order: %d\n", order);
1159 DRM_DEBUG("size: %d\n", size);
1160 DRM_DEBUG("agp_offset: %lu\n", agp_offset);
1161 DRM_DEBUG("alignment: %d\n", alignment);
1162 DRM_DEBUG("page_order: %d\n", page_order);
1163 DRM_DEBUG("total: %d\n", total);
1164
1165 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1166 return -EINVAL;
1167 if (dev->queue_count)
1168 return -EBUSY; /* Not while in use */
1169
1170 spin_lock(&dev->count_lock);
1171 if (dev->buf_use) {
1172 spin_unlock(&dev->count_lock);
1173 return -EBUSY;
1174 }
1175 atomic_inc(&dev->buf_alloc);
1176 spin_unlock(&dev->count_lock);
1177
1178 mutex_lock(&dev->struct_mutex);
1179 entry = &dma->bufs[order];
1180 if (entry->buf_count) {
1181 mutex_unlock(&dev->struct_mutex);
1182 atomic_dec(&dev->buf_alloc);
1183 return -ENOMEM; /* May only call once for each order */
1184 }
1185
1186 if (count < 0 || count > 4096) {
1187 mutex_unlock(&dev->struct_mutex);
1188 atomic_dec(&dev->buf_alloc);
1189 return -EINVAL;
1190 }
1191
1192 entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
1193 DRM_MEM_BUFS);
1194 if (!entry->buflist) {
1195 mutex_unlock(&dev->struct_mutex);
1196 atomic_dec(&dev->buf_alloc);
1197 return -ENOMEM;
1198 }
1199 memset(entry->buflist, 0, count * sizeof(*entry->buflist));
1200
1201 entry->buf_size = size;
1202 entry->page_order = page_order;
1203
1204 offset = 0;
1205
1206 while (entry->buf_count < count) {
1207 buf = &entry->buflist[entry->buf_count];
1208 buf->idx = dma->buf_count + entry->buf_count;
1209 buf->total = alignment;
1210 buf->order = order;
1211 buf->used = 0;
1212
1213 buf->offset = (dma->byte_count + offset);
1214 buf->bus_address = agp_offset + offset;
1215 buf->address = (void *)(agp_offset + offset);
1216 buf->next = NULL;
1217 buf->waiting = 0;
1218 buf->pending = 0;
1219 init_waitqueue_head(&buf->dma_wait);
1220 buf->filp = NULL;
1221
1222 buf->dev_priv_size = dev->driver->dev_priv_size;
1223 buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
1224 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);
1228 mutex_unlock(&dev->struct_mutex);
1229 atomic_dec(&dev->buf_alloc);
1230 return -ENOMEM;
1231 }
1232 memset(buf->dev_private, 0, buf->dev_priv_size);
1233
1234 DRM_DEBUG("buffer %d @ %p\n", entry->buf_count, buf->address);
1235
1236 offset += alignment;
1237 entry->buf_count++;
1238 byte_count += PAGE_SIZE << page_order;
1239 }
1240
1241 DRM_DEBUG("byte_count: %d\n", byte_count);
1242
1243 temp_buflist = drm_realloc(dma->buflist,
1244 dma->buf_count * sizeof(*dma->buflist),
1245 (dma->buf_count + entry->buf_count)
1246 * sizeof(*dma->buflist), DRM_MEM_BUFS);
1247 if (!temp_buflist) {
1248 /* Free the entry because it isn't valid */
1249 drm_cleanup_buf_error(dev, entry);
1250 mutex_unlock(&dev->struct_mutex);
1251 atomic_dec(&dev->buf_alloc);
1252 return -ENOMEM;
1253 }
1254 dma->buflist = temp_buflist;
1255
1256 for (i = 0; i < entry->buf_count; i++) {
1257 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
1258 }
1259
1260 dma->buf_count += entry->buf_count;
1261 dma->seg_count += entry->seg_count;
1262 dma->page_count += byte_count >> PAGE_SHIFT;
1263 dma->byte_count += byte_count;
1264
1265 DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
1266 DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
1267
1268 mutex_unlock(&dev->struct_mutex);
1269
1270 request->count = entry->buf_count;
1271 request->size = size;
1272
1273 dma->flags = _DRM_DMA_USE_FB;
1274
1275 atomic_dec(&dev->buf_alloc);
1276 return 0;
1277 }
1278
1279
1280 /**
1281 * Add buffers for DMA transfers (ioctl).
1282 *
1283 * \param inode device inode.
1284 * \param filp file pointer.
1285 * \param cmd command.
1286 * \param arg pointer to a drm_buf_desc_t request.
1287 * \return zero on success or a negative number on failure.
1288 *
1289 * According with the memory type specified in drm_buf_desc::flags and the
1290 * build options, it dispatches the call either to addbufs_agp(),
1291 * addbufs_sg() or addbufs_pci() for AGP, scatter-gather or consistent
1292 * PCI memory respectively.
1293 */
1294 int drm_addbufs(struct inode *inode, struct file *filp,
1295 unsigned int cmd, unsigned long arg)
1296 {
1297 drm_buf_desc_t request;
1298 drm_file_t *priv = filp->private_data;
1299 drm_device_t *dev = priv->head->dev;
1300 int ret;
1301
1302 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1303 return -EINVAL;
1304
1305 if (copy_from_user(&request, (drm_buf_desc_t __user *) arg,
1306 sizeof(request)))
1307 return -EFAULT;
1308
1309 #if __OS_HAS_AGP
1310 if (request.flags & _DRM_AGP_BUFFER)
1311 ret = drm_addbufs_agp(dev, &request);
1312 else
1313 #endif
1314 if (request.flags & _DRM_SG_BUFFER)
1315 ret = drm_addbufs_sg(dev, &request);
1316 else if (request.flags & _DRM_FB_BUFFER)
1317 ret = drm_addbufs_fb(dev, &request);
1318 else
1319 ret = drm_addbufs_pci(dev, &request);
1320
1321 if (ret == 0) {
1322 if (copy_to_user((void __user *)arg, &request, sizeof(request))) {
1323 ret = -EFAULT;
1324 }
1325 }
1326 return ret;
1327 }
1328
1329 /**
1330 * Get information about the buffer mappings.
1331 *
1332 * This was originally mean for debugging purposes, or by a sophisticated
1333 * client library to determine how best to use the available buffers (e.g.,
1334 * large buffers can be used for image transfer).
1335 *
1336 * \param inode device inode.
1337 * \param filp file pointer.
1338 * \param cmd command.
1339 * \param arg pointer to a drm_buf_info structure.
1340 * \return zero on success or a negative number on failure.
1341 *
1342 * Increments drm_device::buf_use while holding the drm_device::count_lock
1343 * lock, preventing of allocating more buffers after this call. Information
1344 * about each requested buffer is then copied into user space.
1345 */
1346 int drm_infobufs(struct inode *inode, struct file *filp,
1347 unsigned int cmd, unsigned long arg)
1348 {
1349 drm_file_t *priv = filp->private_data;
1350 drm_device_t *dev = priv->head->dev;
1351 drm_device_dma_t *dma = dev->dma;
1352 drm_buf_info_t request;
1353 drm_buf_info_t __user *argp = (void __user *)arg;
1354 int i;
1355 int count;
1356
1357 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1358 return -EINVAL;
1359
1360 if (!dma)
1361 return -EINVAL;
1362
1363 spin_lock(&dev->count_lock);
1364 if (atomic_read(&dev->buf_alloc)) {
1365 spin_unlock(&dev->count_lock);
1366 return -EBUSY;
1367 }
1368 ++dev->buf_use; /* Can't allocate more after this call */
1369 spin_unlock(&dev->count_lock);
1370
1371 if (copy_from_user(&request, argp, sizeof(request)))
1372 return -EFAULT;
1373
1374 for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
1375 if (dma->bufs[i].buf_count)
1376 ++count;
1377 }
1378
1379 DRM_DEBUG("count = %d\n", count);
1380
1381 if (request.count >= count) {
1382 for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
1383 if (dma->bufs[i].buf_count) {
1384 drm_buf_desc_t __user *to =
1385 &request.list[count];
1386 drm_buf_entry_t *from = &dma->bufs[i];
1387 drm_freelist_t *list = &dma->bufs[i].freelist;
1388 if (copy_to_user(&to->count,
1389 &from->buf_count,
1390 sizeof(from->buf_count)) ||
1391 copy_to_user(&to->size,
1392 &from->buf_size,
1393 sizeof(from->buf_size)) ||
1394 copy_to_user(&to->low_mark,
1395 &list->low_mark,
1396 sizeof(list->low_mark)) ||
1397 copy_to_user(&to->high_mark,
1398 &list->high_mark,
1399 sizeof(list->high_mark)))
1400 return -EFAULT;
1401
1402 DRM_DEBUG("%d %d %d %d %d\n",
1403 i,
1404 dma->bufs[i].buf_count,
1405 dma->bufs[i].buf_size,
1406 dma->bufs[i].freelist.low_mark,
1407 dma->bufs[i].freelist.high_mark);
1408 ++count;
1409 }
1410 }
1411 }
1412 request.count = count;
1413
1414 if (copy_to_user(argp, &request, sizeof(request)))
1415 return -EFAULT;
1416
1417 return 0;
1418 }
1419
1420 /**
1421 * Specifies a low and high water mark for buffer allocation
1422 *
1423 * \param inode device inode.
1424 * \param filp file pointer.
1425 * \param cmd command.
1426 * \param arg a pointer to a drm_buf_desc structure.
1427 * \return zero on success or a negative number on failure.
1428 *
1429 * Verifies that the size order is bounded between the admissible orders and
1430 * updates the respective drm_device_dma::bufs entry low and high water mark.
1431 *
1432 * \note This ioctl is deprecated and mostly never used.
1433 */
1434 int drm_markbufs(struct inode *inode, struct file *filp,
1435 unsigned int cmd, unsigned long arg)
1436 {
1437 drm_file_t *priv = filp->private_data;
1438 drm_device_t *dev = priv->head->dev;
1439 drm_device_dma_t *dma = dev->dma;
1440 drm_buf_desc_t request;
1441 int order;
1442 drm_buf_entry_t *entry;
1443
1444 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1445 return -EINVAL;
1446
1447 if (!dma)
1448 return -EINVAL;
1449
1450 if (copy_from_user(&request,
1451 (drm_buf_desc_t __user *) arg, sizeof(request)))
1452 return -EFAULT;
1453
1454 DRM_DEBUG("%d, %d, %d\n",
1455 request.size, request.low_mark, request.high_mark);
1456 order = drm_order(request.size);
1457 if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
1458 return -EINVAL;
1459 entry = &dma->bufs[order];
1460
1461 if (request.low_mark < 0 || request.low_mark > entry->buf_count)
1462 return -EINVAL;
1463 if (request.high_mark < 0 || request.high_mark > entry->buf_count)
1464 return -EINVAL;
1465
1466 entry->freelist.low_mark = request.low_mark;
1467 entry->freelist.high_mark = request.high_mark;
1468
1469 return 0;
1470 }
1471
1472 /**
1473 * Unreserve the buffers in list, previously reserved using drmDMA.
1474 *
1475 * \param inode device inode.
1476 * \param filp file pointer.
1477 * \param cmd command.
1478 * \param arg pointer to a drm_buf_free structure.
1479 * \return zero on success or a negative number on failure.
1480 *
1481 * Calls free_buffer() for each used buffer.
1482 * This function is primarily used for debugging.
1483 */
1484 int drm_freebufs(struct inode *inode, struct file *filp,
1485 unsigned int cmd, unsigned long arg)
1486 {
1487 drm_file_t *priv = filp->private_data;
1488 drm_device_t *dev = priv->head->dev;
1489 drm_device_dma_t *dma = dev->dma;
1490 drm_buf_free_t request;
1491 int i;
1492 int idx;
1493 drm_buf_t *buf;
1494
1495 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1496 return -EINVAL;
1497
1498 if (!dma)
1499 return -EINVAL;
1500
1501 if (copy_from_user(&request,
1502 (drm_buf_free_t __user *) arg, sizeof(request)))
1503 return -EFAULT;
1504
1505 DRM_DEBUG("%d\n", request.count);
1506 for (i = 0; i < request.count; i++) {
1507 if (copy_from_user(&idx, &request.list[i], sizeof(idx)))
1508 return -EFAULT;
1509 if (idx < 0 || idx >= dma->buf_count) {
1510 DRM_ERROR("Index %d (of %d max)\n",
1511 idx, dma->buf_count - 1);
1512 return -EINVAL;
1513 }
1514 buf = dma->buflist[idx];
1515 if (buf->filp != filp) {
1516 DRM_ERROR("Process %d freeing buffer not owned\n",
1517 current->pid);
1518 return -EINVAL;
1519 }
1520 drm_free_buffer(dev, buf);
1521 }
1522
1523 return 0;
1524 }
1525
1526 /**
1527 * Maps all of the DMA buffers into client-virtual space (ioctl).
1528 *
1529 * \param inode device inode.
1530 * \param filp file pointer.
1531 * \param cmd command.
1532 * \param arg pointer to a drm_buf_map structure.
1533 * \return zero on success or a negative number on failure.
1534 *
1535 * Maps the AGP, SG or PCI buffer region with do_mmap(), and copies information
1536 * about each buffer into user space. For PCI buffers, it calls do_mmap() with
1537 * offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
1538 * drm_mmap_dma().
1539 */
1540 int drm_mapbufs(struct inode *inode, struct file *filp,
1541 unsigned int cmd, unsigned long arg)
1542 {
1543 drm_file_t *priv = filp->private_data;
1544 drm_device_t *dev = priv->head->dev;
1545 drm_device_dma_t *dma = dev->dma;
1546 drm_buf_map_t __user *argp = (void __user *)arg;
1547 int retcode = 0;
1548 const int zero = 0;
1549 unsigned long virtual;
1550 unsigned long address;
1551 drm_buf_map_t request;
1552 int i;
1553
1554 if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1555 return -EINVAL;
1556
1557 if (!dma)
1558 return -EINVAL;
1559
1560 spin_lock(&dev->count_lock);
1561 if (atomic_read(&dev->buf_alloc)) {
1562 spin_unlock(&dev->count_lock);
1563 return -EBUSY;
1564 }
1565 dev->buf_use++; /* Can't allocate more after this call */
1566 spin_unlock(&dev->count_lock);
1567
1568 if (copy_from_user(&request, argp, sizeof(request)))
1569 return -EFAULT;
1570
1571 if (request.count >= dma->buf_count) {
1572 if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP))
1573 || (drm_core_check_feature(dev, DRIVER_SG)
1574 && (dma->flags & _DRM_DMA_USE_SG))
1575 || (drm_core_check_feature(dev, DRIVER_FB_DMA)
1576 && (dma->flags & _DRM_DMA_USE_FB))) {
1577 drm_map_t *map = dev->agp_buffer_map;
1578 unsigned long token = dev->agp_buffer_token;
1579
1580 if (!map) {
1581 retcode = -EINVAL;
1582 goto done;
1583 }
1584
1585 down_write(&current->mm->mmap_sem);
1586 virtual = do_mmap(filp, 0, map->size,
1587 PROT_READ | PROT_WRITE,
1588 MAP_SHARED, token);
1589 up_write(&current->mm->mmap_sem);
1590 } else {
1591 down_write(&current->mm->mmap_sem);
1592 virtual = do_mmap(filp, 0, dma->byte_count,
1593 PROT_READ | PROT_WRITE,
1594 MAP_SHARED, 0);
1595 up_write(&current->mm->mmap_sem);
1596 }
1597 if (virtual > -1024UL) {
1598 /* Real error */
1599 retcode = (signed long)virtual;
1600 goto done;
1601 }
1602 request.virtual = (void __user *)virtual;
1603
1604 for (i = 0; i < dma->buf_count; i++) {
1605 if (copy_to_user(&request.list[i].idx,
1606 &dma->buflist[i]->idx,
1607 sizeof(request.list[0].idx))) {
1608 retcode = -EFAULT;
1609 goto done;
1610 }
1611 if (copy_to_user(&request.list[i].total,
1612 &dma->buflist[i]->total,
1613 sizeof(request.list[0].total))) {
1614 retcode = -EFAULT;
1615 goto done;
1616 }
1617 if (copy_to_user(&request.list[i].used,
1618 &zero, sizeof(zero))) {
1619 retcode = -EFAULT;
1620 goto done;
1621 }
1622 address = virtual + dma->buflist[i]->offset; /* *** */
1623 if (copy_to_user(&request.list[i].address,
1624 &address, sizeof(address))) {
1625 retcode = -EFAULT;
1626 goto done;
1627 }
1628 }
1629 }
1630 done:
1631 request.count = dma->buf_count;
1632 DRM_DEBUG("%d buffers, retcode = %d\n", request.count, retcode);
1633
1634 if (copy_to_user(argp, &request, sizeof(request)))
1635 return -EFAULT;
1636
1637 return retcode;
1638 }
1639
1640 /**
1641 * Compute size order. Returns the exponent of the smaller power of two which
1642 * is greater or equal to given number.
1643 *
1644 * \param size size.
1645 * \return order.
1646 *
1647 * \todo Can be made faster.
1648 */
1649 int drm_order(unsigned long size)
1650 {
1651 int order;
1652 unsigned long tmp;
1653
1654 for (order = 0, tmp = size >> 1; tmp; tmp >>= 1, order++) ;
1655
1656 if (size & (size - 1))
1657 ++order;
1658
1659 return order;
1660 }
1661 EXPORT_SYMBOL(drm_order);
1662
1663
kernel source for telekom puls (alcatel/mediatek)