io/drm/drm_irq.c

51 	if ((irq.busnum >> 8) != dev->pci_domain ||
52 	    (irq.busnum & 0xff) != dev->pci_bus ||
53 	    irq.devnum != dev->pci_slot ||
54 	    irq.funcnum != dev->pci_func)
57 	irq.irq = dev->irq;
71 	drm_device_t *dev = (void *)arg;
74 	mutex_enter(&dev->irq_lock);
75 	ret = dev->driver->irq_handler(arg);
76 	mutex_exit(&dev->irq_lock);
83 	struct drm_device *dev = (struct drm_device *)arg;
86 	if (!dev->vblank_disable_allowed)
89 	for (i = 0; i < dev->num_crtcs; i++) {
90 		if (atomic_read(&dev->vblank_refcount[i]) == 0 &&
91 		    atomic_read(&dev->vblank_enabled[i]) == 1) {
92 			dev->last_vblank[i] =
93 			    dev->driver->get_vblank_counter(dev, i);
94 			dev->driver->disable_vblank(dev, i);
95 			atomic_set(&dev->vblank_enabled[i], 0);
102 drm_vblank_cleanup(struct drm_device *dev)
106 	if (dev->num_crtcs == 0)
109 	vblank_disable_fn((void *)dev);
111 	drm_free(dev->vbl_queues, sizeof (wait_queue_head_t) * dev->num_crtcs,
113 	drm_free(dev->vbl_sigs, sizeof (struct drm_vbl_sig) * dev->num_crtcs,
115 	drm_free(dev->_vblank_count, sizeof (atomic_t) *
116 	    dev->num_crtcs, DRM_MEM_DRIVER);
117 	drm_free(dev->vblank_refcount, sizeof (atomic_t) *
118 	    dev->num_crtcs, DRM_MEM_DRIVER);
119 	drm_free(dev->vblank_enabled, sizeof (int) *
120 	    dev->num_crtcs, DRM_MEM_DRIVER);
121 	drm_free(dev->last_vblank, sizeof (u32) * dev->num_crtcs,
123 	drm_free(dev->vblank_inmodeset, sizeof (*dev->vblank_inmodeset) *
124 	    dev->num_crtcs, DRM_MEM_DRIVER);
125 	dev->num_crtcs = 0;
129 drm_vblank_init(struct drm_device *dev, int num_crtcs)
133 	atomic_set(&dev->vbl_signal_pending, 0);
134 	dev->num_crtcs = num_crtcs;
137 	dev->vbl_queues = drm_alloc(sizeof (wait_queue_head_t) * num_crtcs,
139 	if (!dev->vbl_queues)
142 	dev->vbl_sigs = drm_alloc(sizeof (struct drm_vbl_sig) * num_crtcs,
144 	if (!dev->vbl_sigs)
147 	dev->_vblank_count = drm_alloc(sizeof (atomic_t) * num_crtcs,
149 	if (!dev->_vblank_count)
152 	dev->vblank_refcount = drm_alloc(sizeof (atomic_t) * num_crtcs,
154 	if (!dev->vblank_refcount)
157 	dev->vblank_enabled = drm_alloc(num_crtcs * sizeof (int),
159 	if (!dev->vblank_enabled)
162 	dev->last_vblank = drm_alloc(num_crtcs * sizeof (u32), DRM_MEM_DRIVER);
163 	if (!dev->last_vblank)
166 	dev->vblank_inmodeset = drm_alloc(num_crtcs * sizeof (int),
168 	if (!dev->vblank_inmodeset)
173 		DRM_INIT_WAITQUEUE(&dev->vbl_queues[i], DRM_INTR_PRI(dev));
174 		TAILQ_INIT(&dev->vbl_sigs[i]);
175 		atomic_set(&dev->_vblank_count[i], 0);
176 		atomic_set(&dev->vblank_refcount[i], 0);
179 	dev->vblank_disable_allowed = 1;
184 	drm_vblank_cleanup(dev);
190 drm_install_irq_handle(drm_device_t *dev)
192 	dev_info_t *dip = dev->dip;
206 	    &dev->intr_block) != DDI_SUCCESS) {
212 	if (ddi_add_intr(dip, 0, &dev->intr_block,
214 	    (caddr_t)dev) != DDI_SUCCESS) {
224 drm_irq_install(drm_device_t *dev)
228 	if (dev->dev_private == NULL) {
233 	if (dev->irq_enabled) {
238 	DRM_DEBUG("drm_irq_install irq=%d\n", dev->irq);
241 	ret = dev->driver->irq_preinstall(dev);
246 	ret  = drm_install_irq_handle(dev);
253 	dev->driver->irq_postinstall(dev);
255 	dev->irq_enabled = 1;
256 	dev->context_flag = 0;
262 drm_uninstall_irq_handle(drm_device_t *dev)
264 	ASSERT(dev->dip);
265 	ddi_remove_intr(dev->dip, 0, dev->intr_block);
271 drm_irq_uninstall(drm_device_t *dev)
274 	if (!dev->irq_enabled) {
277 	dev->irq_enabled = 0;
282 	DRM_SPINLOCK(&dev->vbl_lock);
283 	for (i = 0; i < dev->num_crtcs; i++) {
284 		DRM_WAKEUP(&dev->vbl_queues[i]);
285 		dev->vblank_enabled[i] = 0;
287 	DRM_SPINUNLOCK(&dev->vbl_lock);
289 	dev->driver->irq_uninstall(dev);
290 	drm_uninstall_irq_handle(dev);
291 	dev->locked_tasklet_func = NULL;
312 		return (drm_irq_install(dev));
314 		err = drm_irq_uninstall(dev);
322 drm_vblank_count(struct drm_device *dev, int crtc)
324 	return (atomic_read(&dev->_vblank_count[crtc]));
327 static void drm_update_vblank_count(struct drm_device *dev, int crtc)
333 	 * NOTE!  It's possible we lost a full dev->max_vblank_count events
337 	cur_vblank = dev->driver->get_vblank_counter(dev, crtc);
338 	diff = cur_vblank - dev->last_vblank[crtc];
339 	if (cur_vblank < dev->last_vblank[crtc]) {
340 		diff += dev->max_vblank_count;
342 	    crtc, dev->last_vblank[crtc], cur_vblank, diff);
345 	atomic_add(diff, &dev->_vblank_count[crtc]);
351 drm_vblank_get(struct drm_device *dev, int crtc)
355 	DRM_SPINLOCK(&dev->vbl_lock);
363 	atomic_add(1, &dev->vblank_refcount[crtc]);
364 	if (dev->vblank_refcount[crtc] == 1 &&
365 	    atomic_read(&dev->vblank_enabled[crtc]) == 0) {
366 		ret = dev->driver->enable_vblank(dev, crtc);
368 			atomic_dec(&dev->vblank_refcount[crtc]);
370 			atomic_set(&dev->vblank_enabled[crtc], 1);
371 			drm_update_vblank_count(dev, crtc);
374 	DRM_SPINUNLOCK(&dev->vbl_lock);
380 drm_vblank_put(struct drm_device *dev, int crtc)
382 	DRM_SPINLOCK(&dev->vbl_lock);
384 	atomic_dec(&dev->vblank_refcount[crtc]);
386 	if (dev->vblank_refcount[crtc] == 0)
387 		timer_id = timeout(vblank_disable_fn, (void *) dev, 5*DRM_HZ);
389 	DRM_SPINUNLOCK(&dev->vbl_lock);
412 	if (!dev->num_crtcs)
419 	if (crtc >= dev->num_crtcs) {
433 		if (!dev->vblank_inmodeset[crtc]) {
434 			dev->vblank_inmodeset[crtc] = 1;
435 			ret = drm_vblank_get(dev, crtc);
439 		if (dev->vblank_inmodeset[crtc]) {
440 			DRM_SPINLOCK(&dev->vbl_lock);
441 			dev->vblank_disable_allowed = 1;
442 			dev->vblank_inmodeset[crtc] = 0;
443 			DRM_SPINUNLOCK(&dev->vbl_lock);
444 			drm_vblank_put(dev, crtc);
465 	if (!dev->irq_enabled) {
494 	if (crtc >= dev->num_crtcs) {
498 	ret = drm_vblank_get(dev, crtc);
503 	sequence = drm_vblank_count(dev, crtc);
533 		DRM_WAIT_ON(ret, &dev->vbl_queues[crtc], 3 * DRM_HZ,
534 		    (((drm_vblank_count(dev, crtc)
536 		    !dev->irq_enabled));
542 			vblwait.reply.sequence = drm_vblank_count(dev, crtc);
564 	drm_vblank_put(dev, crtc);
571 drm_vbl_send_signals(drm_device_t *dev)
577 drm_handle_vblank(struct drm_device *dev, int crtc)
579 	atomic_inc(&dev->_vblank_count[crtc]);
580 	DRM_WAKEUP(&dev->vbl_queues[crtc]);