Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

drm: Kill DRM_WAKUP and DRM_INIT_WAITQUEUE

Less yelling ftw!

Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Dave Airlie <airlied@redhat.com>

authored by

Daniel Vetter and committed by
Dave Airlie
57ed0f7b e9f0d76f

+21 -24
+3 -3
drivers/gpu/drm/drm_irq.c
··· 368 368 if (dev->num_crtcs) { 369 369 spin_lock_irqsave(&dev->vbl_lock, irqflags); 370 370 for (i = 0; i < dev->num_crtcs; i++) { 371 - DRM_WAKEUP(&dev->vblank[i].queue); 371 + wake_up(&dev->vblank[i].queue); 372 372 dev->vblank[i].enabled = false; 373 373 dev->vblank[i].last = 374 374 dev->driver->get_vblank_counter(dev, i); ··· 980 980 981 981 spin_lock_irqsave(&dev->vbl_lock, irqflags); 982 982 vblank_disable_and_save(dev, crtc); 983 - DRM_WAKEUP(&dev->vblank[crtc].queue); 983 + wake_up(&dev->vblank[crtc].queue); 984 984 985 985 /* Send any queued vblank events, lest the natives grow disquiet */ 986 986 seq = drm_vblank_count_and_time(dev, crtc, &now); ··· 1363 1363 crtc, (int) diff_ns); 1364 1364 } 1365 1365 1366 - DRM_WAKEUP(&dev->vblank[crtc].queue); 1366 + wake_up(&dev->vblank[crtc].queue); 1367 1367 drm_handle_vblank_events(dev, crtc); 1368 1368 1369 1369 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
+1 -1
drivers/gpu/drm/exynos/exynos_drm_fimd.c
··· 954 954 } 955 955 956 956 ctx->driver_data = drm_fimd_get_driver_data(pdev); 957 - DRM_INIT_WAITQUEUE(&ctx->wait_vsync_queue); 957 + init_waitqueue_head(&ctx->wait_vsync_queue); 958 958 atomic_set(&ctx->wait_vsync_event, 0); 959 959 960 960 subdrv = &ctx->subdrv;
+2 -2
drivers/gpu/drm/exynos/exynos_mixer.c
··· 1019 1019 /* set wait vsync event to zero and wake up queue. */ 1020 1020 if (atomic_read(&ctx->wait_vsync_event)) { 1021 1021 atomic_set(&ctx->wait_vsync_event, 0); 1022 - DRM_WAKEUP(&ctx->wait_vsync_queue); 1022 + wake_up(&ctx->wait_vsync_queue); 1023 1023 } 1024 1024 } 1025 1025 ··· 1209 1209 drm_hdmi_ctx->ctx = (void *)ctx; 1210 1210 ctx->vp_enabled = drv->is_vp_enabled; 1211 1211 ctx->mxr_ver = drv->version; 1212 - DRM_INIT_WAITQUEUE(&ctx->wait_vsync_queue); 1212 + init_waitqueue_head(&ctx->wait_vsync_queue); 1213 1213 atomic_set(&ctx->wait_vsync_event, 0); 1214 1214 1215 1215 platform_set_drvdata(pdev, drm_hdmi_ctx);
+2 -2
drivers/gpu/drm/mga/mga_irq.c
··· 79 79 MGA_WRITE(MGA_PRIMEND, prim_end); 80 80 81 81 atomic_inc(&dev_priv->last_fence_retired); 82 - DRM_WAKEUP(&dev_priv->fence_queue); 82 + wake_up(&dev_priv->fence_queue); 83 83 handled = 1; 84 84 } 85 85 ··· 151 151 { 152 152 drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private; 153 153 154 - DRM_INIT_WAITQUEUE(&dev_priv->fence_queue); 154 + init_waitqueue_head(&dev_priv->fence_queue); 155 155 156 156 /* Turn on soft trap interrupt. Vertical blank interrupts are enabled 157 157 * in mga_enable_vblank.
+1 -1
drivers/gpu/drm/omapdrm/omap_irq.c
··· 308 308 if (dev->num_crtcs) { 309 309 spin_lock_irqsave(&dev->vbl_lock, irqflags); 310 310 for (i = 0; i < dev->num_crtcs; i++) { 311 - DRM_WAKEUP(&dev->vblank[i].queue); 311 + wake_up(&dev->vblank[i].queue); 312 312 dev->vblank[i].enabled = false; 313 313 dev->vblank[i].last = 314 314 dev->driver->get_vblank_counter(dev, i);
+2 -2
drivers/gpu/drm/radeon/radeon_irq.c
··· 203 203 204 204 /* SW interrupt */ 205 205 if (stat & RADEON_SW_INT_TEST) 206 - DRM_WAKEUP(&dev_priv->swi_queue); 206 + wake_up(&dev_priv->swi_queue); 207 207 208 208 /* VBLANK interrupt */ 209 209 if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RS600) { ··· 354 354 (drm_radeon_private_t *) dev->dev_private; 355 355 356 356 atomic_set(&dev_priv->swi_emitted, 0); 357 - DRM_INIT_WAITQUEUE(&dev_priv->swi_queue); 357 + init_waitqueue_head(&dev_priv->swi_queue); 358 358 359 359 dev->max_vblank_count = 0x001fffff; 360 360
+5 -5
drivers/gpu/drm/via/via_dmablit.c
··· 338 338 339 339 blitq->blits[cur]->aborted = blitq->aborting; 340 340 blitq->done_blit_handle++; 341 - DRM_WAKEUP(blitq->blit_queue + cur); 341 + wake_up(blitq->blit_queue + cur); 342 342 343 343 cur++; 344 344 if (cur >= VIA_NUM_BLIT_SLOTS) ··· 521 521 522 522 spin_unlock_irqrestore(&blitq->blit_lock, irqsave); 523 523 524 - DRM_WAKEUP(&blitq->busy_queue); 524 + wake_up(&blitq->busy_queue); 525 525 526 526 via_free_sg_info(dev->pdev, cur_sg); 527 527 kfree(cur_sg); ··· 561 561 blitq->aborting = 0; 562 562 spin_lock_init(&blitq->blit_lock); 563 563 for (j = 0; j < VIA_NUM_BLIT_SLOTS; ++j) 564 - DRM_INIT_WAITQUEUE(blitq->blit_queue + j); 565 - DRM_INIT_WAITQUEUE(&blitq->busy_queue); 564 + init_waitqueue_head(blitq->blit_queue + j); 565 + init_waitqueue_head(&blitq->busy_queue); 566 566 INIT_WORK(&blitq->wq, via_dmablit_workqueue); 567 567 setup_timer(&blitq->poll_timer, via_dmablit_timer, 568 568 (unsigned long)blitq); ··· 713 713 spin_lock_irqsave(&blitq->blit_lock, irqsave); 714 714 blitq->num_free++; 715 715 spin_unlock_irqrestore(&blitq->blit_lock, irqsave); 716 - DRM_WAKEUP(&blitq->busy_queue); 716 + wake_up(&blitq->busy_queue); 717 717 } 718 718 719 719 /*
+2 -2
drivers/gpu/drm/via/via_irq.c
··· 138 138 for (i = 0; i < dev_priv->num_irqs; ++i) { 139 139 if (status & cur_irq->pending_mask) { 140 140 atomic_inc(&cur_irq->irq_received); 141 - DRM_WAKEUP(&cur_irq->irq_queue); 141 + wake_up(&cur_irq->irq_queue); 142 142 handled = 1; 143 143 if (dev_priv->irq_map[drm_via_irq_dma0_td] == i) 144 144 via_dmablit_handler(dev, 0, 1); ··· 287 287 atomic_set(&cur_irq->irq_received, 0); 288 288 cur_irq->enable_mask = dev_priv->irq_masks[i][0]; 289 289 cur_irq->pending_mask = dev_priv->irq_masks[i][1]; 290 - DRM_INIT_WAITQUEUE(&cur_irq->irq_queue); 290 + init_waitqueue_head(&cur_irq->irq_queue); 291 291 dev_priv->irq_enable_mask |= cur_irq->enable_mask; 292 292 dev_priv->irq_pending_mask |= cur_irq->pending_mask; 293 293 cur_irq++;
+3 -3
drivers/gpu/drm/via/via_video.c
··· 36 36 DRM_DEBUG("\n"); 37 37 38 38 for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) { 39 - DRM_INIT_WAITQUEUE(&(dev_priv->decoder_queue[i])); 39 + init_waitqueue_head(&(dev_priv->decoder_queue[i])); 40 40 XVMCLOCKPTR(dev_priv->sarea_priv, i)->lock = 0; 41 41 } 42 42 } ··· 58 58 if ((_DRM_LOCKING_CONTEXT(*lock) == context)) { 59 59 if (_DRM_LOCK_IS_HELD(*lock) 60 60 && (*lock & _DRM_LOCK_CONT)) { 61 - DRM_WAKEUP(&(dev_priv->decoder_queue[i])); 61 + wake_up(&(dev_priv->decoder_queue[i])); 62 62 } 63 63 *lock = 0; 64 64 } ··· 86 86 (fx->ms / 10) * (HZ / 100), *lock != fx->val); 87 87 return ret; 88 88 case VIA_FUTEX_WAKE: 89 - DRM_WAKEUP(&(dev_priv->decoder_queue[fx->lock])); 89 + wake_up(&(dev_priv->decoder_queue[fx->lock])); 90 90 return 0; 91 91 } 92 92 return 0;
-3
include/drm/drm_os_linux.h
··· 78 78 __set_current_state(TASK_RUNNING); \ 79 79 remove_wait_queue(&(queue), &entry); \ 80 80 } while (0) 81 - 82 - #define DRM_WAKEUP( queue ) wake_up( queue ) 83 - #define DRM_INIT_WAITQUEUE( queue ) init_waitqueue_head( queue )