Lines Matching refs:dev
157 drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
169 static void store_vblank(struct drm_device *dev, unsigned int pipe,
173 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
175 assert_spin_locked(&dev->vblank_time_lock);
185 static u32 drm_max_vblank_count(struct drm_device *dev, unsigned int pipe)
187 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
189 return vblank->max_vblank_count ?: dev->max_vblank_count;
196 static u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe)
198 drm_WARN_ON_ONCE(dev, drm_max_vblank_count(dev, pipe) != 0);
202 static u32 __get_vblank_counter(struct drm_device *dev, unsigned int pipe)
204 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
205 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
207 if (drm_WARN_ON(dev, !crtc))
214 else if (dev->driver->get_vblank_counter) {
215 return dev->driver->get_vblank_counter(dev, pipe);
219 return drm_vblank_no_hw_counter(dev, pipe);
231 static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
238 spin_lock(&dev->vblank_time_lock);
245 cur_vblank = __get_vblank_counter(dev, pipe);
246 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
247 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
261 store_vblank(dev, pipe, 1, t_vblank, cur_vblank);
263 spin_unlock(&dev->vblank_time_lock);
278 static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
281 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
287 u32 max_vblank_count = drm_max_vblank_count(dev, pipe);
292 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
302 cur_vblank = __get_vblank_counter(dev, pipe);
303 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, in_vblank_irq);
304 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
318 drm_dbg_vbl(dev, "crtc %u: Calculating number of vblanks."
325 drm_dbg_vbl(dev, "crtc %u: Redundant vblirq ignored\n",
342 drm_dbg_vbl(dev,
348 drm_dbg_vbl(dev, "updating vblank count on crtc %u:"
354 drm_WARN_ON_ONCE(dev, cur_vblank != vblank->last);
367 store_vblank(dev, pipe, diff, t_vblank, cur_vblank);
370 u64 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
372 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
375 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
405 struct drm_device *dev = crtc->dev;
410 drm_WARN_ONCE(dev, drm_debug_enabled(DRM_UT_VBL) &&
414 spin_lock_irqsave(&dev->vblank_time_lock, flags);
416 drm_update_vblank_count(dev, pipe, false);
417 vblank = drm_vblank_count(dev, pipe);
419 spin_unlock_irqrestore(&dev->vblank_time_lock, flags);
425 static void __disable_vblank(struct drm_device *dev, unsigned int pipe)
427 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
428 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
430 if (drm_WARN_ON(dev, !crtc))
438 dev->driver->disable_vblank(dev, pipe);
449 void drm_vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
451 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
454 assert_spin_locked(&dev->vbl_lock);
460 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
477 drm_update_vblank_count(dev, pipe, false);
478 __disable_vblank(dev, pipe);
482 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
488 struct drm_device *dev = vblank->dev;
492 spin_lock_irqsave(&dev->vbl_lock, irqflags);
494 drm_dbg_core(dev, "disabling vblank on crtc %u\n", pipe);
495 drm_vblank_disable_and_save(dev, pipe);
497 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
500 static void drm_vblank_init_release(struct drm_device *dev, void *ptr)
504 drm_WARN_ON(dev, READ_ONCE(vblank->enabled) &&
505 drm_core_check_feature(dev, DRIVER_MODESET));
513 * @dev: DRM device
514 * @num_crtcs: number of CRTCs supported by @dev
523 int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
528 spin_lock_init(&dev->vbl_lock);
529 spin_lock_init(&dev->vblank_time_lock);
531 dev->vblank = drmm_kcalloc(dev, num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
532 if (!dev->vblank)
535 dev->num_crtcs = num_crtcs;
538 struct drm_vblank_crtc *vblank = &dev->vblank[i];
540 vblank->dev = dev;
546 ret = drmm_add_action_or_reset(dev, drm_vblank_init_release,
563 * @dev: the device
576 bool drm_dev_has_vblank(const struct drm_device *dev)
578 return dev->num_crtcs != 0;
592 return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;
611 struct drm_device *dev = crtc->dev;
613 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
617 if (!drm_dev_has_vblank(dev))
620 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
641 drm_err(dev, "crtc %u: Can't calculate constants, dotclock = 0!\n",
649 drm_dbg_core(dev,
653 drm_dbg_core(dev, "crtc %u: clock %d kHz framedur %d linedur %d\n",
696 struct drm_device *dev = crtc->dev;
698 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
706 if (pipe >= dev->num_crtcs) {
707 drm_err(dev, "Invalid crtc %u\n", pipe);
713 drm_err(dev, "Called from CRTC w/o get_scanout_position()!?\n");
717 if (drm_drv_uses_atomic_modeset(dev))
726 drm_dbg_core(dev, "crtc %u: Noop due to uninitialized mode.\n",
728 drm_WARN_ON_ONCE(dev, drm_drv_uses_atomic_modeset(dev));
751 drm_dbg_core(dev,
767 drm_dbg_core(dev,
793 drm_dbg_vbl(dev,
891 drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
894 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
922 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
929 * @dev: DRM device
940 static u64 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
943 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
947 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs)) {
983 return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc),
1003 if (!drm_dev_has_vblank(crtc->dev))
1006 vblank = &crtc->dev->vblank[pipe];
1024 static void send_vblank_event(struct drm_device *dev,
1057 drm_send_event_timestamp_locked(dev, &e->base, now);
1101 struct drm_device *dev = crtc->dev;
1104 assert_spin_locked(&dev->event_lock);
1108 list_add_tail(&e->base.link, &dev->vblank_event_list);
1126 struct drm_device *dev = crtc->dev;
1131 if (drm_dev_has_vblank(dev)) {
1132 seq = drm_vblank_count_and_time(dev, pipe, &now);
1139 send_vblank_event(dev, e, seq, now);
1143 static int __enable_vblank(struct drm_device *dev, unsigned int pipe)
1145 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1146 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1148 if (drm_WARN_ON(dev, !crtc))
1155 else if (dev->driver->enable_vblank) {
1156 return dev->driver->enable_vblank(dev, pipe);
1163 static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
1165 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1168 assert_spin_locked(&dev->vbl_lock);
1170 spin_lock(&dev->vblank_time_lock);
1180 ret = __enable_vblank(dev, pipe);
1181 drm_dbg_core(dev, "enabling vblank on crtc %u, ret: %d\n",
1186 drm_update_vblank_count(dev, pipe, 0);
1196 spin_unlock(&dev->vblank_time_lock);
1201 int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
1203 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1207 if (!drm_dev_has_vblank(dev))
1210 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1213 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1216 ret = drm_vblank_enable(dev, pipe);
1223 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1240 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1244 void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
1246 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1248 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1251 if (drm_WARN_ON(dev, atomic_read(&vblank->refcount) == 0))
1260 else if (!dev->vblank_disable_immediate)
1275 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1281 * @dev: DRM device
1290 void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
1292 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1296 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1299 ret = drm_vblank_get(dev, pipe);
1300 if (drm_WARN(dev, ret, "vblank not available on crtc %i, ret=%i\n",
1304 last = drm_vblank_count(dev, pipe);
1307 last != drm_vblank_count(dev, pipe),
1310 drm_WARN(dev, ret == 0, "vblank wait timed out on crtc %i\n", pipe);
1312 drm_vblank_put(dev, pipe);
1326 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1343 struct drm_device *dev = crtc->dev;
1345 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1350 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1357 spin_lock_irq(&dev->event_lock);
1359 spin_lock(&dev->vbl_lock);
1360 drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
1365 if (drm_core_check_feature(dev, DRIVER_ATOMIC) || !vblank->inmodeset)
1366 drm_vblank_disable_and_save(dev, pipe);
1378 spin_unlock(&dev->vbl_lock);
1381 seq = drm_vblank_count_and_time(dev, pipe, &now);
1383 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1386 drm_dbg_core(dev, "Sending premature vblank event on disable: "
1390 drm_vblank_put(dev, pipe);
1391 send_vblank_event(dev, e, seq, now);
1397 spin_unlock_irq(&dev->event_lock);
1422 struct drm_device *dev = crtc->dev;
1424 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1426 spin_lock_irq(&dev->vbl_lock);
1435 spin_unlock_irq(&dev->vbl_lock);
1437 drm_WARN_ON(dev, !list_empty(&dev->vblank_event_list));
1438 drm_WARN_ON(dev, !list_empty(&vblank->pending_work));
1462 struct drm_device *dev = crtc->dev;
1464 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1466 drm_WARN_ON(dev, dev->max_vblank_count);
1467 drm_WARN_ON(dev, !READ_ONCE(vblank->inmodeset));
1485 struct drm_device *dev = crtc->dev;
1487 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1489 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1492 spin_lock_irq(&dev->vbl_lock);
1493 drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
1502 drm_reset_vblank_timestamp(dev, pipe);
1509 drm_WARN_ON(dev, drm_vblank_enable(dev, pipe));
1510 spin_unlock_irq(&dev->vbl_lock);
1514 static void drm_vblank_restore(struct drm_device *dev, unsigned int pipe)
1522 u32 max_vblank_count = drm_max_vblank_count(dev, pipe);
1524 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1527 assert_spin_locked(&dev->vbl_lock);
1528 assert_spin_locked(&dev->vblank_time_lock);
1530 vblank = &dev->vblank[pipe];
1531 drm_WARN_ONCE(dev,
1537 cur_vblank = __get_vblank_counter(dev, pipe);
1538 drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
1539 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
1546 drm_dbg_vbl(dev,
1571 WARN_ON_ONCE(!crtc->dev->vblank_disable_immediate);
1573 drm_vblank_restore(crtc->dev, drm_crtc_index(crtc));
1577 static void drm_legacy_vblank_pre_modeset(struct drm_device *dev,
1580 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1583 if (!drm_dev_has_vblank(dev))
1586 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1598 if (drm_vblank_get(dev, pipe) == 0)
1603 static void drm_legacy_vblank_post_modeset(struct drm_device *dev,
1606 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1609 if (!drm_dev_has_vblank(dev))
1612 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1616 spin_lock_irq(&dev->vbl_lock);
1617 drm_reset_vblank_timestamp(dev, pipe);
1618 spin_unlock_irq(&dev->vbl_lock);
1621 drm_vblank_put(dev, pipe);
1627 int drm_legacy_modeset_ctl_ioctl(struct drm_device *dev, void *data,
1634 if (!drm_dev_has_vblank(dev))
1638 if (!drm_core_check_feature(dev, DRIVER_LEGACY))
1642 if (pipe >= dev->num_crtcs)
1647 drm_legacy_vblank_pre_modeset(dev, pipe);
1650 drm_legacy_vblank_post_modeset(dev, pipe);
1659 static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
1664 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1681 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1682 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1688 spin_lock_irq(&dev->event_lock);
1701 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
1707 seq = drm_vblank_count_and_time(dev, pipe, &now);
1709 drm_dbg_core(dev, "event on vblank count %llu, current %llu, crtc %u\n",
1716 drm_vblank_put(dev, pipe);
1717 send_vblank_event(dev, e, seq, now);
1721 list_add_tail(&e->base.link, &dev->vblank_event_list);
1725 spin_unlock_irq(&dev->event_lock);
1730 spin_unlock_irq(&dev->event_lock);
1733 drm_vblank_put(dev, pipe);
1764 static void drm_wait_vblank_reply(struct drm_device *dev, unsigned int pipe,
1775 reply->sequence = drm_vblank_count_and_time(dev, pipe, &now);
1781 static bool drm_wait_vblank_supported(struct drm_device *dev)
1784 if (unlikely(drm_core_check_feature(dev, DRIVER_LEGACY)))
1785 return dev->irq_enabled;
1787 return drm_dev_has_vblank(dev);
1790 int drm_wait_vblank_ioctl(struct drm_device *dev, void *data,
1801 if (!drm_wait_vblank_supported(dev))
1810 drm_dbg_core(dev,
1826 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1828 drm_for_each_crtc(crtc, dev) {
1840 if (pipe >= dev->num_crtcs)
1843 vblank = &dev->vblank[pipe];
1848 if (dev->vblank_disable_immediate &&
1851 drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
1855 ret = drm_vblank_get(dev, pipe);
1857 drm_dbg_core(dev,
1862 seq = drm_vblank_count(dev, pipe);
1889 return drm_queue_vblank_event(dev, pipe, req_seq, vblwait, file_priv);
1895 drm_dbg_core(dev, "waiting on vblank count %llu, crtc %u\n",
1898 drm_vblank_passed(drm_vblank_count(dev, pipe), req_seq) ||
1918 drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
1920 drm_dbg_core(dev, "crtc %d returning %u to client\n",
1923 drm_dbg_core(dev, "crtc %d vblank wait interrupted by signal\n",
1928 drm_vblank_put(dev, pipe);
1932 static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
1934 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1940 assert_spin_locked(&dev->event_lock);
1942 seq = drm_vblank_count_and_time(dev, pipe, &now);
1944 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1950 drm_dbg_core(dev, "vblank event on %llu, current %llu\n",
1954 drm_vblank_put(dev, pipe);
1955 send_vblank_event(dev, e, seq, now);
1966 * @dev: DRM device
1974 bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
1976 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1980 if (drm_WARN_ON_ONCE(dev, !drm_dev_has_vblank(dev)))
1983 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1986 spin_lock_irqsave(&dev->event_lock, irqflags);
1992 spin_lock(&dev->vblank_time_lock);
1996 spin_unlock(&dev->vblank_time_lock);
1997 spin_unlock_irqrestore(&dev->event_lock, irqflags);
2001 drm_update_vblank_count(dev, pipe, true);
2003 spin_unlock(&dev->vblank_time_lock);
2012 disable_irq = (dev->vblank_disable_immediate &&
2016 drm_handle_vblank_events(dev, pipe);
2019 spin_unlock_irqrestore(&dev->event_lock, irqflags);
2050 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
2057 * \param dev DRM device
2062 int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data,
2073 if (!drm_core_check_feature(dev, DRIVER_MODESET))
2076 if (!drm_dev_has_vblank(dev))
2079 crtc = drm_crtc_find(dev, file_priv, get_seq->crtc_id);
2085 vblank = &dev->vblank[pipe];
2086 vblank_enabled = dev->vblank_disable_immediate && READ_ONCE(vblank->enabled);
2091 drm_dbg_core(dev,
2103 get_seq->sequence = drm_vblank_count_and_time(dev, pipe, &now);
2113 * \param dev DRM device
2118 int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data,
2132 if (!drm_core_check_feature(dev, DRIVER_MODESET))
2135 if (!drm_dev_has_vblank(dev))
2138 crtc = drm_crtc_find(dev, file_priv, queue_seq->crtc_id);
2150 vblank = &dev->vblank[pipe];
2158 drm_dbg_core(dev,
2164 seq = drm_vblank_count_and_time(dev, pipe, &now);
2178 spin_lock_irq(&dev->event_lock);
2191 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
2201 send_vblank_event(dev, e, seq, now);
2205 list_add_tail(&e->base.link, &dev->vblank_event_list);
2209 spin_unlock_irq(&dev->event_lock);
2213 spin_unlock_irq(&dev->event_lock);