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))
212 } else if (dev->driver->get_vblank_counter) {
213 return dev->driver->get_vblank_counter(dev, pipe);
216 return drm_vblank_no_hw_counter(dev, pipe);
228 static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)
235 spin_lock(&dev->vblank_time_lock);
242 cur_vblank = __get_vblank_counter(dev, pipe);
243 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
244 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
258 store_vblank(dev, pipe, 1, t_vblank, cur_vblank);
260 spin_unlock(&dev->vblank_time_lock);
275 static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
278 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
284 u32 max_vblank_count = drm_max_vblank_count(dev, pipe);
289 * NOTE! It's possible we lost a full dev->max_vblank_count + 1 events
299 cur_vblank = __get_vblank_counter(dev, pipe);
300 rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, in_vblank_irq);
301 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
315 drm_dbg_vbl(dev, "crtc %u: Calculating number of vblanks."
322 drm_dbg_vbl(dev, "crtc %u: Redundant vblirq ignored\n",
339 drm_dbg_vbl(dev,
345 drm_dbg_vbl(dev, "updating vblank count on crtc %u:"
351 drm_WARN_ON_ONCE(dev, cur_vblank != vblank->last);
364 store_vblank(dev, pipe, diff, t_vblank, cur_vblank);
367 u64 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
369 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
372 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
402 struct drm_device *dev = crtc->dev;
407 drm_WARN_ONCE(dev, drm_debug_enabled(DRM_UT_VBL) &&
411 spin_lock_irqsave(&dev->vblank_time_lock, flags);
413 drm_update_vblank_count(dev, pipe, false);
414 vblank = drm_vblank_count(dev, pipe);
416 spin_unlock_irqrestore(&dev->vblank_time_lock, flags);
422 static void __disable_vblank(struct drm_device *dev, unsigned int pipe)
424 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
425 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
427 if (drm_WARN_ON(dev, !crtc))
433 dev->driver->disable_vblank(dev, pipe);
443 void drm_vblank_disable_and_save(struct drm_device *dev, unsigned int pipe)
445 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
448 assert_spin_locked(&dev->vbl_lock);
454 spin_lock_irqsave(&dev->vblank_time_lock, irqflags);
471 drm_update_vblank_count(dev, pipe, false);
472 __disable_vblank(dev, pipe);
476 spin_unlock_irqrestore(&dev->vblank_time_lock, irqflags);
482 struct drm_device *dev = vblank->dev;
486 spin_lock_irqsave(&dev->vbl_lock, irqflags);
488 drm_dbg_core(dev, "disabling vblank on crtc %u\n", pipe);
489 drm_vblank_disable_and_save(dev, pipe);
491 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
494 static void drm_vblank_init_release(struct drm_device *dev, void *ptr)
498 drm_WARN_ON(dev, READ_ONCE(vblank->enabled) &&
499 drm_core_check_feature(dev, DRIVER_MODESET));
507 * @dev: DRM device
508 * @num_crtcs: number of CRTCs supported by @dev
517 int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)
522 spin_lock_init(&dev->vbl_lock);
523 spin_lock_init(&dev->vblank_time_lock);
525 dev->vblank = drmm_kcalloc(dev, num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
526 if (!dev->vblank)
529 dev->num_crtcs = num_crtcs;
532 struct drm_vblank_crtc *vblank = &dev->vblank[i];
534 vblank->dev = dev;
540 ret = drmm_add_action_or_reset(dev, drm_vblank_init_release,
557 * @dev: the device
570 bool drm_dev_has_vblank(const struct drm_device *dev)
572 return dev->num_crtcs != 0;
586 return &crtc->dev->vblank[drm_crtc_index(crtc)].queue;
605 struct drm_device *dev = crtc->dev;
607 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
611 if (!drm_dev_has_vblank(dev))
614 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
635 drm_err(dev, "crtc %u: Can't calculate constants, dotclock = 0!\n",
643 drm_dbg_core(dev,
647 drm_dbg_core(dev, "crtc %u: clock %d kHz framedur %d linedur %d\n",
690 struct drm_device *dev = crtc->dev;
692 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
700 if (pipe >= dev->num_crtcs) {
701 drm_err(dev, "Invalid crtc %u\n", pipe);
707 drm_err(dev, "Called from CRTC w/o get_scanout_position()!?\n");
711 if (drm_drv_uses_atomic_modeset(dev))
720 drm_dbg_core(dev, "crtc %u: Noop due to uninitialized mode.\n",
722 drm_WARN_ON_ONCE(dev, drm_drv_uses_atomic_modeset(dev));
745 drm_dbg_core(dev,
761 drm_dbg_core(dev,
787 drm_dbg_vbl(dev,
843 * @dev: DRM device
862 drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
865 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
873 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
911 return drm_vblank_count(crtc->dev, drm_crtc_index(crtc));
918 * @dev: DRM device
929 static u64 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
932 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
936 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs)) {
972 return drm_vblank_count_and_time(crtc->dev, drm_crtc_index(crtc),
977 static void send_vblank_event(struct drm_device *dev,
1003 drm_send_event_locked(dev, &e->base);
1047 struct drm_device *dev = crtc->dev;
1050 assert_spin_locked(&dev->event_lock);
1054 list_add_tail(&e->base.link, &dev->vblank_event_list);
1072 struct drm_device *dev = crtc->dev;
1077 if (drm_dev_has_vblank(dev)) {
1078 seq = drm_vblank_count_and_time(dev, pipe, &now);
1085 send_vblank_event(dev, e, seq, now);
1089 static int __enable_vblank(struct drm_device *dev, unsigned int pipe)
1091 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1092 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1094 if (drm_WARN_ON(dev, !crtc))
1099 } else if (dev->driver->enable_vblank) {
1100 return dev->driver->enable_vblank(dev, pipe);
1106 static int drm_vblank_enable(struct drm_device *dev, unsigned int pipe)
1108 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1111 assert_spin_locked(&dev->vbl_lock);
1113 spin_lock(&dev->vblank_time_lock);
1123 ret = __enable_vblank(dev, pipe);
1124 drm_dbg_core(dev, "enabling vblank on crtc %u, ret: %d\n",
1129 drm_update_vblank_count(dev, pipe, 0);
1139 spin_unlock(&dev->vblank_time_lock);
1144 int drm_vblank_get(struct drm_device *dev, unsigned int pipe)
1146 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1150 if (!drm_dev_has_vblank(dev))
1153 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1156 spin_lock_irqsave(&dev->vbl_lock, irqflags);
1159 ret = drm_vblank_enable(dev, pipe);
1166 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
1183 return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
1187 void drm_vblank_put(struct drm_device *dev, unsigned int pipe)
1189 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1191 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1194 if (drm_WARN_ON(dev, atomic_read(&vblank->refcount) == 0))
1203 else if (!dev->vblank_disable_immediate)
1218 drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
1224 * @dev: DRM device
1233 void drm_wait_one_vblank(struct drm_device *dev, unsigned int pipe)
1235 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1239 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1242 ret = drm_vblank_get(dev, pipe);
1243 if (drm_WARN(dev, ret, "vblank not available on crtc %i, ret=%i\n",
1247 last = drm_vblank_count(dev, pipe);
1250 last != drm_vblank_count(dev, pipe),
1253 drm_WARN(dev, ret == 0, "vblank wait timed out on crtc %i\n", pipe);
1255 drm_vblank_put(dev, pipe);
1269 drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
1286 struct drm_device *dev = crtc->dev;
1288 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1293 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1300 spin_lock_irq(&dev->event_lock);
1302 spin_lock(&dev->vbl_lock);
1303 drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
1308 if (drm_core_check_feature(dev, DRIVER_ATOMIC) || !vblank->inmodeset)
1309 drm_vblank_disable_and_save(dev, pipe);
1321 spin_unlock(&dev->vbl_lock);
1324 seq = drm_vblank_count_and_time(dev, pipe, &now);
1326 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1329 drm_dbg_core(dev, "Sending premature vblank event on disable: "
1333 drm_vblank_put(dev, pipe);
1334 send_vblank_event(dev, e, seq, now);
1340 spin_unlock_irq(&dev->event_lock);
1365 struct drm_device *dev = crtc->dev;
1367 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1369 spin_lock_irq(&dev->vbl_lock);
1378 spin_unlock_irq(&dev->vbl_lock);
1380 drm_WARN_ON(dev, !list_empty(&dev->vblank_event_list));
1381 drm_WARN_ON(dev, !list_empty(&vblank->pending_work));
1405 struct drm_device *dev = crtc->dev;
1407 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1409 drm_WARN_ON(dev, dev->max_vblank_count);
1410 drm_WARN_ON(dev, !READ_ONCE(vblank->inmodeset));
1428 struct drm_device *dev = crtc->dev;
1430 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1432 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1435 spin_lock_irq(&dev->vbl_lock);
1436 drm_dbg_vbl(dev, "crtc %d, vblank enabled %d, inmodeset %d\n",
1445 drm_reset_vblank_timestamp(dev, pipe);
1452 drm_WARN_ON(dev, drm_vblank_enable(dev, pipe));
1453 spin_unlock_irq(&dev->vbl_lock);
1459 * @dev: DRM device
1470 void drm_vblank_restore(struct drm_device *dev, unsigned int pipe)
1479 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1482 assert_spin_locked(&dev->vbl_lock);
1483 assert_spin_locked(&dev->vblank_time_lock);
1485 vblank = &dev->vblank[pipe];
1486 drm_WARN_ONCE(dev,
1492 cur_vblank = __get_vblank_counter(dev, pipe);
1493 drm_get_last_vbltimestamp(dev, pipe, &t_vblank, false);
1494 } while (cur_vblank != __get_vblank_counter(dev, pipe) && --count > 0);
1501 drm_dbg_vbl(dev,
1504 store_vblank(dev, pipe, diff, t_vblank, cur_vblank);
1520 drm_vblank_restore(crtc->dev, drm_crtc_index(crtc));
1524 static void drm_legacy_vblank_pre_modeset(struct drm_device *dev,
1527 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1530 if (!drm_dev_has_vblank(dev))
1533 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1545 if (drm_vblank_get(dev, pipe) == 0)
1550 static void drm_legacy_vblank_post_modeset(struct drm_device *dev,
1553 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1556 if (!drm_dev_has_vblank(dev))
1559 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1563 spin_lock_irq(&dev->vbl_lock);
1564 drm_reset_vblank_timestamp(dev, pipe);
1565 spin_unlock_irq(&dev->vbl_lock);
1568 drm_vblank_put(dev, pipe);
1574 int drm_legacy_modeset_ctl_ioctl(struct drm_device *dev, void *data,
1581 if (!drm_dev_has_vblank(dev))
1585 if (!drm_core_check_feature(dev, DRIVER_LEGACY))
1589 if (pipe >= dev->num_crtcs)
1594 drm_legacy_vblank_pre_modeset(dev, pipe);
1597 drm_legacy_vblank_post_modeset(dev, pipe);
1606 static int drm_queue_vblank_event(struct drm_device *dev, unsigned int pipe,
1611 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1628 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1629 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1635 spin_lock_irq(&dev->event_lock);
1648 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
1654 seq = drm_vblank_count_and_time(dev, pipe, &now);
1656 drm_dbg_core(dev, "event on vblank count %llu, current %llu, crtc %u\n",
1663 drm_vblank_put(dev, pipe);
1664 send_vblank_event(dev, e, seq, now);
1668 list_add_tail(&e->base.link, &dev->vblank_event_list);
1672 spin_unlock_irq(&dev->event_lock);
1677 spin_unlock_irq(&dev->event_lock);
1680 drm_vblank_put(dev, pipe);
1711 static void drm_wait_vblank_reply(struct drm_device *dev, unsigned int pipe,
1722 reply->sequence = drm_vblank_count_and_time(dev, pipe, &now);
1728 int drm_wait_vblank_ioctl(struct drm_device *dev, void *data,
1739 if (!dev->irq_enabled)
1748 drm_dbg_core(dev,
1764 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
1766 drm_for_each_crtc(crtc, dev) {
1778 if (pipe >= dev->num_crtcs)
1781 vblank = &dev->vblank[pipe];
1786 if (dev->vblank_disable_immediate &&
1789 drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
1793 ret = drm_vblank_get(dev, pipe);
1795 drm_dbg_core(dev,
1800 seq = drm_vblank_count(dev, pipe);
1827 return drm_queue_vblank_event(dev, pipe, req_seq, vblwait, file_priv);
1833 drm_dbg_core(dev, "waiting on vblank count %llu, crtc %u\n",
1836 drm_vblank_passed(drm_vblank_count(dev, pipe), req_seq) ||
1856 drm_wait_vblank_reply(dev, pipe, &vblwait->reply);
1858 drm_dbg_core(dev, "crtc %d returning %u to client\n",
1861 drm_dbg_core(dev, "crtc %d vblank wait interrupted by signal\n",
1866 drm_vblank_put(dev, pipe);
1870 static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)
1872 struct drm_crtc *crtc = drm_crtc_from_index(dev, pipe);
1878 assert_spin_locked(&dev->event_lock);
1880 seq = drm_vblank_count_and_time(dev, pipe, &now);
1882 list_for_each_entry_safe(e, t, &dev->vblank_event_list, base.link) {
1888 drm_dbg_core(dev, "vblank event on %llu, current %llu\n",
1892 drm_vblank_put(dev, pipe);
1893 send_vblank_event(dev, e, seq, now);
1904 * @dev: DRM device
1912 bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)
1914 struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
1918 if (drm_WARN_ON_ONCE(dev, !drm_dev_has_vblank(dev)))
1921 if (drm_WARN_ON(dev, pipe >= dev->num_crtcs))
1924 spin_lock_irqsave(&dev->event_lock, irqflags);
1930 spin_lock(&dev->vblank_time_lock);
1934 spin_unlock(&dev->vblank_time_lock);
1935 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1939 drm_update_vblank_count(dev, pipe, true);
1941 spin_unlock(&dev->vblank_time_lock);
1950 disable_irq = (dev->vblank_disable_immediate &&
1954 drm_handle_vblank_events(dev, pipe);
1957 spin_unlock_irqrestore(&dev->event_lock, irqflags);
1988 return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
1995 * \param dev DRM device
2000 int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data,
2011 if (!drm_core_check_feature(dev, DRIVER_MODESET))
2014 if (!dev->irq_enabled)
2017 crtc = drm_crtc_find(dev, file_priv, get_seq->crtc_id);
2023 vblank = &dev->vblank[pipe];
2024 vblank_enabled = dev->vblank_disable_immediate && READ_ONCE(vblank->enabled);
2029 drm_dbg_core(dev,
2041 get_seq->sequence = drm_vblank_count_and_time(dev, pipe, &now);
2051 * \param dev DRM device
2056 int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data,
2070 if (!drm_core_check_feature(dev, DRIVER_MODESET))
2073 if (!dev->irq_enabled)
2076 crtc = drm_crtc_find(dev, file_priv, queue_seq->crtc_id);
2088 vblank = &dev->vblank[pipe];
2096 drm_dbg_core(dev,
2102 seq = drm_vblank_count_and_time(dev, pipe, &now);
2116 spin_lock_irq(&dev->event_lock);
2129 ret = drm_event_reserve_init_locked(dev, file_priv, &e->base,
2139 send_vblank_event(dev, e, seq, now);
2143 list_add_tail(&e->base.link, &dev->vblank_event_list);
2147 spin_unlock_irq(&dev->event_lock);
2151 spin_unlock_irq(&dev->event_lock);