dev/drm/via_dmablit.c

197  * Fire a blit engine.
200 via_fire_dmablit(struct drm_device *dev, drm_via_sg_info_t *vsg, int engine)
204 	VIA_WRITE(VIA_PCI_DMA_MAR0 + engine*0x10, 0);
205 	VIA_WRITE(VIA_PCI_DMA_DAR0 + engine*0x10, 0);
206 	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DD | VIA_DMA_CSR_TD |
208 	VIA_WRITE(VIA_PCI_DMA_MR0  + engine*0x04, VIA_DMA_MR_CM | VIA_DMA_MR_TDIE);
209 	VIA_WRITE(VIA_PCI_DMA_BCR0 + engine*0x10, 0);
210 	VIA_WRITE(VIA_PCI_DMA_DPR0 + engine*0x10, vsg->chain_start);
212 	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DE | VIA_DMA_CSR_TS);
213 	(void)VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04);
290 via_abort_dmablit(struct drm_device *dev, int engine)
294 	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TA);
299 via_dmablit_engine_off(struct drm_device *dev, int engine)
303 	VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TD | VIA_DMA_CSR_DD);
310  * task. Basically the task of the interrupt handler is to submit a new blit to the engine, while
314 via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
317 	drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
322 	DRM_DEBUG("DMA blit handler called. engine = %d, from_irq = %d, blitq = 0x%lx\n",
323 		  engine, from_irq, (unsigned long) blitq);
328 	  (( status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD);
347 		VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04,  VIA_DMA_CSR_TD);
360 		via_abort_dmablit(dev, engine);
367 			via_fire_dmablit(dev, blitq->blits[cur], engine);
381 			via_dmablit_engine_off(dev, engine);
393 via_dmablit_active(drm_via_blitq_t *blitq, int engine, uint32_t handle, wait_queue_head_t **queue)
424 via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine)
428 	drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
432 	if (via_dmablit_active(blitq, engine, handle, &queue)) {
434 			    !via_dmablit_active(blitq, engine, handle, NULL));
436 	DRM_DEBUG("DMA blit sync handle 0x%x engine %d returned %d\n",
437 		  handle, engine, ret);
444  * A timer that regularly polls the blit engine in cases where we don't have interrupts:
455 	int engine = (int)
458 	DRM_DEBUG("Polling timer called for engine %d, jiffies %lu\n", engine,
461 	via_dmablit_handler(dev, engine, 0);
471 	       via_dmablit_handler(dev, engine, 0);
480  * blit engine only and may not be called on each interrupt.
491 	DRM_DEBUG("task called for blit engine %ld\n",(unsigned long)
660 via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
710 	int engine;
717 	engine = (xfer->to_fb) ? 0 : 1;
718 	blitq = dev_priv->blit_queues + engine;
719 	if (0 != (ret = via_dmablit_grab_slot(blitq, engine))) {
741 	xfer->sync.engine = engine;
743 	via_dmablit_handler(dev, engine, 0);
763 	if (sync->engine >= VIA_NUM_BLIT_ENGINES)
766 	err = via_dmablit_sync(dev, sync->sync_handle, sync->engine);