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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
i830_dma.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：36k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

i830_dma.c：源码内容
  1. /* i830_dma.c -- DMA support for the I830 -*- linux-c -*-
  2.  * Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
  3.  *
  4.  * Copyright 1999 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.  * PRECISION INSIGHT 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 OTHER
  25.  * DEALINGS IN THE SOFTWARE.
  26.  *
  27.  * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
  28.  *     Jeff Hartmann <jhartmann@valinux.com>
  29.  *      Keith Whitwell <keithw@valinux.com>
  30.  *      Abraham vd Merwe <abraham@2d3d.co.za>
  31.  *
  32.  */
  34. #include "i830.h"
  35. #include "drmP.h"
  36. #include "i830_drv.h"
  37. #include <linux/interrupt.h> /* For task queue support */
  38. #include <linux/delay.h>
  39. /* in case we don't have a 2.3.99-pre6 kernel or later: */
  40. #ifndef VM_DONTCOPY
  41. #define VM_DONTCOPY 0
  42. #endif
  44. #define I830_BUF_FREE 2
  45. #define I830_BUF_CLIENT 1
  46. #define I830_BUF_HARDWARE       0
  48. #define I830_BUF_UNMAPPED 0
  49. #define I830_BUF_MAPPED   1
  51. #define RING_LOCALS unsigned int outring, ringmask; volatile char *virt;
  54. #define DO_IDLE_WORKAROUND()
  55. do {
  56.    int _head;
  57.    int _tail;
  58.    do { 
  59.       _head = I830_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
  60.       _tail = I830_READ(LP_RING + RING_TAIL) & TAIL_ADDR;
  61.       udelay(1);
  62.    } while(_head != _tail);
  63. } while(0)
  65. #define I830_SYNC_WORKAROUND 0
  67. #define BEGIN_LP_RING(n) do {
  68. if (I830_VERBOSE)
  69. DRM_DEBUG("BEGIN_LP_RING(%d) in %sn",
  70.   n, __FUNCTION__);
  71. if (I830_SYNC_WORKAROUND)
  72. DO_IDLE_WORKAROUND();
  73. if (dev_priv->ring.space < n*4) 
  74. i830_wait_ring(dev, n*4);
  75. dev_priv->ring.space -= n*4;
  76. outring = dev_priv->ring.tail;
  77. ringmask = dev_priv->ring.tail_mask;
  78. virt = dev_priv->ring.virtual_start;
  79. } while (0)
  81. #define ADVANCE_LP_RING() do {
  82. if (I830_VERBOSE) DRM_DEBUG("ADVANCE_LP_RINGn");
  83. dev_priv->ring.tail = outring;
  84. I830_WRITE(LP_RING + RING_TAIL, outring);
  85. } while(0)
  87. #define OUT_RING(n) do {
  88. if (I830_VERBOSE) DRM_DEBUG("   OUT_RING %xn", (int)(n));
  89. *(volatile unsigned int *)(virt + outring) = n;
  90. outring += 4;
  91. outring &= ringmask;
  92. } while (0);
  94. static inline void i830_print_status_page(drm_device_t *dev)
  95. {
  96.     drm_device_dma_t *dma = dev->dma;
  97.        drm_i830_private_t *dev_priv = dev->dev_private;
  98. u8 *temp = dev_priv->hw_status_page;
  99.     int i;
  101.     DRM_DEBUG(  "hw_status: Interrupt Status : %xn", temp[0]);
  102.     DRM_DEBUG(  "hw_status: LpRing Head ptr : %xn", temp[1]);
  103.     DRM_DEBUG(  "hw_status: IRing Head ptr : %xn", temp[2]);
  104.        DRM_DEBUG(  "hw_status: Reserved : %xn", temp[3]);
  105.     DRM_DEBUG(  "hw_status: Driver Counter : %dn", temp[5]);
  106.     for(i = 9; i < dma->buf_count + 9; i++) {
  107.     DRM_DEBUG( "buffer status idx : %d used: %dn", i - 9, temp[i]);
  108. }
  109. }
  111. static drm_buf_t *i830_freelist_get(drm_device_t *dev)
  112. {
  113.     drm_device_dma_t *dma = dev->dma;
  114. int  i;
  115.     int   used;
  116.    
  117. /* Linear search might not be the best solution */
  119.     for (i = 0; i < dma->buf_count; i++) {
  120.     drm_buf_t *buf = dma->buflist[ i ];
  121.     drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  122. /* In use is already a pointer */
  123.     used = cmpxchg(buf_priv->in_use, I830_BUF_FREE, 
  124.        I830_BUF_CLIENT);
  125.     if(used == I830_BUF_FREE) {
  126. return buf;
  127. }
  128. }
  129.     return NULL;
  130. }
  132. /* This should only be called if the buffer is not sent to the hardware
  133.  * yet, the hardware updates in use for us once its on the ring buffer.
  134.  */
  136. static int i830_freelist_put(drm_device_t *dev, drm_buf_t *buf)
  137. {
  138.     drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  139.     int used;
  140.    
  141.     /* In use is already a pointer */
  142.     used = cmpxchg(buf_priv->in_use, I830_BUF_CLIENT, I830_BUF_FREE);
  143.     if(used != I830_BUF_CLIENT) {
  144.     DRM_ERROR("Freeing buffer thats not in use : %dn", buf->idx);
  145.     return -EINVAL;
  146. }
  147.    
  148.     return 0;
  149. }
  151. static struct file_operations i830_buffer_fops = {
  152. open:  DRM(open),
  153. flush:  DRM(flush),
  154. release: DRM(release),
  155. ioctl:  DRM(ioctl),
  156. mmap:  i830_mmap_buffers,
  157. read:  DRM(read),
  158. fasync:  DRM(fasync),
  159.        poll:  DRM(poll),
  160. };
  162. int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
  163. {
  164. drm_file_t     *priv   = filp->private_data;
  165. drm_device_t     *dev;
  166. drm_i830_private_t  *dev_priv;
  167. drm_buf_t           *buf;
  168. drm_i830_buf_priv_t *buf_priv;
  170. lock_kernel();
  171. dev  = priv->dev;
  172. dev_priv = dev->dev_private;
  173. buf      = dev_priv->mmap_buffer;
  174. buf_priv = buf->dev_private;
  175.    
  176. vma->vm_flags |= (VM_IO | VM_DONTCOPY);
  177. vma->vm_file = filp;
  178.    
  179.     buf_priv->currently_mapped = I830_BUF_MAPPED;
  180. unlock_kernel();
  182. if (remap_page_range(vma->vm_start,
  183.      VM_OFFSET(vma),
  184.      vma->vm_end - vma->vm_start,
  185.      vma->vm_page_prot)) return -EAGAIN;
  186. return 0;
  187. }
  189. static int i830_map_buffer(drm_buf_t *buf, struct file *filp)
  190. {
  191. drm_file_t   *priv   = filp->private_data;
  192. drm_device_t   *dev   = priv->dev;
  193. drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  194.        drm_i830_private_t *dev_priv = dev->dev_private;
  195.     struct file_operations *old_fops;
  196. int retcode = 0;
  198. if(buf_priv->currently_mapped == I830_BUF_MAPPED) return -EINVAL;
  200. if(VM_DONTCOPY != 0) {
  201. down_write( &current->mm->mmap_sem );
  202. old_fops = filp->f_op;
  203. filp->f_op = &i830_buffer_fops;
  204. dev_priv->mmap_buffer = buf;
  205. buf_priv->virtual = (void *)do_mmap(filp, 0, buf->total, 
  206.     PROT_READ|PROT_WRITE,
  207.     MAP_SHARED, 
  208.     buf->bus_address);
  209. dev_priv->mmap_buffer = NULL;
  210.     filp->f_op = old_fops;
  211. if ((unsigned long)buf_priv->virtual > -1024UL) {
  212. /* Real error */
  213. DRM_DEBUG("mmap errorn");
  214. retcode = (signed int)buf_priv->virtual;
  215. buf_priv->virtual = 0;
  216. }
  217. up_write( &current->mm->mmap_sem );
  218. } else {
  219. buf_priv->virtual = buf_priv->kernel_virtual;
  220.     buf_priv->currently_mapped = I830_BUF_MAPPED;
  221. }
  222. return retcode;
  223. }
  225. static int i830_unmap_buffer(drm_buf_t *buf)
  226. {
  227. drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  228. int retcode = 0;
  230. if(VM_DONTCOPY != 0) {
  231. if(buf_priv->currently_mapped != I830_BUF_MAPPED) 
  232. return -EINVAL;
  233. down_write( &current->mm->mmap_sem );
  234.          retcode = do_munmap(current->mm, 
  235.     (unsigned long)buf_priv->virtual, 
  236.     (size_t) buf->total);
  237.     up_write( &current->mm->mmap_sem );
  238. }
  239.     buf_priv->currently_mapped = I830_BUF_UNMAPPED;
  240.     buf_priv->virtual = 0;
  242. return retcode;
  243. }
  245. static int i830_dma_get_buffer(drm_device_t *dev, drm_i830_dma_t *d, 
  246.        struct file *filp)
  247. {
  248. drm_file_t   *priv   = filp->private_data;
  249. drm_buf_t   *buf;
  250. drm_i830_buf_priv_t *buf_priv;
  251. int retcode = 0;
  253. buf = i830_freelist_get(dev);
  254. if (!buf) {
  255. retcode = -ENOMEM;
  256.     DRM_DEBUG("retcode=%dn", retcode);
  257. return retcode;
  258. }
  259.    
  260. retcode = i830_map_buffer(buf, filp);
  261. if(retcode) {
  262. i830_freelist_put(dev, buf);
  263.     DRM_DEBUG("mapbuf failed, retcode %dn", retcode);
  264. return retcode;
  265. }
  266. buf->pid     = priv->pid;
  267. buf_priv = buf->dev_private;
  268. d->granted = 1;
  269.     d->request_idx = buf->idx;
  270.     d->request_size = buf->total;
  271.     d->virtual = buf_priv->virtual;
  273. return retcode;
  274. }
  276. static int i830_dma_cleanup(drm_device_t *dev)
  277. {
  278. drm_device_dma_t *dma = dev->dma;
  280. if(dev->dev_private) {
  281. int i;
  282.     drm_i830_private_t *dev_priv = 
  283.       (drm_i830_private_t *) dev->dev_private;
  284.    
  285.     if(dev_priv->ring.virtual_start) {
  286.     DRM(ioremapfree)((void *) dev_priv->ring.virtual_start,
  287.  dev_priv->ring.Size);
  288. }
  289.     if(dev_priv->hw_status_page != NULL) {
  290.     pci_free_consistent(dev->pdev, PAGE_SIZE, 
  291.         dev_priv->hw_status_page, dev_priv->dma_status_page);
  292.     /* Need to rewrite hardware status page */
  293.     I830_WRITE(0x02080, 0x1ffff000);
  294. }
  295.     DRM(free)(dev->dev_private, sizeof(drm_i830_private_t), 
  296.  DRM_MEM_DRIVER);
  297.     dev->dev_private = NULL;
  299. for (i = 0; i < dma->buf_count; i++) {
  300. drm_buf_t *buf = dma->buflist[ i ];
  301. drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  302. DRM(ioremapfree)(buf_priv->kernel_virtual, buf->total);
  303. }
  304. }
  305.     return 0;
  306. }
  308. static int i830_wait_ring(drm_device_t *dev, int n)
  309. {
  310.     drm_i830_private_t *dev_priv = dev->dev_private;
  311.     drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
  312.     int iters = 0;
  313.     unsigned long end;
  314. unsigned int last_head = I830_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
  316. end = jiffies + (HZ*3);
  317.     while (ring->space < n) {
  318.     ring->head = I830_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
  319.     ring->space = ring->head - (ring->tail+8);
  320. if (ring->space < 0) ring->space += ring->Size;
  321.    
  322. if (ring->head != last_head) {
  323. end = jiffies + (HZ*3);
  324. last_head = ring->head;
  325. }
  326.   
  327.     iters++;
  328. if(time_before(end,jiffies)) {
  329.     DRM_ERROR("space: %d wanted %dn", ring->space, n);
  330.     DRM_ERROR("lockupn");
  331.     goto out_wait_ring;
  332. }
  334.     udelay(1);
  335. }
  337. out_wait_ring:   
  338.     return iters;
  339. }
  341. static void i830_kernel_lost_context(drm_device_t *dev)
  342. {
  343.        drm_i830_private_t *dev_priv = dev->dev_private;
  344.     drm_i830_ring_buffer_t *ring = &(dev_priv->ring);
  345.       
  346.     ring->head = I830_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
  347.       ring->tail = I830_READ(LP_RING + RING_TAIL);
  348.       ring->space = ring->head - (ring->tail+8);
  349.       if (ring->space < 0) ring->space += ring->Size;
  350. }
  352. static int i830_freelist_init(drm_device_t *dev, drm_i830_private_t *dev_priv)
  353. {
  354.        drm_device_dma_t *dma = dev->dma;
  355.     int my_idx = 36;
  356.     u32 *hw_status = (u32 *)(dev_priv->hw_status_page + my_idx);
  357.     int i;
  359.     if(dma->buf_count > 1019) {
  360.     /* Not enough space in the status page for the freelist */
  361.     return -EINVAL;
  362. }
  364.     for (i = 0; i < dma->buf_count; i++) {
  365.     drm_buf_t *buf = dma->buflist[ i ];
  366.     drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  368.     buf_priv->in_use = hw_status++;
  369.     buf_priv->my_use_idx = my_idx;
  370.     my_idx += 4;
  372.     *buf_priv->in_use = I830_BUF_FREE;
  374. buf_priv->kernel_virtual = DRM(ioremap)(buf->bus_address, 
  375. buf->total);
  376. }
  377. return 0;
  378. }
  380. static int i830_dma_initialize(drm_device_t *dev, 
  381.        drm_i830_private_t *dev_priv,
  382.        drm_i830_init_t *init)
  383. {
  384. struct list_head *list;
  386.     memset(dev_priv, 0, sizeof(drm_i830_private_t));
  388. list_for_each(list, &dev->maplist->head) {
  389. drm_map_list_t *r_list = (drm_map_list_t *)list;
  390. if( r_list->map &&
  391.     r_list->map->type == _DRM_SHM &&
  392.     r_list->map->flags & _DRM_CONTAINS_LOCK ) {
  393. dev_priv->sarea_map = r_list->map;
  394.   break;
  395.   }
  396.   }
  398. if(!dev_priv->sarea_map) {
  399. dev->dev_private = (void *)dev_priv;
  400. i830_dma_cleanup(dev);
  401. DRM_ERROR("can not find sarea!n");
  402. return -EINVAL;
  403. }
  404. DRM_FIND_MAP( dev_priv->mmio_map, init->mmio_offset );
  405. if(!dev_priv->mmio_map) {
  406. dev->dev_private = (void *)dev_priv;
  407. i830_dma_cleanup(dev);
  408. DRM_ERROR("can not find mmio map!n");
  409. return -EINVAL;
  410. }
  411. DRM_FIND_MAP( dev_priv->buffer_map, init->buffers_offset );
  412. if(!dev_priv->buffer_map) {
  413. dev->dev_private = (void *)dev_priv;
  414. i830_dma_cleanup(dev);
  415. DRM_ERROR("can not find dma buffer map!n");
  416. return -EINVAL;
  417. }
  419. dev_priv->sarea_priv = (drm_i830_sarea_t *)
  420. ((u8 *)dev_priv->sarea_map->handle +
  421.  init->sarea_priv_offset);
  423.     atomic_set(&dev_priv->flush_done, 0);
  424. init_waitqueue_head(&dev_priv->flush_queue);
  426.     dev_priv->ring.Start = init->ring_start;
  427.     dev_priv->ring.End = init->ring_end;
  428.     dev_priv->ring.Size = init->ring_size;
  430.     dev_priv->ring.virtual_start = DRM(ioremap)(dev->agp->base + 
  431.     init->ring_start, 
  432.     init->ring_size);
  434.     if (dev_priv->ring.virtual_start == NULL) {
  435. dev->dev_private = (void *) dev_priv;
  436.     i830_dma_cleanup(dev);
  437.     DRM_ERROR("can not ioremap virtual address for"
  438.   " ring buffern");
  439.     return -ENOMEM;
  440. }
  442.     dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
  443.    
  444. dev_priv->w = init->w;
  445. dev_priv->h = init->h;
  446. dev_priv->pitch = init->pitch;
  447. dev_priv->back_offset = init->back_offset;
  448. dev_priv->depth_offset = init->depth_offset;
  450. dev_priv->front_di1 = init->front_offset | init->pitch_bits;
  451. dev_priv->back_di1 = init->back_offset | init->pitch_bits;
  452. dev_priv->zi1 = init->depth_offset | init->pitch_bits;
  454. dev_priv->cpp = init->cpp;
  455. /* We are using seperate values as placeholders for mechanisms for
  456.  * private backbuffer/depthbuffer usage.
  457.  */
  459. dev_priv->back_pitch = init->back_pitch;
  460. dev_priv->depth_pitch = init->depth_pitch;
  462.     /* Program Hardware Status Page */
  463.     dev_priv->hw_status_page = pci_alloc_consistent(dev->pdev, PAGE_SIZE, 
  464. &dev_priv->dma_status_page);
  465.     if(dev_priv->hw_status_page == NULL) {
  466. dev->dev_private = (void *)dev_priv;
  467. i830_dma_cleanup(dev);
  468. DRM_ERROR("Can not allocate hardware status pagen");
  469. return -ENOMEM;
  470. }
  471.     memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
  472. DRM_DEBUG("hw status page @ %pn", dev_priv->hw_status_page);
  473.    
  474.     I830_WRITE(0x02080, dev_priv->dma_status_page);
  475. DRM_DEBUG("Enabled hardware status pagen");
  476.    
  477.     /* Now we need to init our freelist */
  478.     if(i830_freelist_init(dev, dev_priv) != 0) {
  479. dev->dev_private = (void *)dev_priv;
  480.     i830_dma_cleanup(dev);
  481.     DRM_ERROR("Not enough space in the status page for"
  482.   " the freelistn");
  483.     return -ENOMEM;
  484. }
  485. dev->dev_private = (void *)dev_priv;
  487.     return 0;
  488. }
  490. int i830_dma_init(struct inode *inode, struct file *filp,
  491.   unsigned int cmd, unsigned long arg)
  492. {
  493.     drm_file_t *priv = filp->private_data;
  494.     drm_device_t *dev = priv->dev;
  495.     drm_i830_private_t *dev_priv;
  496.     drm_i830_init_t init;
  497.     int retcode = 0;
  499.    if (copy_from_user(&init, (drm_i830_init_t *)arg, sizeof(init)))
  500. return -EFAULT;
  502.     switch(init.func) {
  503.   case I830_INIT_DMA:
  504. dev_priv = DRM(alloc)(sizeof(drm_i830_private_t), 
  505.       DRM_MEM_DRIVER);
  506.     if(dev_priv == NULL) return -ENOMEM;
  507.     retcode = i830_dma_initialize(dev, dev_priv, &init);
  508.     break;
  509.   case I830_CLEANUP_DMA:
  510.     retcode = i830_dma_cleanup(dev);
  511.     break;
  512.   default:
  513.     retcode = -EINVAL;
  514.     break;
  515. }
  516.    
  517.     return retcode;
  518. }
  520. /* Most efficient way to verify state for the i830 is as it is
  521.  * emitted.  Non-conformant state is silently dropped.
  522.  *
  523.  * Use 'volatile' & local var tmp to force the emitted values to be
  524.  * identical to the verified ones.
  525.  */
  526. static void i830EmitContextVerified( drm_device_t *dev, 
  527.      volatile unsigned int *code )
  528. {
  529.     drm_i830_private_t *dev_priv = dev->dev_private;
  530. int i, j = 0;
  531. unsigned int tmp;
  532. RING_LOCALS;
  534. BEGIN_LP_RING( I830_CTX_SETUP_SIZE );
  535. for ( i = 0 ; i < I830_CTX_SETUP_SIZE ; i++ ) {
  536. tmp = code[i];
  538. #if 0
  539. if ((tmp & (7<<29)) == (3<<29) &&
  540.     (tmp & (0x1f<<24)) < (0x1d<<24)) {
  541. OUT_RING( tmp ); 
  542. j++;
  543. } else {
  544. printk("Skipping %dn", i);
  545. }
  546. #else
  547. OUT_RING( tmp ); 
  548. j++;
  549. #endif
  550. }
  552. if (j & 1) 
  553. OUT_RING( 0 ); 
  555. ADVANCE_LP_RING();
  556. }
  558. static void i830EmitTexVerified( drm_device_t *dev, 
  559.  volatile unsigned int *code ) 
  560. {
  561.     drm_i830_private_t *dev_priv = dev->dev_private;
  562. int i, j = 0;
  563. unsigned int tmp;
  564. RING_LOCALS;
  566. BEGIN_LP_RING( I830_TEX_SETUP_SIZE );
  568. OUT_RING( GFX_OP_MAP_INFO );
  569. OUT_RING( code[I830_TEXREG_MI1] );
  570. OUT_RING( code[I830_TEXREG_MI2] );
  571. OUT_RING( code[I830_TEXREG_MI3] );
  572. OUT_RING( code[I830_TEXREG_MI4] );
  573. OUT_RING( code[I830_TEXREG_MI5] );
  575. for ( i = 6 ; i < I830_TEX_SETUP_SIZE ; i++ ) {
  576. tmp = code[i];
  577. OUT_RING( tmp ); 
  578. j++;
  579. } 
  581. if (j & 1) 
  582. OUT_RING( 0 ); 
  584. ADVANCE_LP_RING();
  585. }
  587. static void i830EmitTexBlendVerified( drm_device_t *dev, 
  588.      volatile unsigned int *code,
  589.      volatile unsigned int num)
  590. {
  591.     drm_i830_private_t *dev_priv = dev->dev_private;
  592. int i, j = 0;
  593. unsigned int tmp;
  594. RING_LOCALS;
  596. BEGIN_LP_RING( num );
  598. for ( i = 0 ; i < num ; i++ ) {
  599. tmp = code[i];
  600. OUT_RING( tmp );
  601. j++;
  602. }
  604. if (j & 1) 
  605. OUT_RING( 0 ); 
  607. ADVANCE_LP_RING();
  608. }
  610. static void i830EmitTexPalette( drm_device_t *dev,
  611.         unsigned int *palette,
  612.         int number,
  613.         int is_shared )
  614. {
  615.     drm_i830_private_t *dev_priv = dev->dev_private;
  616. int i;
  617. RING_LOCALS;
  619. BEGIN_LP_RING( 258 );
  621. if(is_shared == 1) {
  622. OUT_RING(CMD_OP_MAP_PALETTE_LOAD |
  623.  MAP_PALETTE_NUM(0) |
  624.  MAP_PALETTE_BOTH);
  625. } else {
  626. OUT_RING(CMD_OP_MAP_PALETTE_LOAD | MAP_PALETTE_NUM(number));
  627. }
  628. for(i = 0; i < 256; i++) {
  629. OUT_RING(palette[i]);
  630. }
  631. OUT_RING(0);
  632. }
  634. /* Need to do some additional checking when setting the dest buffer.
  635.  */
  636. static void i830EmitDestVerified( drm_device_t *dev, 
  637.   volatile unsigned int *code ) 
  638. {
  639.     drm_i830_private_t *dev_priv = dev->dev_private;
  640. unsigned int tmp;
  641. RING_LOCALS;
  643. BEGIN_LP_RING( I830_DEST_SETUP_SIZE + 6 );
  645. tmp = code[I830_DESTREG_CBUFADDR];
  646. if (tmp == dev_priv->front_di1) {
  647. /* Don't use fence when front buffer rendering */
  648. OUT_RING( CMD_OP_DESTBUFFER_INFO );
  649. OUT_RING( BUF_3D_ID_COLOR_BACK | 
  650.   BUF_3D_PITCH(dev_priv->back_pitch * dev_priv->cpp) );
  651. OUT_RING( tmp );
  653. OUT_RING( CMD_OP_DESTBUFFER_INFO );
  654. OUT_RING( BUF_3D_ID_DEPTH |
  655.   BUF_3D_PITCH(dev_priv->depth_pitch * dev_priv->cpp));
  656. OUT_RING( dev_priv->zi1 );
  657. } else if(tmp == dev_priv->back_di1) {
  658. OUT_RING( CMD_OP_DESTBUFFER_INFO );
  659. OUT_RING( BUF_3D_ID_COLOR_BACK | 
  660.   BUF_3D_PITCH(dev_priv->back_pitch * dev_priv->cpp) |
  661.   BUF_3D_USE_FENCE);
  662. OUT_RING( tmp );
  664. OUT_RING( CMD_OP_DESTBUFFER_INFO );
  665. OUT_RING( BUF_3D_ID_DEPTH | BUF_3D_USE_FENCE | 
  666.   BUF_3D_PITCH(dev_priv->depth_pitch * dev_priv->cpp));
  667. OUT_RING( dev_priv->zi1 );
  668. } else {
  669. DRM_DEBUG("bad di1 %x (allow %x or %x)n",
  670.   tmp, dev_priv->front_di1, dev_priv->back_di1);
  671. }
  673. /* invarient:
  674.  */
  677. OUT_RING( GFX_OP_DESTBUFFER_VARS );
  678. OUT_RING( code[I830_DESTREG_DV1] );
  680. OUT_RING( GFX_OP_DRAWRECT_INFO );
  681. OUT_RING( code[I830_DESTREG_DR1] );
  682. OUT_RING( code[I830_DESTREG_DR2] );
  683. OUT_RING( code[I830_DESTREG_DR3] );
  684. OUT_RING( code[I830_DESTREG_DR4] );
  686. /* Need to verify this */
  687. tmp = code[I830_DESTREG_SENABLE];
  688. if((tmp & ~0x3) == GFX_OP_SCISSOR_ENABLE) {
  689. OUT_RING( tmp );
  690. } else {
  691. DRM_DEBUG("bad scissor enablen");
  692. OUT_RING( 0 );
  693. }
  695. OUT_RING( code[I830_DESTREG_SENABLE] );
  697. OUT_RING( GFX_OP_SCISSOR_RECT );
  698. OUT_RING( code[I830_DESTREG_SR1] );
  699. OUT_RING( code[I830_DESTREG_SR2] );
  701. ADVANCE_LP_RING();
  702. }
  704. static void i830EmitState( drm_device_t *dev )
  705. {
  706.     drm_i830_private_t *dev_priv = dev->dev_private;
  707.        drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
  708. unsigned int dirty = sarea_priv->dirty;
  710. if (dirty & I830_UPLOAD_BUFFERS) {
  711. i830EmitDestVerified( dev, sarea_priv->BufferState );
  712. sarea_priv->dirty &= ~I830_UPLOAD_BUFFERS;
  713. }
  715. if (dirty & I830_UPLOAD_CTX) {
  716. i830EmitContextVerified( dev, sarea_priv->ContextState );
  717. sarea_priv->dirty &= ~I830_UPLOAD_CTX;
  718. }
  720. if (dirty & I830_UPLOAD_TEX0) {
  721. i830EmitTexVerified( dev, sarea_priv->TexState[0] );
  722. sarea_priv->dirty &= ~I830_UPLOAD_TEX0;
  723. }
  725. if (dirty & I830_UPLOAD_TEX1) {
  726. i830EmitTexVerified( dev, sarea_priv->TexState[1] );
  727. sarea_priv->dirty &= ~I830_UPLOAD_TEX1;
  728. }
  730. if (dirty & I830_UPLOAD_TEXBLEND0) {
  731. i830EmitTexBlendVerified( dev, sarea_priv->TexBlendState[0],
  732. sarea_priv->TexBlendStateWordsUsed[0]);
  733. sarea_priv->dirty &= ~I830_UPLOAD_TEXBLEND0;
  734. }
  736. if (dirty & I830_UPLOAD_TEXBLEND1) {
  737. i830EmitTexBlendVerified( dev, sarea_priv->TexBlendState[1],
  738. sarea_priv->TexBlendStateWordsUsed[1]);
  739. sarea_priv->dirty &= ~I830_UPLOAD_TEXBLEND1;
  740. }
  742. if (dirty & I830_UPLOAD_TEX_PALETTE_SHARED) {
  743.    i830EmitTexPalette(dev, sarea_priv->Palette[0], 0, 1);
  744. } else {
  745.    if (dirty & I830_UPLOAD_TEX_PALETTE_N(0)) {
  746.       i830EmitTexPalette(dev, sarea_priv->Palette[0], 0, 0);
  747.       sarea_priv->dirty &= ~I830_UPLOAD_TEX_PALETTE_N(0);
  748.    }
  749.    if (dirty & I830_UPLOAD_TEX_PALETTE_N(1)) {
  750.       i830EmitTexPalette(dev, sarea_priv->Palette[1], 1, 0);
  751.       sarea_priv->dirty &= ~I830_UPLOAD_TEX_PALETTE_N(1);
  752.    }
  753. }
  754. }
  756. static void i830_dma_dispatch_clear( drm_device_t *dev, int flags, 
  757.     unsigned int clear_color,
  758.     unsigned int clear_zval,
  759.     unsigned int clear_depthmask)
  760. {
  761.     drm_i830_private_t *dev_priv = dev->dev_private;
  762.        drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
  763. int nbox = sarea_priv->nbox;
  764. drm_clip_rect_t *pbox = sarea_priv->boxes;
  765. int pitch = dev_priv->pitch;
  766. int cpp = dev_priv->cpp;
  767. int i;
  768. unsigned int BR13, CMD, D_CMD;
  769. RING_LOCALS;
  771.    i830_kernel_lost_context(dev);
  773. switch(cpp) {
  774. case 2: 
  775. BR13 = (0xF0 << 16) | (pitch * cpp) | (1<<24);
  776. D_CMD = CMD = XY_COLOR_BLT_CMD;
  777. break;
  778. case 4:
  779. BR13 = (0xF0 << 16) | (pitch * cpp) | (1<<24) | (1<<25);
  780. CMD = (XY_COLOR_BLT_CMD | XY_COLOR_BLT_WRITE_ALPHA | 
  781.        XY_COLOR_BLT_WRITE_RGB);
  782. D_CMD = XY_COLOR_BLT_CMD;
  783. if(clear_depthmask & 0x00ffffff)
  784. D_CMD |= XY_COLOR_BLT_WRITE_RGB;
  785. if(clear_depthmask & 0xff000000)
  786. D_CMD |= XY_COLOR_BLT_WRITE_ALPHA;
  787. break;
  788. default:
  789. BR13 = (0xF0 << 16) | (pitch * cpp) | (1<<24);
  790. D_CMD = CMD = XY_COLOR_BLT_CMD;
  791. break;
  792. }
  794.        if (nbox > I830_NR_SAREA_CLIPRECTS)
  795.       nbox = I830_NR_SAREA_CLIPRECTS;
  797. for (i = 0 ; i < nbox ; i++, pbox++) {
  798. if (pbox->x1 > pbox->x2 ||
  799.     pbox->y1 > pbox->y2 ||
  800.     pbox->x2 > dev_priv->w ||
  801.     pbox->y2 > dev_priv->h)
  802. continue;
  804.     if ( flags & I830_FRONT ) {     
  805.     DRM_DEBUG("clear frontn");
  806. BEGIN_LP_RING( 6 );     
  807. OUT_RING( CMD );
  808. OUT_RING( BR13 );
  809. OUT_RING( (pbox->y1 << 16) | pbox->x1 );
  810. OUT_RING( (pbox->y2 << 16) | pbox->x2 );
  811. OUT_RING( 0 );
  812. OUT_RING( clear_color );
  813. ADVANCE_LP_RING();
  814. }
  816. if ( flags & I830_BACK ) {
  817. DRM_DEBUG("clear backn");
  818. BEGIN_LP_RING( 6 );     
  819. OUT_RING( CMD );
  820. OUT_RING( BR13 );
  821. OUT_RING( (pbox->y1 << 16) | pbox->x1 );
  822. OUT_RING( (pbox->y2 << 16) | pbox->x2 );
  823. OUT_RING( dev_priv->back_offset );
  824. OUT_RING( clear_color );
  825. ADVANCE_LP_RING();
  826. }
  828. if ( flags & I830_DEPTH ) {
  829. DRM_DEBUG("clear depthn");
  830. BEGIN_LP_RING( 6 );
  831. OUT_RING( D_CMD );
  832. OUT_RING( BR13 );
  833. OUT_RING( (pbox->y1 << 16) | pbox->x1 );
  834. OUT_RING( (pbox->y2 << 16) | pbox->x2 );
  835. OUT_RING( dev_priv->depth_offset );
  836. OUT_RING( clear_zval );
  837. ADVANCE_LP_RING();
  838. }
  839. }
  840. }
  842. static void i830_dma_dispatch_swap( drm_device_t *dev )
  843. {
  844.     drm_i830_private_t *dev_priv = dev->dev_private;
  845.        drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
  846. int nbox = sarea_priv->nbox;
  847. drm_clip_rect_t *pbox = sarea_priv->boxes;
  848. int pitch = dev_priv->pitch;
  849. int cpp = dev_priv->cpp;
  850. int ofs = dev_priv->back_offset;
  851. int i;
  852. unsigned int CMD, BR13;
  853. RING_LOCALS;
  855. DRM_DEBUG("swapbuffersn");
  857. switch(cpp) {
  858. case 2: 
  859. BR13 = (pitch * cpp) | (0xCC << 16) | (1<<24);
  860. CMD = XY_SRC_COPY_BLT_CMD;
  861. break;
  862. case 4:
  863. BR13 = (pitch * cpp) | (0xCC << 16) | (1<<24) | (1<<25);
  864. CMD = (XY_SRC_COPY_BLT_CMD | XY_SRC_COPY_BLT_WRITE_ALPHA |
  865.        XY_SRC_COPY_BLT_WRITE_RGB);
  866. break;
  867. default:
  868. BR13 = (pitch * cpp) | (0xCC << 16) | (1<<24);
  869. CMD = XY_SRC_COPY_BLT_CMD;
  870. break;
  871. }
  873.    i830_kernel_lost_context(dev);
  875.        if (nbox > I830_NR_SAREA_CLIPRECTS)
  876.       nbox = I830_NR_SAREA_CLIPRECTS;
  878. for (i = 0 ; i < nbox; i++, pbox++) 
  879. {
  880. if (pbox->x1 > pbox->x2 ||
  881.     pbox->y1 > pbox->y2 ||
  882.     pbox->x2 > dev_priv->w ||
  883.     pbox->y2 > dev_priv->h)
  884. continue;
  885.  
  886. DRM_DEBUG("dispatch swap %d,%d-%d,%d!n",
  887.   pbox->x1, pbox->y1,
  888.   pbox->x2, pbox->y2);
  890. BEGIN_LP_RING( 8 );
  891. OUT_RING( CMD );
  892. OUT_RING( BR13 );
  894. OUT_RING( (pbox->y1 << 16) |
  895.   pbox->x1 );
  896. OUT_RING( (pbox->y2 << 16) |
  897.   pbox->x2 );
  899. OUT_RING( 0 /* front ofs always zero */ );
  900. OUT_RING( (pbox->y1 << 16) |
  901.   pbox->x1 );
  903. OUT_RING( BR13 & 0xffff );
  904. OUT_RING( ofs );
  906. ADVANCE_LP_RING();
  907. }
  908. }
  911. static void i830_dma_dispatch_vertex(drm_device_t *dev, 
  912.      drm_buf_t *buf,
  913.      int discard,
  914.      int used)
  915. {
  916.     drm_i830_private_t *dev_priv = dev->dev_private;
  917. drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  918.     drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv;
  919.     drm_clip_rect_t *box = sarea_priv->boxes;
  920.     int nbox = sarea_priv->nbox;
  921. unsigned long address = (unsigned long)buf->bus_address;
  922. unsigned long start = address - dev->agp->base;     
  923. int i = 0, u;
  924.     RING_LOCALS;
  926.     i830_kernel_lost_context(dev);
  928.     if (nbox > I830_NR_SAREA_CLIPRECTS) 
  929. nbox = I830_NR_SAREA_CLIPRECTS;
  931. if (discard) {
  932. u = cmpxchg(buf_priv->in_use, I830_BUF_CLIENT, 
  933.     I830_BUF_HARDWARE);
  934. if(u != I830_BUF_CLIENT) {
  935. DRM_DEBUG("xxxx 2n");
  936. }
  937. }
  939. if (used > 4*1024) 
  940. used = 0;
  942. if (sarea_priv->dirty)
  943.    i830EmitState( dev );
  945.    DRM_DEBUG("dispatch vertex addr 0x%lx, used 0x%x nbox %dn", 
  946.   address, used, nbox);
  948.     dev_priv->counter++;
  949.     DRM_DEBUG(  "dispatch counter : %ldn", dev_priv->counter);
  950.     DRM_DEBUG(  "i830_dma_dispatchn");
  951.     DRM_DEBUG(  "start : %lxn", start);
  952. DRM_DEBUG(  "used : %dn", used);
  953.     DRM_DEBUG(  "start + used - 4 : %ldn", start + used - 4);
  955. if (buf_priv->currently_mapped == I830_BUF_MAPPED) {
  956. *(u32 *)buf_priv->virtual = (GFX_OP_PRIMITIVE |
  957.      sarea_priv->vertex_prim |
  958.      ((used/4)-2));
  960. if (used & 4) {
  961. *(u32 *)((u32)buf_priv->virtual + used) = 0;
  962. used += 4;
  963. }
  965. i830_unmap_buffer(buf);
  966. }
  967.    
  968. if (used) {
  969. do {
  970. if (i < nbox) {
  971. BEGIN_LP_RING(6);
  972. OUT_RING( GFX_OP_DRAWRECT_INFO );
  973. OUT_RING( sarea_priv->BufferState[I830_DESTREG_DR1] );
  974. OUT_RING( box[i].x1 | (box[i].y1<<16) );
  975. OUT_RING( box[i].x2 | (box[i].y2<<16) );
  976. OUT_RING( sarea_priv->BufferState[I830_DESTREG_DR4] );
  977. OUT_RING( 0 );
  978. ADVANCE_LP_RING();
  979. }
  981. BEGIN_LP_RING(4);
  983. OUT_RING( MI_BATCH_BUFFER );
  984. OUT_RING( start | MI_BATCH_NON_SECURE );
  985. OUT_RING( start + used - 4 );
  986. OUT_RING( 0 );
  987. ADVANCE_LP_RING();
  989. } while (++i < nbox);
  990. }
  992. BEGIN_LP_RING(10);
  993. OUT_RING( CMD_STORE_DWORD_IDX );
  994. OUT_RING( 20 );
  995. OUT_RING( dev_priv->counter );
  996. OUT_RING( 0 );
  998. if (discard) {
  999. OUT_RING( CMD_STORE_DWORD_IDX );
  1000. OUT_RING( buf_priv->my_use_idx );
  1001. OUT_RING( I830_BUF_FREE );
  1002. OUT_RING( 0 );
  1003. }
  1005.        OUT_RING( CMD_REPORT_HEAD );
  1006. OUT_RING( 0 );
  1007.     ADVANCE_LP_RING();
  1008. }
  1010. /* Interrupts are only for flushing */
  1011. void i830_dma_service(int irq, void *device, struct pt_regs *regs)
  1012. {
  1013. drm_device_t  *dev = (drm_device_t *)device;
  1014.        drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1015.     u16 temp;
  1016.    
  1017.        temp = I830_READ16(I830REG_INT_IDENTITY_R);
  1018.     temp = temp & ~(0x6000);
  1019.     if(temp != 0) I830_WRITE16(I830REG_INT_IDENTITY_R, 
  1020.    temp); /* Clear all interrupts */
  1021. else
  1022.    return;
  1023.  
  1024.     queue_task(&dev->tq, &tq_immediate);
  1025.     mark_bh(IMMEDIATE_BH);
  1026. }
  1028. void DRM(dma_immediate_bh)(void *device)
  1029. {
  1030. drm_device_t *dev = (drm_device_t *) device;
  1031.        drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1033.     atomic_set(&dev_priv->flush_done, 1);
  1034.     wake_up_interruptible(&dev_priv->flush_queue);
  1035. }
  1037. static inline void i830_dma_emit_flush(drm_device_t *dev)
  1038. {
  1039.     drm_i830_private_t *dev_priv = dev->dev_private;
  1040.     RING_LOCALS;
  1042.     i830_kernel_lost_context(dev);
  1044.     BEGIN_LP_RING(2);
  1045.        OUT_RING( CMD_REPORT_HEAD );
  1046.        OUT_RING( GFX_OP_USER_INTERRUPT );
  1047.        ADVANCE_LP_RING();
  1049. i830_wait_ring( dev, dev_priv->ring.Size - 8 );
  1050. atomic_set(&dev_priv->flush_done, 1);
  1051. wake_up_interruptible(&dev_priv->flush_queue);
  1052. }
  1054. static inline void i830_dma_quiescent_emit(drm_device_t *dev)
  1055. {
  1056.        drm_i830_private_t *dev_priv = dev->dev_private;
  1057.     RING_LOCALS;
  1059.    i830_kernel_lost_context(dev);
  1061.     BEGIN_LP_RING(4);
  1062.     OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE );
  1063.     OUT_RING( CMD_REPORT_HEAD );
  1064.        OUT_RING( 0 );
  1065.        OUT_RING( GFX_OP_USER_INTERRUPT );
  1066.     ADVANCE_LP_RING();
  1068. i830_wait_ring( dev, dev_priv->ring.Size - 8 );
  1069. atomic_set(&dev_priv->flush_done, 1);
  1070. wake_up_interruptible(&dev_priv->flush_queue);
  1071. }
  1073. void i830_dma_quiescent(drm_device_t *dev)
  1074. {
  1075.        DECLARE_WAITQUEUE(entry, current);
  1076.    drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1077. unsigned long end;      
  1079.     if(dev_priv == NULL) {
  1080.     return;
  1081. }
  1082.        atomic_set(&dev_priv->flush_done, 0);
  1083.     add_wait_queue(&dev_priv->flush_queue, &entry);
  1084.     end = jiffies + (HZ*3);
  1085.    
  1086.     for (;;) {
  1087. current->state = TASK_INTERRUPTIBLE;
  1088.        i830_dma_quiescent_emit(dev);
  1089.     if (atomic_read(&dev_priv->flush_done) == 1) break;
  1090. if(time_before(end, jiffies)) {
  1091.     DRM_ERROR("lockupn");
  1092.     break;
  1093. }    
  1094.        schedule_timeout(HZ*3);
  1095.        if (signal_pending(current)) {
  1096.     break;
  1097. }
  1098. }
  1099.    
  1100.     current->state = TASK_RUNNING;
  1101.     remove_wait_queue(&dev_priv->flush_queue, &entry);
  1102.    
  1103.     return;
  1104. }
  1106. static int i830_flush_queue(drm_device_t *dev)
  1107. {
  1108.     DECLARE_WAITQUEUE(entry, current);
  1109.    drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1110. drm_device_dma_t *dma = dev->dma;
  1111. unsigned long end;
  1112.     int i, ret = 0;      
  1114.     if(dev_priv == NULL) {
  1115.     return 0;
  1116. }
  1117.        atomic_set(&dev_priv->flush_done, 0);
  1118.     add_wait_queue(&dev_priv->flush_queue, &entry);
  1119.     end = jiffies + (HZ*3);
  1120.     for (;;) {
  1121. current->state = TASK_INTERRUPTIBLE;
  1122.        i830_dma_emit_flush(dev);
  1123.     if (atomic_read(&dev_priv->flush_done) == 1) break;
  1124. if(time_before(end, jiffies)) {
  1125.     DRM_ERROR("lockupn");
  1126.     break;
  1127. }    
  1128.        schedule_timeout(HZ*3);
  1129.        if (signal_pending(current)) {
  1130.     ret = -EINTR; /* Can't restart */
  1131.     break;
  1132. }
  1133. }
  1134.    
  1135.     current->state = TASK_RUNNING;
  1136.     remove_wait_queue(&dev_priv->flush_queue, &entry);
  1139.     for (i = 0; i < dma->buf_count; i++) {
  1140.     drm_buf_t *buf = dma->buflist[ i ];
  1141.     drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  1142.    
  1143. int used = cmpxchg(buf_priv->in_use, I830_BUF_HARDWARE, 
  1144.    I830_BUF_FREE);
  1146. if (used == I830_BUF_HARDWARE)
  1147. DRM_DEBUG("reclaimed from HARDWAREn");
  1148. if (used == I830_BUF_CLIENT)
  1149. DRM_DEBUG("still on client HARDWAREn");
  1150. }
  1152.     return ret;
  1153. }
  1155. /* Must be called with the lock held */
  1156. void i830_reclaim_buffers(drm_device_t *dev, pid_t pid)
  1157. {
  1158. drm_device_dma_t *dma = dev->dma;
  1159. int  i;
  1161. if (!dma) return;
  1162.        if (!dev->dev_private) return;
  1163. if (!dma->buflist) return;
  1165.         i830_flush_queue(dev);
  1167. for (i = 0; i < dma->buf_count; i++) {
  1168.     drm_buf_t *buf = dma->buflist[ i ];
  1169.     drm_i830_buf_priv_t *buf_priv = buf->dev_private;
  1170.    
  1171. if (buf->pid == pid && buf_priv) {
  1172. int used = cmpxchg(buf_priv->in_use, I830_BUF_CLIENT, 
  1173.    I830_BUF_FREE);
  1175. if (used == I830_BUF_CLIENT)
  1176. DRM_DEBUG("reclaimed from clientn");
  1177.     if(buf_priv->currently_mapped == I830_BUF_MAPPED)
  1178.       buf_priv->currently_mapped = I830_BUF_UNMAPPED;
  1179. }
  1180. }
  1181. }
  1183. int i830_flush_ioctl(struct inode *inode, struct file *filp, 
  1184.      unsigned int cmd, unsigned long arg)
  1185. {
  1186.     drm_file_t   *priv   = filp->private_data;
  1187.     drm_device_t   *dev   = priv->dev;
  1188.    
  1189.     DRM_DEBUG("i830_flush_ioctln");
  1190.     if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1191. DRM_ERROR("i830_flush_ioctl called without lock heldn");
  1192. return -EINVAL;
  1193. }
  1195.     i830_flush_queue(dev);
  1196.     return 0;
  1197. }
  1199. int i830_dma_vertex(struct inode *inode, struct file *filp,
  1200.        unsigned int cmd, unsigned long arg)
  1201. {
  1202. drm_file_t *priv = filp->private_data;
  1203. drm_device_t *dev = priv->dev;
  1204. drm_device_dma_t *dma = dev->dma;
  1205.     drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1206.        u32 *hw_status = (u32 *)dev_priv->hw_status_page;
  1207.     drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *) 
  1208.       dev_priv->sarea_priv; 
  1209. drm_i830_vertex_t vertex;
  1211. if (copy_from_user(&vertex, (drm_i830_vertex_t *)arg, sizeof(vertex)))
  1212. return -EFAULT;
  1214.     if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1215. DRM_ERROR("i830_dma_vertex called without lock heldn");
  1216. return -EINVAL;
  1217. }
  1219. DRM_DEBUG("i830 dma vertex, idx %d used %d discard %dn",
  1220.   vertex.idx, vertex.used, vertex.discard);
  1222. if(vertex.idx < 0 || vertex.idx > dma->buf_count) return -EINVAL;
  1224. i830_dma_dispatch_vertex( dev, 
  1225.   dma->buflist[ vertex.idx ], 
  1226.   vertex.discard, vertex.used );
  1228. sarea_priv->last_enqueue = dev_priv->counter-1;
  1229.     sarea_priv->last_dispatch = (int) hw_status[5];
  1230.    
  1231. return 0;
  1232. }
  1234. int i830_clear_bufs(struct inode *inode, struct file *filp,
  1235.    unsigned int cmd, unsigned long arg)
  1236. {
  1237. drm_file_t *priv = filp->private_data;
  1238. drm_device_t *dev = priv->dev;
  1239. drm_i830_clear_t clear;
  1241.     if (copy_from_user(&clear, (drm_i830_clear_t *)arg, sizeof(clear)))
  1242. return -EFAULT;
  1243.    
  1244.     if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1245. DRM_ERROR("i830_clear_bufs called without lock heldn");
  1246. return -EINVAL;
  1247. }
  1249. /* GH: Someone's doing nasty things... */
  1250. if (!dev->dev_private) {
  1251. return -EINVAL;
  1252. }
  1254. i830_dma_dispatch_clear( dev, clear.flags, 
  1255.  clear.clear_color, 
  1256.  clear.clear_depth,
  1257.          clear.clear_depthmask);
  1258.     return 0;
  1259. }
  1261. int i830_swap_bufs(struct inode *inode, struct file *filp,
  1262.   unsigned int cmd, unsigned long arg)
  1263. {
  1264. drm_file_t *priv = filp->private_data;
  1265. drm_device_t *dev = priv->dev;
  1266.    
  1267. DRM_DEBUG("i830_swap_bufsn");
  1269.     if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1270. DRM_ERROR("i830_swap_buf called without lock heldn");
  1271. return -EINVAL;
  1272. }
  1274. i830_dma_dispatch_swap( dev );
  1275.     return 0;
  1276. }
  1278. int i830_getage(struct inode *inode, struct file *filp, unsigned int cmd,
  1279. unsigned long arg)
  1280. {
  1281.     drm_file_t   *priv     = filp->private_data;
  1282. drm_device_t   *dev     = priv->dev;
  1283.     drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1284.        u32 *hw_status = (u32 *)dev_priv->hw_status_page;
  1285.     drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *) 
  1286.       dev_priv->sarea_priv; 
  1288.        sarea_priv->last_dispatch = (int) hw_status[5];
  1289. return 0;
  1290. }
  1292. int i830_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
  1293. unsigned long arg)
  1294. {
  1295. drm_file_t   *priv     = filp->private_data;
  1296. drm_device_t   *dev     = priv->dev;
  1297. int   retcode   = 0;
  1298. drm_i830_dma_t   d;
  1299.     drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1300.     u32 *hw_status = (u32 *)dev_priv->hw_status_page;
  1301.     drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *) 
  1302.       dev_priv->sarea_priv; 
  1304. DRM_DEBUG("getbufn");
  1305.     if (copy_from_user(&d, (drm_i830_dma_t *)arg, sizeof(d)))
  1306. return -EFAULT;
  1307.    
  1308. if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1309. DRM_ERROR("i830_dma called without lock heldn");
  1310. return -EINVAL;
  1311. }
  1313. d.granted = 0;
  1315. retcode = i830_dma_get_buffer(dev, &d, filp);
  1317. DRM_DEBUG("i830_dma: %d returning %d, granted = %dn",
  1318.   current->pid, retcode, d.granted);
  1320. if (copy_to_user((drm_dma_t *)arg, &d, sizeof(d)))
  1321. return -EFAULT;
  1322.     sarea_priv->last_dispatch = (int) hw_status[5];
  1324. return retcode;
  1325. }
  1327. int i830_copybuf(struct inode *inode, struct file *filp, unsigned int cmd,
  1328. unsigned long arg)
  1329. {
  1330. drm_file_t   *priv     = filp->private_data;
  1331. drm_device_t   *dev     = priv->dev;
  1332. drm_i830_copy_t   d;
  1333.     drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
  1334.     u32 *hw_status = (u32 *)dev_priv->hw_status_page;
  1335.     drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *) 
  1336.       dev_priv->sarea_priv; 
  1337. drm_buf_t *buf;
  1338. drm_i830_buf_priv_t *buf_priv;
  1339. drm_device_dma_t *dma = dev->dma;
  1341. if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
  1342. DRM_ERROR("i830_dma called without lock heldn");
  1343. return -EINVAL;
  1344. }
  1345.    
  1346.     if (copy_from_user(&d, (drm_i830_copy_t *)arg, sizeof(d)))
  1347. return -EFAULT;
  1349. if(d.idx < 0 || d.idx > dma->buf_count) return -EINVAL;
  1350. buf = dma->buflist[ d.idx ];
  1351.     buf_priv = buf->dev_private;
  1352. if (buf_priv->currently_mapped != I830_BUF_MAPPED) return -EPERM;
  1354. if(d.used < 0 || d.used > buf->total) return -EINVAL;
  1356.     if (copy_from_user(buf_priv->virtual, d.address, d.used))
  1357. return -EFAULT;
  1359.     sarea_priv->last_dispatch = (int) hw_status[5];
  1361. return 0;
  1362. }
  1364. int i830_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
  1365. unsigned long arg)
  1366. {
  1367. if(VM_DONTCOPY == 0) return 1;
  1368. return 0;
  1369. }