1 /* i810_dma.c -- DMA support for the i810 -*- linux-c -*-
2 * Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
4 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
5 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
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:
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
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.
27 * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
28 * Jeff Hartmann <jhartmann@valinux.com>
29 * Keith Whitwell <keith@tungstengraphics.com>
33 #include <linux/interrupt.h> /* For task queue support */
34 #include <linux/delay.h>
35 #include <linux/pagemap.h>
42 #define I810_BUF_FREE 2
43 #define I810_BUF_CLIENT 1
44 #define I810_BUF_HARDWARE 0
46 #define I810_BUF_UNMAPPED 0
47 #define I810_BUF_MAPPED 1
49 static inline void i810_print_status_page(struct drm_device * dev)
51 struct drm_device_dma *dma = dev->dma;
52 drm_i810_private_t *dev_priv = dev->dev_private;
53 u32 *temp = dev_priv->hw_status_page;
56 DRM_DEBUG("hw_status: Interrupt Status : %x\n", temp[0]);
57 DRM_DEBUG("hw_status: LpRing Head ptr : %x\n", temp[1]);
58 DRM_DEBUG("hw_status: IRing Head ptr : %x\n", temp[2]);
59 DRM_DEBUG("hw_status: Reserved : %x\n", temp[3]);
60 DRM_DEBUG("hw_status: Last Render: %x\n", temp[4]);
61 DRM_DEBUG("hw_status: Driver Counter : %d\n", temp[5]);
62 for (i = 6; i < dma->buf_count + 6; i++) {
63 DRM_DEBUG("buffer status idx : %d used: %d\n", i - 6, temp[i]);
67 static struct drm_buf *i810_freelist_get(struct drm_device * dev)
69 struct drm_device_dma *dma = dev->dma;
73 /* Linear search might not be the best solution */
75 for (i = 0; i < dma->buf_count; i++) {
76 struct drm_buf *buf = dma->buflist[i];
77 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
78 /* In use is already a pointer */
79 used = cmpxchg(buf_priv->in_use, I810_BUF_FREE,
81 if (used == I810_BUF_FREE) {
88 /* This should only be called if the buffer is not sent to the hardware
89 * yet, the hardware updates in use for us once its on the ring buffer.
92 static int i810_freelist_put(struct drm_device * dev, struct drm_buf * buf)
94 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
97 /* In use is already a pointer */
98 used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_FREE);
99 if (used != I810_BUF_CLIENT) {
100 DRM_ERROR("Freeing buffer thats not in use : %d\n", buf->idx);
107 static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
109 struct drm_file *priv = filp->private_data;
110 struct drm_device *dev;
111 drm_i810_private_t *dev_priv;
113 drm_i810_buf_priv_t *buf_priv;
116 dev = priv->minor->dev;
117 dev_priv = dev->dev_private;
118 buf = dev_priv->mmap_buffer;
119 buf_priv = buf->dev_private;
121 vma->vm_flags |= (VM_IO | VM_DONTCOPY);
124 buf_priv->currently_mapped = I810_BUF_MAPPED;
127 if (io_remap_pfn_range(vma, vma->vm_start,
129 vma->vm_end - vma->vm_start, vma->vm_page_prot))
134 static const struct file_operations i810_buffer_fops = {
136 .release = drm_release,
138 .mmap = i810_mmap_buffers,
139 .fasync = drm_fasync,
142 static int i810_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
144 struct drm_device *dev = file_priv->minor->dev;
145 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
146 drm_i810_private_t *dev_priv = dev->dev_private;
147 const struct file_operations *old_fops;
150 if (buf_priv->currently_mapped == I810_BUF_MAPPED)
153 down_write(¤t->mm->mmap_sem);
154 old_fops = file_priv->filp->f_op;
155 file_priv->filp->f_op = &i810_buffer_fops;
156 dev_priv->mmap_buffer = buf;
157 buf_priv->virtual = (void *)do_mmap(file_priv->filp, 0, buf->total,
158 PROT_READ | PROT_WRITE,
159 MAP_SHARED, buf->bus_address);
160 dev_priv->mmap_buffer = NULL;
161 file_priv->filp->f_op = old_fops;
162 if (IS_ERR(buf_priv->virtual)) {
164 DRM_ERROR("mmap error\n");
165 retcode = PTR_ERR(buf_priv->virtual);
166 buf_priv->virtual = NULL;
168 up_write(¤t->mm->mmap_sem);
173 static int i810_unmap_buffer(struct drm_buf * buf)
175 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
178 if (buf_priv->currently_mapped != I810_BUF_MAPPED)
181 down_write(¤t->mm->mmap_sem);
182 retcode = do_munmap(current->mm,
183 (unsigned long)buf_priv->virtual,
184 (size_t) buf->total);
185 up_write(¤t->mm->mmap_sem);
187 buf_priv->currently_mapped = I810_BUF_UNMAPPED;
188 buf_priv->virtual = NULL;
193 static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
194 struct drm_file *file_priv)
197 drm_i810_buf_priv_t *buf_priv;
200 buf = i810_freelist_get(dev);
203 DRM_DEBUG("retcode=%d\n", retcode);
207 retcode = i810_map_buffer(buf, file_priv);
209 i810_freelist_put(dev, buf);
210 DRM_ERROR("mapbuf failed, retcode %d\n", retcode);
213 buf->file_priv = file_priv;
214 buf_priv = buf->dev_private;
216 d->request_idx = buf->idx;
217 d->request_size = buf->total;
218 d->virtual = buf_priv->virtual;
223 static int i810_dma_cleanup(struct drm_device * dev)
225 struct drm_device_dma *dma = dev->dma;
227 /* Make sure interrupts are disabled here because the uninstall ioctl
228 * may not have been called from userspace and after dev_private
229 * is freed, it's too late.
231 if (drm_core_check_feature(dev, DRIVER_HAVE_IRQ) && dev->irq_enabled)
232 drm_irq_uninstall(dev);
234 if (dev->dev_private) {
236 drm_i810_private_t *dev_priv =
237 (drm_i810_private_t *) dev->dev_private;
239 if (dev_priv->ring.virtual_start) {
240 drm_core_ioremapfree(&dev_priv->ring.map, dev);
242 if (dev_priv->hw_status_page) {
243 pci_free_consistent(dev->pdev, PAGE_SIZE,
244 dev_priv->hw_status_page,
245 dev_priv->dma_status_page);
246 /* Need to rewrite hardware status page */
247 I810_WRITE(0x02080, 0x1ffff000);
249 drm_free(dev->dev_private, sizeof(drm_i810_private_t),
251 dev->dev_private = NULL;
253 for (i = 0; i < dma->buf_count; i++) {
254 struct drm_buf *buf = dma->buflist[i];
255 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
257 if (buf_priv->kernel_virtual && buf->total)
258 drm_core_ioremapfree(&buf_priv->map, dev);
264 static int i810_wait_ring(struct drm_device * dev, int n)
266 drm_i810_private_t *dev_priv = dev->dev_private;
267 drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
270 unsigned int last_head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
272 end = jiffies + (HZ * 3);
273 while (ring->space < n) {
274 ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
275 ring->space = ring->head - (ring->tail + 8);
277 ring->space += ring->Size;
279 if (ring->head != last_head) {
280 end = jiffies + (HZ * 3);
281 last_head = ring->head;
285 if (time_before(end, jiffies)) {
286 DRM_ERROR("space: %d wanted %d\n", ring->space, n);
287 DRM_ERROR("lockup\n");
297 static void i810_kernel_lost_context(struct drm_device * dev)
299 drm_i810_private_t *dev_priv = dev->dev_private;
300 drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
302 ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
303 ring->tail = I810_READ(LP_RING + RING_TAIL);
304 ring->space = ring->head - (ring->tail + 8);
306 ring->space += ring->Size;
309 static int i810_freelist_init(struct drm_device * dev, drm_i810_private_t * dev_priv)
311 struct drm_device_dma *dma = dev->dma;
313 u32 *hw_status = (u32 *) (dev_priv->hw_status_page + my_idx);
316 if (dma->buf_count > 1019) {
317 /* Not enough space in the status page for the freelist */
321 for (i = 0; i < dma->buf_count; i++) {
322 struct drm_buf *buf = dma->buflist[i];
323 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
325 buf_priv->in_use = hw_status++;
326 buf_priv->my_use_idx = my_idx;
329 *buf_priv->in_use = I810_BUF_FREE;
331 buf_priv->map.offset = buf->bus_address;
332 buf_priv->map.size = buf->total;
333 buf_priv->map.type = _DRM_AGP;
334 buf_priv->map.flags = 0;
335 buf_priv->map.mtrr = 0;
337 drm_core_ioremap(&buf_priv->map, dev);
338 buf_priv->kernel_virtual = buf_priv->map.handle;
344 static int i810_dma_initialize(struct drm_device * dev,
345 drm_i810_private_t * dev_priv,
346 drm_i810_init_t * init)
348 struct drm_map_list *r_list;
349 memset(dev_priv, 0, sizeof(drm_i810_private_t));
351 list_for_each_entry(r_list, &dev->maplist, head) {
353 r_list->map->type == _DRM_SHM &&
354 r_list->map->flags & _DRM_CONTAINS_LOCK) {
355 dev_priv->sarea_map = r_list->map;
359 if (!dev_priv->sarea_map) {
360 dev->dev_private = (void *)dev_priv;
361 i810_dma_cleanup(dev);
362 DRM_ERROR("can not find sarea!\n");
365 dev_priv->mmio_map = drm_core_findmap(dev, init->mmio_offset);
366 if (!dev_priv->mmio_map) {
367 dev->dev_private = (void *)dev_priv;
368 i810_dma_cleanup(dev);
369 DRM_ERROR("can not find mmio map!\n");
372 dev->agp_buffer_token = init->buffers_offset;
373 dev->agp_buffer_map = drm_core_findmap(dev, init->buffers_offset);
374 if (!dev->agp_buffer_map) {
375 dev->dev_private = (void *)dev_priv;
376 i810_dma_cleanup(dev);
377 DRM_ERROR("can not find dma buffer map!\n");
381 dev_priv->sarea_priv = (drm_i810_sarea_t *)
382 ((u8 *) dev_priv->sarea_map->handle + init->sarea_priv_offset);
384 dev_priv->ring.Start = init->ring_start;
385 dev_priv->ring.End = init->ring_end;
386 dev_priv->ring.Size = init->ring_size;
388 dev_priv->ring.map.offset = dev->agp->base + init->ring_start;
389 dev_priv->ring.map.size = init->ring_size;
390 dev_priv->ring.map.type = _DRM_AGP;
391 dev_priv->ring.map.flags = 0;
392 dev_priv->ring.map.mtrr = 0;
394 drm_core_ioremap(&dev_priv->ring.map, dev);
396 if (dev_priv->ring.map.handle == NULL) {
397 dev->dev_private = (void *)dev_priv;
398 i810_dma_cleanup(dev);
399 DRM_ERROR("can not ioremap virtual address for"
404 dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
406 dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
408 dev_priv->w = init->w;
409 dev_priv->h = init->h;
410 dev_priv->pitch = init->pitch;
411 dev_priv->back_offset = init->back_offset;
412 dev_priv->depth_offset = init->depth_offset;
413 dev_priv->front_offset = init->front_offset;
415 dev_priv->overlay_offset = init->overlay_offset;
416 dev_priv->overlay_physical = init->overlay_physical;
418 dev_priv->front_di1 = init->front_offset | init->pitch_bits;
419 dev_priv->back_di1 = init->back_offset | init->pitch_bits;
420 dev_priv->zi1 = init->depth_offset | init->pitch_bits;
422 /* Program Hardware Status Page */
423 dev_priv->hw_status_page =
424 pci_alloc_consistent(dev->pdev, PAGE_SIZE,
425 &dev_priv->dma_status_page);
426 if (!dev_priv->hw_status_page) {
427 dev->dev_private = (void *)dev_priv;
428 i810_dma_cleanup(dev);
429 DRM_ERROR("Can not allocate hardware status page\n");
432 memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
433 DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);
435 I810_WRITE(0x02080, dev_priv->dma_status_page);
436 DRM_DEBUG("Enabled hardware status page\n");
438 /* Now we need to init our freelist */
439 if (i810_freelist_init(dev, dev_priv) != 0) {
440 dev->dev_private = (void *)dev_priv;
441 i810_dma_cleanup(dev);
442 DRM_ERROR("Not enough space in the status page for"
446 dev->dev_private = (void *)dev_priv;
451 static int i810_dma_init(struct drm_device *dev, void *data,
452 struct drm_file *file_priv)
454 drm_i810_private_t *dev_priv;
455 drm_i810_init_t *init = data;
458 switch (init->func) {
459 case I810_INIT_DMA_1_4:
460 DRM_INFO("Using v1.4 init.\n");
461 dev_priv = drm_alloc(sizeof(drm_i810_private_t),
463 if (dev_priv == NULL)
465 retcode = i810_dma_initialize(dev, dev_priv, init);
468 case I810_CLEANUP_DMA:
469 DRM_INFO("DMA Cleanup\n");
470 retcode = i810_dma_cleanup(dev);
479 /* Most efficient way to verify state for the i810 is as it is
480 * emitted. Non-conformant state is silently dropped.
482 * Use 'volatile' & local var tmp to force the emitted values to be
483 * identical to the verified ones.
485 static void i810EmitContextVerified(struct drm_device * dev,
486 volatile unsigned int *code)
488 drm_i810_private_t *dev_priv = dev->dev_private;
493 BEGIN_LP_RING(I810_CTX_SETUP_SIZE);
495 OUT_RING(GFX_OP_COLOR_FACTOR);
496 OUT_RING(code[I810_CTXREG_CF1]);
498 OUT_RING(GFX_OP_STIPPLE);
499 OUT_RING(code[I810_CTXREG_ST1]);
501 for (i = 4; i < I810_CTX_SETUP_SIZE; i++) {
504 if ((tmp & (7 << 29)) == (3 << 29) &&
505 (tmp & (0x1f << 24)) < (0x1d << 24)) {
509 printk("constext state dropped!!!\n");
518 static void i810EmitTexVerified(struct drm_device * dev, volatile unsigned int *code)
520 drm_i810_private_t *dev_priv = dev->dev_private;
525 BEGIN_LP_RING(I810_TEX_SETUP_SIZE);
527 OUT_RING(GFX_OP_MAP_INFO);
528 OUT_RING(code[I810_TEXREG_MI1]);
529 OUT_RING(code[I810_TEXREG_MI2]);
530 OUT_RING(code[I810_TEXREG_MI3]);
532 for (i = 4; i < I810_TEX_SETUP_SIZE; i++) {
535 if ((tmp & (7 << 29)) == (3 << 29) &&
536 (tmp & (0x1f << 24)) < (0x1d << 24)) {
540 printk("texture state dropped!!!\n");
549 /* Need to do some additional checking when setting the dest buffer.
551 static void i810EmitDestVerified(struct drm_device * dev,
552 volatile unsigned int *code)
554 drm_i810_private_t *dev_priv = dev->dev_private;
558 BEGIN_LP_RING(I810_DEST_SETUP_SIZE + 2);
560 tmp = code[I810_DESTREG_DI1];
561 if (tmp == dev_priv->front_di1 || tmp == dev_priv->back_di1) {
562 OUT_RING(CMD_OP_DESTBUFFER_INFO);
565 DRM_DEBUG("bad di1 %x (allow %x or %x)\n",
566 tmp, dev_priv->front_di1, dev_priv->back_di1);
570 OUT_RING(CMD_OP_Z_BUFFER_INFO);
571 OUT_RING(dev_priv->zi1);
573 OUT_RING(GFX_OP_DESTBUFFER_VARS);
574 OUT_RING(code[I810_DESTREG_DV1]);
576 OUT_RING(GFX_OP_DRAWRECT_INFO);
577 OUT_RING(code[I810_DESTREG_DR1]);
578 OUT_RING(code[I810_DESTREG_DR2]);
579 OUT_RING(code[I810_DESTREG_DR3]);
580 OUT_RING(code[I810_DESTREG_DR4]);
586 static void i810EmitState(struct drm_device * dev)
588 drm_i810_private_t *dev_priv = dev->dev_private;
589 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
590 unsigned int dirty = sarea_priv->dirty;
592 DRM_DEBUG("%x\n", dirty);
594 if (dirty & I810_UPLOAD_BUFFERS) {
595 i810EmitDestVerified(dev, sarea_priv->BufferState);
596 sarea_priv->dirty &= ~I810_UPLOAD_BUFFERS;
599 if (dirty & I810_UPLOAD_CTX) {
600 i810EmitContextVerified(dev, sarea_priv->ContextState);
601 sarea_priv->dirty &= ~I810_UPLOAD_CTX;
604 if (dirty & I810_UPLOAD_TEX0) {
605 i810EmitTexVerified(dev, sarea_priv->TexState[0]);
606 sarea_priv->dirty &= ~I810_UPLOAD_TEX0;
609 if (dirty & I810_UPLOAD_TEX1) {
610 i810EmitTexVerified(dev, sarea_priv->TexState[1]);
611 sarea_priv->dirty &= ~I810_UPLOAD_TEX1;
617 static void i810_dma_dispatch_clear(struct drm_device * dev, int flags,
618 unsigned int clear_color,
619 unsigned int clear_zval)
621 drm_i810_private_t *dev_priv = dev->dev_private;
622 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
623 int nbox = sarea_priv->nbox;
624 struct drm_clip_rect *pbox = sarea_priv->boxes;
625 int pitch = dev_priv->pitch;
630 if (dev_priv->current_page == 1) {
631 unsigned int tmp = flags;
633 flags &= ~(I810_FRONT | I810_BACK);
634 if (tmp & I810_FRONT)
640 i810_kernel_lost_context(dev);
642 if (nbox > I810_NR_SAREA_CLIPRECTS)
643 nbox = I810_NR_SAREA_CLIPRECTS;
645 for (i = 0; i < nbox; i++, pbox++) {
646 unsigned int x = pbox->x1;
647 unsigned int y = pbox->y1;
648 unsigned int width = (pbox->x2 - x) * cpp;
649 unsigned int height = pbox->y2 - y;
650 unsigned int start = y * pitch + x * cpp;
652 if (pbox->x1 > pbox->x2 ||
653 pbox->y1 > pbox->y2 ||
654 pbox->x2 > dev_priv->w || pbox->y2 > dev_priv->h)
657 if (flags & I810_FRONT) {
659 OUT_RING(BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3);
660 OUT_RING(BR13_SOLID_PATTERN | (0xF0 << 16) | pitch);
661 OUT_RING((height << 16) | width);
663 OUT_RING(clear_color);
668 if (flags & I810_BACK) {
670 OUT_RING(BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3);
671 OUT_RING(BR13_SOLID_PATTERN | (0xF0 << 16) | pitch);
672 OUT_RING((height << 16) | width);
673 OUT_RING(dev_priv->back_offset + start);
674 OUT_RING(clear_color);
679 if (flags & I810_DEPTH) {
681 OUT_RING(BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3);
682 OUT_RING(BR13_SOLID_PATTERN | (0xF0 << 16) | pitch);
683 OUT_RING((height << 16) | width);
684 OUT_RING(dev_priv->depth_offset + start);
685 OUT_RING(clear_zval);
692 static void i810_dma_dispatch_swap(struct drm_device * dev)
694 drm_i810_private_t *dev_priv = dev->dev_private;
695 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
696 int nbox = sarea_priv->nbox;
697 struct drm_clip_rect *pbox = sarea_priv->boxes;
698 int pitch = dev_priv->pitch;
703 DRM_DEBUG("swapbuffers\n");
705 i810_kernel_lost_context(dev);
707 if (nbox > I810_NR_SAREA_CLIPRECTS)
708 nbox = I810_NR_SAREA_CLIPRECTS;
710 for (i = 0; i < nbox; i++, pbox++) {
711 unsigned int w = pbox->x2 - pbox->x1;
712 unsigned int h = pbox->y2 - pbox->y1;
713 unsigned int dst = pbox->x1 * cpp + pbox->y1 * pitch;
714 unsigned int start = dst;
716 if (pbox->x1 > pbox->x2 ||
717 pbox->y1 > pbox->y2 ||
718 pbox->x2 > dev_priv->w || pbox->y2 > dev_priv->h)
722 OUT_RING(BR00_BITBLT_CLIENT | BR00_OP_SRC_COPY_BLT | 0x4);
723 OUT_RING(pitch | (0xCC << 16));
724 OUT_RING((h << 16) | (w * cpp));
725 if (dev_priv->current_page == 0)
726 OUT_RING(dev_priv->front_offset + start);
728 OUT_RING(dev_priv->back_offset + start);
730 if (dev_priv->current_page == 0)
731 OUT_RING(dev_priv->back_offset + start);
733 OUT_RING(dev_priv->front_offset + start);
738 static void i810_dma_dispatch_vertex(struct drm_device * dev,
739 struct drm_buf * buf, int discard, int used)
741 drm_i810_private_t *dev_priv = dev->dev_private;
742 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
743 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
744 struct drm_clip_rect *box = sarea_priv->boxes;
745 int nbox = sarea_priv->nbox;
746 unsigned long address = (unsigned long)buf->bus_address;
747 unsigned long start = address - dev->agp->base;
751 i810_kernel_lost_context(dev);
753 if (nbox > I810_NR_SAREA_CLIPRECTS)
754 nbox = I810_NR_SAREA_CLIPRECTS;
759 if (sarea_priv->dirty)
762 if (buf_priv->currently_mapped == I810_BUF_MAPPED) {
763 unsigned int prim = (sarea_priv->vertex_prim & PR_MASK);
765 *(u32 *) buf_priv->kernel_virtual =
766 ((GFX_OP_PRIMITIVE | prim | ((used / 4) - 2)));
769 *(u32 *) ((char *) buf_priv->kernel_virtual + used) = 0;
773 i810_unmap_buffer(buf);
780 OUT_RING(GFX_OP_SCISSOR | SC_UPDATE_SCISSOR |
782 OUT_RING(GFX_OP_SCISSOR_INFO);
783 OUT_RING(box[i].x1 | (box[i].y1 << 16));
784 OUT_RING((box[i].x2 -
785 1) | ((box[i].y2 - 1) << 16));
790 OUT_RING(CMD_OP_BATCH_BUFFER);
791 OUT_RING(start | BB1_PROTECTED);
792 OUT_RING(start + used - 4);
796 } while (++i < nbox);
802 (void)cmpxchg(buf_priv->in_use, I810_BUF_CLIENT,
806 OUT_RING(CMD_STORE_DWORD_IDX);
808 OUT_RING(dev_priv->counter);
809 OUT_RING(CMD_STORE_DWORD_IDX);
810 OUT_RING(buf_priv->my_use_idx);
811 OUT_RING(I810_BUF_FREE);
812 OUT_RING(CMD_REPORT_HEAD);
818 static void i810_dma_dispatch_flip(struct drm_device * dev)
820 drm_i810_private_t *dev_priv = dev->dev_private;
821 int pitch = dev_priv->pitch;
824 DRM_DEBUG("page=%d pfCurrentPage=%d\n",
825 dev_priv->current_page,
826 dev_priv->sarea_priv->pf_current_page);
828 i810_kernel_lost_context(dev);
831 OUT_RING(INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE);
835 BEGIN_LP_RING(I810_DEST_SETUP_SIZE + 2);
836 /* On i815 at least ASYNC is buggy */
837 /* pitch<<5 is from 11.2.8 p158,
838 its the pitch / 8 then left shifted 8,
839 so (pitch >> 3) << 8 */
840 OUT_RING(CMD_OP_FRONTBUFFER_INFO | (pitch << 5) /*| ASYNC_FLIP */ );
841 if (dev_priv->current_page == 0) {
842 OUT_RING(dev_priv->back_offset);
843 dev_priv->current_page = 1;
845 OUT_RING(dev_priv->front_offset);
846 dev_priv->current_page = 0;
852 OUT_RING(CMD_OP_WAIT_FOR_EVENT | WAIT_FOR_PLANE_A_FLIP);
856 /* Increment the frame counter. The client-side 3D driver must
857 * throttle the framerate by waiting for this value before
858 * performing the swapbuffer ioctl.
860 dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
864 static void i810_dma_quiescent(struct drm_device * dev)
866 drm_i810_private_t *dev_priv = dev->dev_private;
869 i810_kernel_lost_context(dev);
872 OUT_RING(INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE);
873 OUT_RING(CMD_REPORT_HEAD);
878 i810_wait_ring(dev, dev_priv->ring.Size - 8);
881 static int i810_flush_queue(struct drm_device * dev)
883 drm_i810_private_t *dev_priv = dev->dev_private;
884 struct drm_device_dma *dma = dev->dma;
888 i810_kernel_lost_context(dev);
891 OUT_RING(CMD_REPORT_HEAD);
895 i810_wait_ring(dev, dev_priv->ring.Size - 8);
897 for (i = 0; i < dma->buf_count; i++) {
898 struct drm_buf *buf = dma->buflist[i];
899 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
901 int used = cmpxchg(buf_priv->in_use, I810_BUF_HARDWARE,
904 if (used == I810_BUF_HARDWARE)
905 DRM_DEBUG("reclaimed from HARDWARE\n");
906 if (used == I810_BUF_CLIENT)
907 DRM_DEBUG("still on client\n");
913 /* Must be called with the lock held */
914 static void i810_reclaim_buffers(struct drm_device *dev,
915 struct drm_file *file_priv)
917 struct drm_device_dma *dma = dev->dma;
922 if (!dev->dev_private)
927 i810_flush_queue(dev);
929 for (i = 0; i < dma->buf_count; i++) {
930 struct drm_buf *buf = dma->buflist[i];
931 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
933 if (buf->file_priv == file_priv && buf_priv) {
934 int used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT,
937 if (used == I810_BUF_CLIENT)
938 DRM_DEBUG("reclaimed from client\n");
939 if (buf_priv->currently_mapped == I810_BUF_MAPPED)
940 buf_priv->currently_mapped = I810_BUF_UNMAPPED;
945 static int i810_flush_ioctl(struct drm_device *dev, void *data,
946 struct drm_file *file_priv)
948 LOCK_TEST_WITH_RETURN(dev, file_priv);
950 i810_flush_queue(dev);
954 static int i810_dma_vertex(struct drm_device *dev, void *data,
955 struct drm_file *file_priv)
957 struct drm_device_dma *dma = dev->dma;
958 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
959 u32 *hw_status = dev_priv->hw_status_page;
960 drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
961 dev_priv->sarea_priv;
962 drm_i810_vertex_t *vertex = data;
964 LOCK_TEST_WITH_RETURN(dev, file_priv);
966 DRM_DEBUG("idx %d used %d discard %d\n",
967 vertex->idx, vertex->used, vertex->discard);
969 if (vertex->idx < 0 || vertex->idx > dma->buf_count)
972 i810_dma_dispatch_vertex(dev,
973 dma->buflist[vertex->idx],
974 vertex->discard, vertex->used);
976 atomic_add(vertex->used, &dev->counts[_DRM_STAT_SECONDARY]);
977 atomic_inc(&dev->counts[_DRM_STAT_DMA]);
978 sarea_priv->last_enqueue = dev_priv->counter - 1;
979 sarea_priv->last_dispatch = (int)hw_status[5];
984 static int i810_clear_bufs(struct drm_device *dev, void *data,
985 struct drm_file *file_priv)
987 drm_i810_clear_t *clear = data;
989 LOCK_TEST_WITH_RETURN(dev, file_priv);
991 /* GH: Someone's doing nasty things... */
992 if (!dev->dev_private) {
996 i810_dma_dispatch_clear(dev, clear->flags,
997 clear->clear_color, clear->clear_depth);
1001 static int i810_swap_bufs(struct drm_device *dev, void *data,
1002 struct drm_file *file_priv)
1006 LOCK_TEST_WITH_RETURN(dev, file_priv);
1008 i810_dma_dispatch_swap(dev);
1012 static int i810_getage(struct drm_device *dev, void *data,
1013 struct drm_file *file_priv)
1015 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1016 u32 *hw_status = dev_priv->hw_status_page;
1017 drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1018 dev_priv->sarea_priv;
1020 sarea_priv->last_dispatch = (int)hw_status[5];
1024 static int i810_getbuf(struct drm_device *dev, void *data,
1025 struct drm_file *file_priv)
1028 drm_i810_dma_t *d = data;
1029 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1030 u32 *hw_status = dev_priv->hw_status_page;
1031 drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1032 dev_priv->sarea_priv;
1034 LOCK_TEST_WITH_RETURN(dev, file_priv);
1038 retcode = i810_dma_get_buffer(dev, d, file_priv);
1040 DRM_DEBUG("i810_dma: %d returning %d, granted = %d\n",
1041 current->pid, retcode, d->granted);
1043 sarea_priv->last_dispatch = (int)hw_status[5];
1048 static int i810_copybuf(struct drm_device *dev, void *data,
1049 struct drm_file *file_priv)
1051 /* Never copy - 2.4.x doesn't need it */
1055 static int i810_docopy(struct drm_device *dev, void *data,
1056 struct drm_file *file_priv)
1058 /* Never copy - 2.4.x doesn't need it */
1062 static void i810_dma_dispatch_mc(struct drm_device * dev, struct drm_buf * buf, int used,
1063 unsigned int last_render)
1065 drm_i810_private_t *dev_priv = dev->dev_private;
1066 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
1067 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
1068 unsigned long address = (unsigned long)buf->bus_address;
1069 unsigned long start = address - dev->agp->base;
1073 i810_kernel_lost_context(dev);
1075 u = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_HARDWARE);
1076 if (u != I810_BUF_CLIENT) {
1077 DRM_DEBUG("MC found buffer that isn't mine!\n");
1080 if (used > 4 * 1024)
1083 sarea_priv->dirty = 0x7f;
1085 DRM_DEBUG("addr 0x%lx, used 0x%x\n", address, used);
1087 dev_priv->counter++;
1088 DRM_DEBUG("dispatch counter : %ld\n", dev_priv->counter);
1089 DRM_DEBUG("start : %lx\n", start);
1090 DRM_DEBUG("used : %d\n", used);
1091 DRM_DEBUG("start + used - 4 : %ld\n", start + used - 4);
1093 if (buf_priv->currently_mapped == I810_BUF_MAPPED) {
1095 *(u32 *) ((char *) buf_priv->virtual + used) = 0;
1099 i810_unmap_buffer(buf);
1102 OUT_RING(CMD_OP_BATCH_BUFFER);
1103 OUT_RING(start | BB1_PROTECTED);
1104 OUT_RING(start + used - 4);
1109 OUT_RING(CMD_STORE_DWORD_IDX);
1110 OUT_RING(buf_priv->my_use_idx);
1111 OUT_RING(I810_BUF_FREE);
1114 OUT_RING(CMD_STORE_DWORD_IDX);
1116 OUT_RING(last_render);
1121 static int i810_dma_mc(struct drm_device *dev, void *data,
1122 struct drm_file *file_priv)
1124 struct drm_device_dma *dma = dev->dma;
1125 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1126 u32 *hw_status = dev_priv->hw_status_page;
1127 drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1128 dev_priv->sarea_priv;
1129 drm_i810_mc_t *mc = data;
1131 LOCK_TEST_WITH_RETURN(dev, file_priv);
1133 if (mc->idx >= dma->buf_count || mc->idx < 0)
1136 i810_dma_dispatch_mc(dev, dma->buflist[mc->idx], mc->used,
1139 atomic_add(mc->used, &dev->counts[_DRM_STAT_SECONDARY]);
1140 atomic_inc(&dev->counts[_DRM_STAT_DMA]);
1141 sarea_priv->last_enqueue = dev_priv->counter - 1;
1142 sarea_priv->last_dispatch = (int)hw_status[5];
1147 static int i810_rstatus(struct drm_device *dev, void *data,
1148 struct drm_file *file_priv)
1150 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1152 return (int)(((u32 *) (dev_priv->hw_status_page))[4]);
1155 static int i810_ov0_info(struct drm_device *dev, void *data,
1156 struct drm_file *file_priv)
1158 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1159 drm_i810_overlay_t *ov = data;
1161 ov->offset = dev_priv->overlay_offset;
1162 ov->physical = dev_priv->overlay_physical;
1167 static int i810_fstatus(struct drm_device *dev, void *data,
1168 struct drm_file *file_priv)
1170 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1172 LOCK_TEST_WITH_RETURN(dev, file_priv);
1173 return I810_READ(0x30008);
1176 static int i810_ov0_flip(struct drm_device *dev, void *data,
1177 struct drm_file *file_priv)
1179 drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
1181 LOCK_TEST_WITH_RETURN(dev, file_priv);
1182 //Tell the overlay to update
1183 I810_WRITE(0x30000, dev_priv->overlay_physical | 0x80000000);
1188 /* Not sure why this isn't set all the time:
1190 static void i810_do_init_pageflip(struct drm_device * dev)
1192 drm_i810_private_t *dev_priv = dev->dev_private;
1195 dev_priv->page_flipping = 1;
1196 dev_priv->current_page = 0;
1197 dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
1200 static int i810_do_cleanup_pageflip(struct drm_device * dev)
1202 drm_i810_private_t *dev_priv = dev->dev_private;
1205 if (dev_priv->current_page != 0)
1206 i810_dma_dispatch_flip(dev);
1208 dev_priv->page_flipping = 0;
1212 static int i810_flip_bufs(struct drm_device *dev, void *data,
1213 struct drm_file *file_priv)
1215 drm_i810_private_t *dev_priv = dev->dev_private;
1219 LOCK_TEST_WITH_RETURN(dev, file_priv);
1221 if (!dev_priv->page_flipping)
1222 i810_do_init_pageflip(dev);
1224 i810_dma_dispatch_flip(dev);
1228 int i810_driver_load(struct drm_device *dev, unsigned long flags)
1230 /* i810 has 4 more counters */
1232 dev->types[6] = _DRM_STAT_IRQ;
1233 dev->types[7] = _DRM_STAT_PRIMARY;
1234 dev->types[8] = _DRM_STAT_SECONDARY;
1235 dev->types[9] = _DRM_STAT_DMA;
1240 void i810_driver_lastclose(struct drm_device * dev)
1242 i810_dma_cleanup(dev);
1245 void i810_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
1247 if (dev->dev_private) {
1248 drm_i810_private_t *dev_priv = dev->dev_private;
1249 if (dev_priv->page_flipping) {
1250 i810_do_cleanup_pageflip(dev);
1255 void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
1256 struct drm_file *file_priv)
1258 i810_reclaim_buffers(dev, file_priv);
1261 int i810_driver_dma_quiescent(struct drm_device * dev)
1263 i810_dma_quiescent(dev);
1267 struct drm_ioctl_desc i810_ioctls[] = {
1268 DRM_IOCTL_DEF(DRM_I810_INIT, i810_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
1269 DRM_IOCTL_DEF(DRM_I810_VERTEX, i810_dma_vertex, DRM_AUTH),
1270 DRM_IOCTL_DEF(DRM_I810_CLEAR, i810_clear_bufs, DRM_AUTH),
1271 DRM_IOCTL_DEF(DRM_I810_FLUSH, i810_flush_ioctl, DRM_AUTH),
1272 DRM_IOCTL_DEF(DRM_I810_GETAGE, i810_getage, DRM_AUTH),
1273 DRM_IOCTL_DEF(DRM_I810_GETBUF, i810_getbuf, DRM_AUTH),
1274 DRM_IOCTL_DEF(DRM_I810_SWAP, i810_swap_bufs, DRM_AUTH),
1275 DRM_IOCTL_DEF(DRM_I810_COPY, i810_copybuf, DRM_AUTH),
1276 DRM_IOCTL_DEF(DRM_I810_DOCOPY, i810_docopy, DRM_AUTH),
1277 DRM_IOCTL_DEF(DRM_I810_OV0INFO, i810_ov0_info, DRM_AUTH),
1278 DRM_IOCTL_DEF(DRM_I810_FSTATUS, i810_fstatus, DRM_AUTH),
1279 DRM_IOCTL_DEF(DRM_I810_OV0FLIP, i810_ov0_flip, DRM_AUTH),
1280 DRM_IOCTL_DEF(DRM_I810_MC, i810_dma_mc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
1281 DRM_IOCTL_DEF(DRM_I810_RSTATUS, i810_rstatus, DRM_AUTH),
1282 DRM_IOCTL_DEF(DRM_I810_FLIP, i810_flip_bufs, DRM_AUTH)
1285 int i810_max_ioctl = DRM_ARRAY_SIZE(i810_ioctls);
1288 * Determine if the device really is AGP or not.
1290 * All Intel graphics chipsets are treated as AGP, even if they are really
1293 * \param dev The device to be tested.
1296 * A value of 1 is always retured to indictate every i810 is AGP.
1298 int i810_driver_device_is_agp(struct drm_device * dev)