开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
drm_bufs.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：29k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

drm_bufs.h：源码内容
  1. /* drm_bufs.h -- Generic buffer template -*- linux-c -*-
  2.  * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
  3.  *
  4.  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
  5.  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  6.  * All Rights Reserved.
  7.  *
  8.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice (including the next
  16.  * paragraph) shall be included in all copies or substantial portions of the
  17.  * Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25.  * OTHER DEALINGS IN THE SOFTWARE.
  26.  *
  27.  * Authors:
  28.  *    Rickard E. (Rik) Faith <faith@valinux.com>
  29.  *    Gareth Hughes <gareth@valinux.com>
  30.  */
  32. #define __NO_VERSION__
  33. #include <linux/vmalloc.h>
  34. #include "drmP.h"
  36. #ifndef __HAVE_PCI_DMA
  37. #define __HAVE_PCI_DMA 0
  38. #endif
  40. #ifndef __HAVE_SG
  41. #define __HAVE_SG 0
  42. #endif
  44. #ifndef DRIVER_BUF_PRIV_T
  45. #define DRIVER_BUF_PRIV_T u32
  46. #endif
  47. #ifndef DRIVER_AGP_BUFFERS_MAP
  48. #if __HAVE_AGP && __HAVE_DMA
  49. #error "You must define DRIVER_AGP_BUFFERS_MAP()"
  50. #else
  51. #define DRIVER_AGP_BUFFERS_MAP( dev ) NULL
  52. #endif
  53. #endif
  55. /*
  56.  * Compute order.  Can be made faster.
  57.  */
  58. int DRM(order)( unsigned long size )
  59. {
  60. int order;
  61. unsigned long tmp;
  63. for ( order = 0, tmp = size ; tmp >>= 1 ; ++order );
  65. if ( size & ~(1 << order) )
  66. ++order;
  68. return order;
  69. }
  71. int DRM(addmap)( struct inode *inode, struct file *filp,
  72.  unsigned int cmd, unsigned long arg )
  73. {
  74. drm_file_t *priv = filp->private_data;
  75. drm_device_t *dev = priv->dev;
  76. drm_map_t *map;
  77. drm_map_list_t *list;
  79. if ( !(filp->f_mode & 3) ) return -EACCES; /* Require read/write */
  81. map = DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
  82. if ( !map )
  83. return -ENOMEM;
  85. if ( copy_from_user( map, (drm_map_t *)arg, sizeof(*map) ) ) {
  86. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  87. return -EFAULT;
  88. }
  90. /* Only allow shared memory to be removable since we only keep enough
  91.  * book keeping information about shared memory to allow for removal
  92.  * when processes fork.
  93.  */
  94. if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
  95. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  96. return -EINVAL;
  97. }
  98. DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %dn",
  99.    map->offset, map->size, map->type );
  100. if ( (map->offset & (~PAGE_MASK)) || (map->size & (~PAGE_MASK)) ) {
  101. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  102. return -EINVAL;
  103. }
  104. map->mtrr   = -1;
  105. map->handle = 0;
  107. switch ( map->type ) {
  108. case _DRM_REGISTERS:
  109. case _DRM_FRAME_BUFFER:
  110. #if !defined(__sparc__) && !defined(__alpha__)
  111. if ( map->offset + map->size < map->offset ||
  112.      map->offset < virt_to_phys(high_memory) ) {
  113. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  114. return -EINVAL;
  115. }
  116. #endif
  117. #ifdef __alpha__
  118. map->offset += dev->hose->mem_space->start;
  119. #endif
  120. #if __REALLY_HAVE_MTRR
  121. if ( map->type == _DRM_FRAME_BUFFER ||
  122.      (map->flags & _DRM_WRITE_COMBINING) ) {
  123. map->mtrr = mtrr_add( map->offset, map->size,
  124.       MTRR_TYPE_WRCOMB, 1 );
  125. }
  126. #endif
  127. map->handle = DRM(ioremap)( map->offset, map->size );
  128. break;
  130. case _DRM_SHM:
  131. map->handle = vmalloc_32(map->size);
  132. DRM_DEBUG( "%ld %d %pn",
  133.    map->size, DRM(order)( map->size ), map->handle );
  134. if ( !map->handle ) {
  135. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  136. return -ENOMEM;
  137. }
  138. map->offset = (unsigned long)map->handle;
  139. if ( map->flags & _DRM_CONTAINS_LOCK ) {
  140. dev->lock.hw_lock = map->handle; /* Pointer to lock */
  141. }
  142. break;
  143. #if __REALLY_HAVE_AGP
  144. case _DRM_AGP:
  145. #ifdef __alpha__
  146. map->offset += dev->hose->mem_space->start;
  147. #endif
  148. map->offset = map->offset + dev->agp->base;
  149. map->mtrr   = dev->agp->agp_mtrr; /* for getmap */
  150. break;
  151. #endif
  152. case _DRM_SCATTER_GATHER:
  153. if (!dev->sg) {
  154. DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
  155. return -EINVAL;
  156. }
  157. map->offset = map->offset + dev->sg->handle;
  158. break;
  160. default:
  161. DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
  162. return -EINVAL;
  163. }
  165. list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
  166. if(!list) {
  167. DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
  168. return -EINVAL;
  169. }
  170. memset(list, 0, sizeof(*list));
  171. list->map = map;
  173. down(&dev->struct_sem);
  174. list_add(&list->head, &dev->maplist->head);
  175.   up(&dev->struct_sem);
  177. if ( copy_to_user( (drm_map_t *)arg, map, sizeof(*map) ) )
  178. return -EFAULT;
  179. if ( map->type != _DRM_SHM ) {
  180. if ( copy_to_user( &((drm_map_t *)arg)->handle,
  181.    &map->offset,
  182.    sizeof(map->offset) ) )
  183. return -EFAULT;
  184. }
  185. return 0;
  186. }
  189. /* Remove a map private from list and deallocate resources if the mapping
  190.  * isn't in use.
  191.  */
  193. int DRM(rmmap)(struct inode *inode, struct file *filp,
  194.        unsigned int cmd, unsigned long arg)
  195. {
  196. drm_file_t *priv = filp->private_data;
  197. drm_device_t *dev = priv->dev;
  198. struct list_head *list;
  199. drm_map_list_t *r_list = NULL;
  200. drm_vma_entry_t *pt, *prev;
  201. drm_map_t *map;
  202. drm_map_t request;
  203. int found_maps = 0;
  205. if (copy_from_user(&request, (drm_map_t *)arg,
  206.    sizeof(request))) {
  207. return -EFAULT;
  208. }
  210. down(&dev->struct_sem);
  211. list = &dev->maplist->head;
  212. list_for_each(list, &dev->maplist->head) {
  213. r_list = (drm_map_list_t *) list;
  215. if(r_list->map &&
  216.    r_list->map->handle == request.handle &&
  217.    r_list->map->flags & _DRM_REMOVABLE) break;
  218. }
  220. /* List has wrapped around to the head pointer, or its empty we didn't
  221.  * find anything.
  222.  */
  223. if(list == (&dev->maplist->head)) {
  224. up(&dev->struct_sem);
  225. return -EINVAL;
  226. }
  227. map = r_list->map;
  228. list_del(list);
  229. DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
  231. for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
  232. #if LINUX_VERSION_CODE >= 0x020300
  233. if (pt->vma->vm_private_data == map) found_maps++;
  234. #else
  235. if (pt->vma->vm_pte == map) found_maps++;
  236. #endif
  237. }
  239. if(!found_maps) {
  240. switch (map->type) {
  241. case _DRM_REGISTERS:
  242. case _DRM_FRAME_BUFFER:
  243. #if __REALLY_HAVE_MTRR
  244. if (map->mtrr >= 0) {
  245. int retcode;
  246. retcode = mtrr_del(map->mtrr,
  247.    map->offset,
  248.    map->size);
  249. DRM_DEBUG("mtrr_del = %dn", retcode);
  250. }
  251. #endif
  252. DRM(ioremapfree)(map->handle, map->size);
  253. break;
  254. case _DRM_SHM:
  255. vfree(map->handle);
  256. break;
  257. case _DRM_AGP:
  258. case _DRM_SCATTER_GATHER:
  259. break;
  260. }
  261. DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
  262. }
  263. up(&dev->struct_sem);
  264. return 0;
  265. }
  267. #if __HAVE_DMA
  270. static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
  271. {
  272. int i;
  274. if (entry->seg_count) {
  275. for (i = 0; i < entry->seg_count; i++) {
  276. DRM(free_pages)(entry->seglist[i],
  277. entry->page_order,
  278. DRM_MEM_DMA);
  279. }
  280. DRM(free)(entry->seglist,
  281.   entry->seg_count *
  282.   sizeof(*entry->seglist),
  283.   DRM_MEM_SEGS);
  285. entry->seg_count = 0;
  286. }
  288.     if(entry->buf_count) {
  289.     for(i = 0; i < entry->buf_count; i++) {
  290. if(entry->buflist[i].dev_private) {
  291. DRM(free)(entry->buflist[i].dev_private,
  292.   entry->buflist[i].dev_priv_size,
  293.   DRM_MEM_BUFS);
  294. }
  295. }
  296. DRM(free)(entry->buflist,
  297.   entry->buf_count *
  298.   sizeof(*entry->buflist),
  299.   DRM_MEM_BUFS);
  301. #if __HAVE_DMA_FREELIST
  302.     DRM(freelist_destroy)(&entry->freelist);
  303. #endif
  305. entry->buf_count = 0;
  306. }
  307. }
  309. #if __REALLY_HAVE_AGP
  310. int DRM(addbufs_agp)( struct inode *inode, struct file *filp,
  311.       unsigned int cmd, unsigned long arg )
  312. {
  313. drm_file_t *priv = filp->private_data;
  314. drm_device_t *dev = priv->dev;
  315. drm_device_dma_t *dma = dev->dma;
  316. drm_buf_desc_t request;
  317. drm_buf_entry_t *entry;
  318. drm_buf_t *buf;
  319. unsigned long offset;
  320. unsigned long agp_offset;
  321. int count;
  322. int order;
  323. int size;
  324. int alignment;
  325. int page_order;
  326. int total;
  327. int byte_count;
  328. int i;
  329. drm_buf_t **temp_buflist;
  331. if ( !dma ) return -EINVAL;
  333. if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
  334.      sizeof(request) ) )
  335. return -EFAULT;
  337. count = request.count;
  338. order = DRM(order)( request.size );
  339. size = 1 << order;
  341. alignment  = (request.flags & _DRM_PAGE_ALIGN)
  342. ? PAGE_ALIGN(size) : size;
  343. page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
  344. total = PAGE_SIZE << page_order;
  346. byte_count = 0;
  347. agp_offset = dev->agp->base + request.agp_start;
  349. DRM_DEBUG( "count:      %dn",  count );
  350. DRM_DEBUG( "order:      %dn",  order );
  351. DRM_DEBUG( "size:       %dn",  size );
  352. DRM_DEBUG( "agp_offset: %ldn", agp_offset );
  353. DRM_DEBUG( "alignment:  %dn",  alignment );
  354. DRM_DEBUG( "page_order: %dn",  page_order );
  355. DRM_DEBUG( "total:      %dn",  total );
  357. if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
  358. if ( dev->queue_count ) return -EBUSY; /* Not while in use */
  360. spin_lock( &dev->count_lock );
  361. if ( dev->buf_use ) {
  362. spin_unlock( &dev->count_lock );
  363. return -EBUSY;
  364. }
  365. atomic_inc( &dev->buf_alloc );
  366. spin_unlock( &dev->count_lock );
  368. down( &dev->struct_sem );
  369. entry = &dma->bufs[order];
  370. if ( entry->buf_count ) {
  371. up( &dev->struct_sem );
  372. atomic_dec( &dev->buf_alloc );
  373. return -ENOMEM; /* May only call once for each order */
  374. }
  376. if (count < 0 || count > 4096) {
  377. up( &dev->struct_sem );
  378. atomic_dec( &dev->buf_alloc );
  379. return -EINVAL;
  380. }
  382. entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
  383.     DRM_MEM_BUFS );
  384. if ( !entry->buflist ) {
  385. up( &dev->struct_sem );
  386. atomic_dec( &dev->buf_alloc );
  387. return -ENOMEM;
  388. }
  389. memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
  391. entry->buf_size = size;
  392. entry->page_order = page_order;
  394. offset = 0;
  396. while ( entry->buf_count < count ) {
  397. buf          = &entry->buflist[entry->buf_count];
  398. buf->idx     = dma->buf_count + entry->buf_count;
  399. buf->total   = alignment;
  400. buf->order   = order;
  401. buf->used    = 0;
  403. buf->offset  = (dma->byte_count + offset);
  404. buf->bus_address = agp_offset + offset;
  405. buf->address = (void *)(agp_offset + offset);
  406. buf->next    = NULL;
  407. buf->waiting = 0;
  408. buf->pending = 0;
  409. init_waitqueue_head( &buf->dma_wait );
  410. buf->pid     = 0;
  412. buf->dev_priv_size = sizeof(DRIVER_BUF_PRIV_T);
  413. buf->dev_private = DRM(alloc)( sizeof(DRIVER_BUF_PRIV_T),
  414.        DRM_MEM_BUFS );
  415. if(!buf->dev_private) {
  416. /* Set count correctly so we free the proper amount. */
  417. entry->buf_count = count;
  418. DRM(cleanup_buf_error)(entry);
  419. }
  420. memset( buf->dev_private, 0, buf->dev_priv_size );
  422. #if __HAVE_DMA_HISTOGRAM
  423. buf->time_queued = 0;
  424. buf->time_dispatched = 0;
  425. buf->time_completed = 0;
  426. buf->time_freed = 0;
  427. #endif
  428. DRM_DEBUG( "buffer %d @ %pn",
  429.    entry->buf_count, buf->address );
  431. offset += alignment;
  432. entry->buf_count++;
  433. byte_count += PAGE_SIZE << page_order;
  434. }
  436. DRM_DEBUG( "byte_count: %dn", byte_count );
  438. temp_buflist = DRM(realloc)( dma->buflist,
  439.      dma->buf_count * sizeof(*dma->buflist),
  440.      (dma->buf_count + entry->buf_count)
  441.      * sizeof(*dma->buflist),
  442.      DRM_MEM_BUFS );
  443. if(!temp_buflist) {
  444. /* Free the entry because it isn't valid */
  445. DRM(cleanup_buf_error)(entry);
  446. up( &dev->struct_sem );
  447. atomic_dec( &dev->buf_alloc );
  448. return -ENOMEM;
  449. }
  450. dma->buflist = temp_buflist;
  452. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  453. dma->buflist[i + dma->buf_count] = &entry->buflist[i];
  454. }
  456. dma->buf_count += entry->buf_count;
  457. dma->byte_count += byte_count;
  459. DRM_DEBUG( "dma->buf_count : %dn", dma->buf_count );
  460. DRM_DEBUG( "entry->buf_count : %dn", entry->buf_count );
  462. #if __HAVE_DMA_FREELIST
  463. DRM(freelist_create)( &entry->freelist, entry->buf_count );
  464. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  465. DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
  466. }
  467. #endif
  468. up( &dev->struct_sem );
  470. request.count = entry->buf_count;
  471. request.size = size;
  473. if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
  474. return -EFAULT;
  476. dma->flags = _DRM_DMA_USE_AGP;
  478. atomic_dec( &dev->buf_alloc );
  479. return 0;
  480. }
  481. #endif /* __REALLY_HAVE_AGP */
  483. #if __HAVE_PCI_DMA
  484. int DRM(addbufs_pci)( struct inode *inode, struct file *filp,
  485.       unsigned int cmd, unsigned long arg )
  486. {
  487.     drm_file_t *priv = filp->private_data;
  488. drm_device_t *dev = priv->dev;
  489. drm_device_dma_t *dma = dev->dma;
  490. drm_buf_desc_t request;
  491. int count;
  492. int order;
  493. int size;
  494. int total;
  495. int page_order;
  496. drm_buf_entry_t *entry;
  497. unsigned long page;
  498. drm_buf_t *buf;
  499. int alignment;
  500. unsigned long offset;
  501. int i;
  502. int byte_count;
  503. int page_count;
  504. unsigned long *temp_pagelist;
  505. drm_buf_t **temp_buflist;
  507. if ( !dma ) return -EINVAL;
  509. if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
  510.      sizeof(request) ) )
  511. return -EFAULT;
  513. count = request.count;
  514. order = DRM(order)( request.size );
  515. size = 1 << order;
  517. DRM_DEBUG( "count=%d, size=%d (%d), order=%d, queue_count=%dn",
  518.    request.count, request.size, size,
  519.    order, dev->queue_count );
  521. if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
  522. if ( dev->queue_count ) return -EBUSY; /* Not while in use */
  524. alignment = (request.flags & _DRM_PAGE_ALIGN)
  525. ? PAGE_ALIGN(size) : size;
  526. page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
  527. total = PAGE_SIZE << page_order;
  529. spin_lock( &dev->count_lock );
  530. if ( dev->buf_use ) {
  531. spin_unlock( &dev->count_lock );
  532. return -EBUSY;
  533. }
  534. atomic_inc( &dev->buf_alloc );
  535. spin_unlock( &dev->count_lock );
  537. down( &dev->struct_sem );
  538. entry = &dma->bufs[order];
  539. if ( entry->buf_count ) {
  540. up( &dev->struct_sem );
  541. atomic_dec( &dev->buf_alloc );
  542. return -ENOMEM; /* May only call once for each order */
  543. }
  545. if (count < 0 || count > 4096) {
  546. up( &dev->struct_sem );
  547. atomic_dec( &dev->buf_alloc );
  548. return -EINVAL;
  549. }
  551. entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
  552.     DRM_MEM_BUFS );
  553. if ( !entry->buflist ) {
  554. up( &dev->struct_sem );
  555. atomic_dec( &dev->buf_alloc );
  556. return -ENOMEM;
  557. }
  558. memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
  560. entry->seglist = DRM(alloc)( count * sizeof(*entry->seglist),
  561.     DRM_MEM_SEGS );
  562. if ( !entry->seglist ) {
  563. DRM(free)( entry->buflist,
  564.   count * sizeof(*entry->buflist),
  565.   DRM_MEM_BUFS );
  566. up( &dev->struct_sem );
  567. atomic_dec( &dev->buf_alloc );
  568. return -ENOMEM;
  569. }
  570. memset( entry->seglist, 0, count * sizeof(*entry->seglist) );
  572. temp_pagelist = DRM(realloc)( dma->pagelist,
  573.       dma->page_count * sizeof(*dma->pagelist),
  574.       (dma->page_count + (count << page_order))
  575.       * sizeof(*dma->pagelist),
  576.       DRM_MEM_PAGES );
  577. if(!temp_pagelist) {
  578. DRM(free)( entry->buflist,
  579.    count * sizeof(*entry->buflist),
  580.    DRM_MEM_BUFS );
  581. DRM(free)( entry->seglist,
  582.    count * sizeof(*entry->seglist),
  583.    DRM_MEM_SEGS );
  584. up( &dev->struct_sem );
  585. atomic_dec( &dev->buf_alloc );
  586. return -ENOMEM;
  587. }
  589. dma->pagelist = temp_pagelist;
  590. DRM_DEBUG( "pagelist: %d entriesn",
  591.    dma->page_count + (count << page_order) );
  593. entry->buf_size = size;
  594. entry->page_order = page_order;
  595. byte_count = 0;
  596. page_count = 0;
  598. while ( entry->buf_count < count ) {
  599. page = DRM(alloc_pages)( page_order, DRM_MEM_DMA );
  600. if ( !page ) break;
  601. entry->seglist[entry->seg_count++] = page;
  602. for ( i = 0 ; i < (1 << page_order) ; i++ ) {
  603. DRM_DEBUG( "page %d @ 0x%08lxn",
  604.    dma->page_count + page_count,
  605.    page + PAGE_SIZE * i );
  606. dma->pagelist[dma->page_count + page_count++]
  607. = page + PAGE_SIZE * i;
  608. }
  609. for ( offset = 0 ;
  610.       offset + size <= total && entry->buf_count < count ;
  611.       offset += alignment, ++entry->buf_count ) {
  612. buf      = &entry->buflist[entry->buf_count];
  613. buf->idx     = dma->buf_count + entry->buf_count;
  614. buf->total   = alignment;
  615. buf->order   = order;
  616. buf->used    = 0;
  617. buf->offset  = (dma->byte_count + byte_count + offset);
  618. buf->address = (void *)(page + offset);
  619. buf->next    = NULL;
  620. buf->waiting = 0;
  621. buf->pending = 0;
  622. init_waitqueue_head( &buf->dma_wait );
  623. buf->pid     = 0;
  624. #if __HAVE_DMA_HISTOGRAM
  625. buf->time_queued     = 0;
  626. buf->time_dispatched = 0;
  627. buf->time_completed  = 0;
  628. buf->time_freed      = 0;
  629. #endif
  630. DRM_DEBUG( "buffer %d @ %pn",
  631.    entry->buf_count, buf->address );
  632. }
  633. byte_count += PAGE_SIZE << page_order;
  634. }
  636. temp_buflist = DRM(realloc)( dma->buflist,
  637.      dma->buf_count * sizeof(*dma->buflist),
  638.      (dma->buf_count + entry->buf_count)
  639.      * sizeof(*dma->buflist),
  640.      DRM_MEM_BUFS );
  641. if(!temp_buflist) {
  642. /* Free the entry because it isn't valid */
  643. DRM(cleanup_buf_error)(entry);
  644. up( &dev->struct_sem );
  645. atomic_dec( &dev->buf_alloc );
  646. return -ENOMEM;
  647. }
  648. dma->buflist = temp_buflist;
  650. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  651. dma->buflist[i + dma->buf_count] = &entry->buflist[i];
  652. }
  654. dma->buf_count += entry->buf_count;
  655. dma->seg_count += entry->seg_count;
  656. dma->page_count += entry->seg_count << page_order;
  657. dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
  659. #if __HAVE_DMA_FREELIST
  660. DRM(freelist_create)( &entry->freelist, entry->buf_count );
  661. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  662. DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
  663. }
  664. #endif
  665. up( &dev->struct_sem );
  667. request.count = entry->buf_count;
  668. request.size = size;
  670. if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
  671. return -EFAULT;
  673. atomic_dec( &dev->buf_alloc );
  674. return 0;
  676. }
  677. #endif /* __HAVE_PCI_DMA */
  679. #ifdef __HAVE_SG
  680. int DRM(addbufs_sg)( struct inode *inode, struct file *filp,
  681.                      unsigned int cmd, unsigned long arg )
  682. {
  683. drm_file_t *priv = filp->private_data;
  684. drm_device_t *dev = priv->dev;
  685. drm_device_dma_t *dma = dev->dma;
  686. drm_buf_desc_t request;
  687. drm_buf_entry_t *entry;
  688. drm_buf_t *buf;
  689. unsigned long offset;
  690. unsigned long agp_offset;
  691. int count;
  692. int order;
  693. int size;
  694. int alignment;
  695. int page_order;
  696. int total;
  697. int byte_count;
  698. int i;
  699. drm_buf_t **temp_buflist;
  701. if ( !dma ) return -EINVAL;
  703. if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
  704.                              sizeof(request) ) )
  705. return -EFAULT;
  707. count = request.count;
  708. order = DRM(order)( request.size );
  709. size = 1 << order;
  711. alignment  = (request.flags & _DRM_PAGE_ALIGN)
  712. ? PAGE_ALIGN(size) : size;
  713. page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
  714. total = PAGE_SIZE << page_order;
  716. byte_count = 0;
  717. agp_offset = request.agp_start;
  719. DRM_DEBUG( "count:      %dn",  count );
  720. DRM_DEBUG( "order:      %dn",  order );
  721. DRM_DEBUG( "size:       %dn",  size );
  722. DRM_DEBUG( "agp_offset: %ldn", agp_offset );
  723. DRM_DEBUG( "alignment:  %dn",  alignment );
  724. DRM_DEBUG( "page_order: %dn",  page_order );
  725. DRM_DEBUG( "total:      %dn",  total );
  727. if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
  728. if ( dev->queue_count ) return -EBUSY; /* Not while in use */
  730. spin_lock( &dev->count_lock );
  731. if ( dev->buf_use ) {
  732. spin_unlock( &dev->count_lock );
  733. return -EBUSY;
  734. }
  735. atomic_inc( &dev->buf_alloc );
  736. spin_unlock( &dev->count_lock );
  738. down( &dev->struct_sem );
  739. entry = &dma->bufs[order];
  740. if ( entry->buf_count ) {
  741. up( &dev->struct_sem );
  742. atomic_dec( &dev->buf_alloc );
  743. return -ENOMEM; /* May only call once for each order */
  744. }
  746. if (count < 0 || count > 4096) {
  747. up( &dev->struct_sem );
  748. atomic_dec( &dev->buf_alloc );
  749. return -EINVAL;
  750. }
  752. entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
  753.      DRM_MEM_BUFS );
  754. if ( !entry->buflist ) {
  755. up( &dev->struct_sem );
  756. atomic_dec( &dev->buf_alloc );
  757. return -ENOMEM;
  758. }
  759. memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
  761. entry->buf_size = size;
  762. entry->page_order = page_order;
  764. offset = 0;
  766. while ( entry->buf_count < count ) {
  767. buf          = &entry->buflist[entry->buf_count];
  768. buf->idx     = dma->buf_count + entry->buf_count;
  769. buf->total   = alignment;
  770. buf->order   = order;
  771. buf->used    = 0;
  773. buf->offset  = (dma->byte_count + offset);
  774. buf->bus_address = agp_offset + offset;
  775. buf->address = (void *)(agp_offset + offset + dev->sg->handle);
  776. buf->next    = NULL;
  777. buf->waiting = 0;
  778. buf->pending = 0;
  779. init_waitqueue_head( &buf->dma_wait );
  780. buf->pid     = 0;
  782. buf->dev_priv_size = sizeof(DRIVER_BUF_PRIV_T);
  783. buf->dev_private = DRM(alloc)( sizeof(DRIVER_BUF_PRIV_T),
  784.        DRM_MEM_BUFS );
  785. if(!buf->dev_private) {
  786. /* Set count correctly so we free the proper amount. */
  787. entry->buf_count = count;
  788. DRM(cleanup_buf_error)(entry);
  789. up( &dev->struct_sem );
  790. atomic_dec( &dev->buf_alloc );
  791. return -ENOMEM;
  792. }
  794. memset( buf->dev_private, 0, buf->dev_priv_size );
  796. # if __HAVE_DMA_HISTOGRAM
  797. buf->time_queued = 0;
  798. buf->time_dispatched = 0;
  799. buf->time_completed = 0;
  800. buf->time_freed = 0;
  801. # endif
  802. DRM_DEBUG( "buffer %d @ %pn",
  803.    entry->buf_count, buf->address );
  805. offset += alignment;
  806. entry->buf_count++;
  807. byte_count += PAGE_SIZE << page_order;
  808. }
  810. DRM_DEBUG( "byte_count: %dn", byte_count );
  812. temp_buflist = DRM(realloc)( dma->buflist,
  813.      dma->buf_count * sizeof(*dma->buflist),
  814.      (dma->buf_count + entry->buf_count)
  815.      * sizeof(*dma->buflist),
  816.      DRM_MEM_BUFS );
  817. if(!temp_buflist) {
  818. /* Free the entry because it isn't valid */
  819. DRM(cleanup_buf_error)(entry);
  820. up( &dev->struct_sem );
  821. atomic_dec( &dev->buf_alloc );
  822. return -ENOMEM;
  823. }
  824. dma->buflist = temp_buflist;
  826. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  827. dma->buflist[i + dma->buf_count] = &entry->buflist[i];
  828. }
  830. dma->buf_count += entry->buf_count;
  831. dma->byte_count += byte_count;
  833. DRM_DEBUG( "dma->buf_count : %dn", dma->buf_count );
  834. DRM_DEBUG( "entry->buf_count : %dn", entry->buf_count );
  836. #if __HAVE_DMA_FREELIST
  837. DRM(freelist_create)( &entry->freelist, entry->buf_count );
  838. for ( i = 0 ; i < entry->buf_count ; i++ ) {
  839. DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
  840. }
  841. #endif
  842. up( &dev->struct_sem );
  844. request.count = entry->buf_count;
  845. request.size = size;
  847. if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
  848. return -EFAULT;
  850. dma->flags = _DRM_DMA_USE_SG;
  852. atomic_dec( &dev->buf_alloc );
  853. return 0;
  854. }
  855. #endif /* __HAVE_SG */
  857. int DRM(addbufs)( struct inode *inode, struct file *filp,
  858.   unsigned int cmd, unsigned long arg )
  859. {
  860. drm_buf_desc_t request;
  862. if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
  863.      sizeof(request) ) )
  864. return -EFAULT;
  866. #if __REALLY_HAVE_AGP
  867. if ( request.flags & _DRM_AGP_BUFFER )
  868. return DRM(addbufs_agp)( inode, filp, cmd, arg );
  869. else
  870. #endif
  871. #if __HAVE_SG
  872. if ( request.flags & _DRM_SG_BUFFER )
  873. return DRM(addbufs_sg)( inode, filp, cmd, arg );
  874. else
  875. #endif
  876. #if __HAVE_PCI_DMA
  877. return DRM(addbufs_pci)( inode, filp, cmd, arg );
  878. #else
  879. return -EINVAL;
  880. #endif
  881. }
  883. int DRM(infobufs)( struct inode *inode, struct file *filp,
  884.    unsigned int cmd, unsigned long arg )
  885. {
  886. drm_file_t *priv = filp->private_data;
  887. drm_device_t *dev = priv->dev;
  888. drm_device_dma_t *dma = dev->dma;
  889. drm_buf_info_t request;
  890. int i;
  891. int count;
  893. if ( !dma ) return -EINVAL;
  895. spin_lock( &dev->count_lock );
  896. if ( atomic_read( &dev->buf_alloc ) ) {
  897. spin_unlock( &dev->count_lock );
  898. return -EBUSY;
  899. }
  900. ++dev->buf_use; /* Can't allocate more after this call */
  901. spin_unlock( &dev->count_lock );
  903. if ( copy_from_user( &request,
  904.      (drm_buf_info_t *)arg,
  905.      sizeof(request) ) )
  906. return -EFAULT;
  908. for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
  909. if ( dma->bufs[i].buf_count ) ++count;
  910. }
  912. DRM_DEBUG( "count = %dn", count );
  914. if ( request.count >= count ) {
  915. for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
  916. if ( dma->bufs[i].buf_count ) {
  917. drm_buf_desc_t *to = &request.list[count];
  918. drm_buf_entry_t *from = &dma->bufs[i];
  919. drm_freelist_t *list = &dma->bufs[i].freelist;
  920. if ( copy_to_user( &to->count,
  921.    &from->buf_count,
  922.    sizeof(from->buf_count) ) ||
  923.      copy_to_user( &to->size,
  924.    &from->buf_size,
  925.    sizeof(from->buf_size) ) ||
  926.      copy_to_user( &to->low_mark,
  927.    &list->low_mark,
  928.    sizeof(list->low_mark) ) ||
  929.      copy_to_user( &to->high_mark,
  930.    &list->high_mark,
  931.    sizeof(list->high_mark) ) )
  932. return -EFAULT;
  934. DRM_DEBUG( "%d %d %d %d %dn",
  935.    i,
  936.    dma->bufs[i].buf_count,
  937.    dma->bufs[i].buf_size,
  938.    dma->bufs[i].freelist.low_mark,
  939.    dma->bufs[i].freelist.high_mark );
  940. ++count;
  941. }
  942. }
  943. }
  944. request.count = count;
  946. if ( copy_to_user( (drm_buf_info_t *)arg,
  947.    &request,
  948.    sizeof(request) ) )
  949. return -EFAULT;
  951. return 0;
  952. }
  954. int DRM(markbufs)( struct inode *inode, struct file *filp,
  955.    unsigned int cmd, unsigned long arg )
  956. {
  957. drm_file_t *priv = filp->private_data;
  958. drm_device_t *dev = priv->dev;
  959. drm_device_dma_t *dma = dev->dma;
  960. drm_buf_desc_t request;
  961. int order;
  962. drm_buf_entry_t *entry;
  964. if ( !dma ) return -EINVAL;
  966. if ( copy_from_user( &request,
  967.      (drm_buf_desc_t *)arg,
  968.      sizeof(request) ) )
  969. return -EFAULT;
  971. DRM_DEBUG( "%d, %d, %dn",
  972.    request.size, request.low_mark, request.high_mark );
  973. order = DRM(order)( request.size );
  974. if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
  975. entry = &dma->bufs[order];
  977. if ( request.low_mark < 0 || request.low_mark > entry->buf_count )
  978. return -EINVAL;
  979. if ( request.high_mark < 0 || request.high_mark > entry->buf_count )
  980. return -EINVAL;
  982. entry->freelist.low_mark  = request.low_mark;
  983. entry->freelist.high_mark = request.high_mark;
  985. return 0;
  986. }
  988. int DRM(freebufs)( struct inode *inode, struct file *filp,
  989.    unsigned int cmd, unsigned long arg )
  990. {
  991. drm_file_t *priv = filp->private_data;
  992. drm_device_t *dev = priv->dev;
  993. drm_device_dma_t *dma = dev->dma;
  994. drm_buf_free_t request;
  995. int i;
  996. int idx;
  997. drm_buf_t *buf;
  999. if ( !dma ) return -EINVAL;
  1001. if ( copy_from_user( &request,
  1002.      (drm_buf_free_t *)arg,
  1003.      sizeof(request) ) )
  1004. return -EFAULT;
  1006. DRM_DEBUG( "%dn", request.count );
  1007. for ( i = 0 ; i < request.count ; i++ ) {
  1008. if ( copy_from_user( &idx,
  1009.      &request.list[i],
  1010.      sizeof(idx) ) )
  1011. return -EFAULT;
  1012. if ( idx < 0 || idx >= dma->buf_count ) {
  1013. DRM_ERROR( "Index %d (of %d max)n",
  1014.    idx, dma->buf_count - 1 );
  1015. return -EINVAL;
  1016. }
  1017. buf = dma->buflist[idx];
  1018. if ( buf->pid != current->pid ) {
  1019. DRM_ERROR( "Process %d freeing buffer owned by %dn",
  1020.    current->pid, buf->pid );
  1021. return -EINVAL;
  1022. }
  1023. DRM(free_buffer)( dev, buf );
  1024. }
  1026. return 0;
  1027. }
  1029. int DRM(mapbufs)( struct inode *inode, struct file *filp,
  1030.   unsigned int cmd, unsigned long arg )
  1031. {
  1032. drm_file_t *priv = filp->private_data;
  1033. drm_device_t *dev = priv->dev;
  1034. drm_device_dma_t *dma = dev->dma;
  1035. int retcode = 0;
  1036. const int zero = 0;
  1037. unsigned long virtual;
  1038. unsigned long address;
  1039. drm_buf_map_t request;
  1040. int i;
  1042. if ( !dma ) return -EINVAL;
  1044. spin_lock( &dev->count_lock );
  1045. if ( atomic_read( &dev->buf_alloc ) ) {
  1046. spin_unlock( &dev->count_lock );
  1047. return -EBUSY;
  1048. }
  1049. dev->buf_use++; /* Can't allocate more after this call */
  1050. spin_unlock( &dev->count_lock );
  1052. if ( copy_from_user( &request, (drm_buf_map_t *)arg,
  1053.      sizeof(request) ) )
  1054. return -EFAULT;
  1056. if ( request.count >= dma->buf_count ) {
  1057. if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
  1058.      (__HAVE_SG && (dma->flags & _DRM_DMA_USE_SG)) ) {
  1059. drm_map_t *map = DRIVER_AGP_BUFFERS_MAP( dev );
  1061. if ( !map ) {
  1062. retcode = -EINVAL;
  1063. goto done;
  1064. }
  1066. #if LINUX_VERSION_CODE <= 0x020402
  1067. down( &current->mm->mmap_sem );
  1068. #else
  1069. down_write( &current->mm->mmap_sem );
  1070. #endif
  1071. virtual = do_mmap( filp, 0, map->size,
  1072.    PROT_READ | PROT_WRITE,
  1073.    MAP_SHARED,
  1074.    (unsigned long)map->offset );
  1075. #if LINUX_VERSION_CODE <= 0x020402
  1076. up( &current->mm->mmap_sem );
  1077. #else
  1078. up_write( &current->mm->mmap_sem );
  1079. #endif
  1080. } else {
  1081. #if LINUX_VERSION_CODE <= 0x020402
  1082. down( &current->mm->mmap_sem );
  1083. #else
  1084. down_write( &current->mm->mmap_sem );
  1085. #endif
  1086. virtual = do_mmap( filp, 0, dma->byte_count,
  1087.    PROT_READ | PROT_WRITE,
  1088.    MAP_SHARED, 0 );
  1089. #if LINUX_VERSION_CODE <= 0x020402
  1090. up( &current->mm->mmap_sem );
  1091. #else
  1092. up_write( &current->mm->mmap_sem );
  1093. #endif
  1094. }
  1095. if ( virtual > -1024UL ) {
  1096. /* Real error */
  1097. retcode = (signed long)virtual;
  1098. goto done;
  1099. }
  1100. request.virtual = (void *)virtual;
  1102. for ( i = 0 ; i < dma->buf_count ; i++ ) {
  1103. if ( copy_to_user( &request.list[i].idx,
  1104.    &dma->buflist[i]->idx,
  1105.    sizeof(request.list[0].idx) ) ) {
  1106. retcode = -EFAULT;
  1107. goto done;
  1108. }
  1109. if ( copy_to_user( &request.list[i].total,
  1110.    &dma->buflist[i]->total,
  1111.    sizeof(request.list[0].total) ) ) {
  1112. retcode = -EFAULT;
  1113. goto done;
  1114. }
  1115. if ( copy_to_user( &request.list[i].used,
  1116.    &zero,
  1117.    sizeof(zero) ) ) {
  1118. retcode = -EFAULT;
  1119. goto done;
  1120. }
  1121. address = virtual + dma->buflist[i]->offset; /* *** */
  1122. if ( copy_to_user( &request.list[i].address,
  1123.    &address,
  1124.    sizeof(address) ) ) {
  1125. retcode = -EFAULT;
  1126. goto done;
  1127. }
  1128. }
  1129. }
  1130.  done:
  1131. request.count = dma->buf_count;
  1132. DRM_DEBUG( "%d buffers, retcode = %dn", request.count, retcode );
  1134. if ( copy_to_user( (drm_buf_map_t *)arg, &request, sizeof(request) ) )
  1135. return -EFAULT;
  1137. return retcode;
  1138. }
  1140. #endif /* __HAVE_DMA */