drm/nouveau: Introduce CRC support for gf119+
Subsystems (3)
Lyude Paul
maintainerv4 cover drm/nouveau: Introduce CRC support for gf119+
Nvidia released some documentation on how CRC support works on their GPUs, hooray!
So: this patch series implements said CRC support in nouveau, along with adding some special debugfs interfaces for some relevant igt-gpu-tools tests (already on the ML).
First - we add some new functionality to kthread_work in the kernel, and then use this to add a new feature to DRM that Ville Syrjälä came up
with: vblank workers. Basically, this is just a generic DRM interface that allows for scheduling high-priority workers that start on a given vblank interrupt. Note that while we're currently only using this in nouveau, Intel has plans to use this for i915 as well (hence why they came up with it!).
And finally: in order to implement the last feature, we expose some new functions in the kernel's kthread_worker infrastructure so that we can de-complicate our implementation of this.
Anyway-welcome to the future! :)
Major changes since v3:
* Style fixes on nouveau patches from checkpatch, no functional changes
* Don't integrate so tightly with kthread_work (and use our own lock), instead introduce some new functions for doing simple async flushing and cancelling. I think this interface looks a lot more acceptable then what I was previously trying.
* Apply some changes requested by danvet
Major changes since v2:
* Use kthread_worker instead of kthreadd for vblank workers
* Don't check debugfs return values
Lyude Paul (12):
kthread: Add kthread_queue_flush_work()
kthread: Add kthread_(un)block_work_queuing() and
kthread_work_queuable()
drm/vblank: Register drmm cleanup action once per drm_vblank_crtc drm/vblank: Add vblank works
drm/nouveau/kms/nv50-: Unroll error cleanup in nv50_head_create() drm/nouveau/kms/nv140-: Don't modify depth in state during atomic
commit
drm/nouveau/kms/nv50-: Fix disabling dithering drm/nouveau/kms/nv50-: s/harm/armh/g drm/nouveau/kms/nv140-: Track wndw mappings in nv50_head_atom drm/nouveau/kms/nv50-: Expose nv50_outp_atom in disp.h drm/nouveau/kms/nv50-: Move hard-coded object handles into header drm/nouveau/kms/nvd9-: Add CRC support
drivers/gpu/drm/drm_vblank.c | 280 +++++++- drivers/gpu/drm/nouveau/dispnv04/crtc.c | 25 +- drivers/gpu/drm/nouveau/dispnv50/Kbuild | 4 + drivers/gpu/drm/nouveau/dispnv50/atom.h | 21 + drivers/gpu/drm/nouveau/dispnv50/core.h | 4 + drivers/gpu/drm/nouveau/dispnv50/core907d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/core917d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/corec37d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/corec57d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/crc.c | 715 ++++++++++++++++++++ drivers/gpu/drm/nouveau/dispnv50/crc.h | 125 ++++ drivers/gpu/drm/nouveau/dispnv50/crc907d.c | 139 ++++ drivers/gpu/drm/nouveau/dispnv50/crcc37d.c | 153 +++++ drivers/gpu/drm/nouveau/dispnv50/disp.c | 65 +- drivers/gpu/drm/nouveau/dispnv50/disp.h | 24 + drivers/gpu/drm/nouveau/dispnv50/handles.h | 16 + drivers/gpu/drm/nouveau/dispnv50/head.c | 142 +++- drivers/gpu/drm/nouveau/dispnv50/head.h | 13 +- drivers/gpu/drm/nouveau/dispnv50/head907d.c | 14 +- drivers/gpu/drm/nouveau/dispnv50/headc37d.c | 27 +- drivers/gpu/drm/nouveau/dispnv50/headc57d.c | 20 +- drivers/gpu/drm/nouveau/dispnv50/wndw.c | 15 +- drivers/gpu/drm/nouveau/nouveau_display.c | 60 +- include/drm/drm_vblank.h | 35 + include/linux/kthread.h | 35 + kernel/kthread.c | 133 +++- 26 files changed, 1903 insertions(+), 174 deletions(-) create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc.c create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc.h create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc907d.c create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crcc37d.c create mode 100644 drivers/gpu/drm/nouveau/dispnv50/handles.h
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 1/12 kthread: Add kthread_queue_flush_work()
Currently, it's only possible to flush on a kthread_work in contexts where it's possible to block. This can be kind of painful though when trying to implement new types of delayed work which use kthread_work, since it means we'd need to drop any spinlocks for new delayed work implementations before we can actually call kthread_flush_work().
In the time between dropping locks and calling kthread_flush_work(), the work might have already executed once and have gotten re-queued by the time we're ready. This would mean that once the user finally executes kthread_flush_work(), we'd accidentally wait for someone else's queued work instead of our own.
For DRM vblank works it's preferable that we just return immediately during such races, instead of blocking on the re-queue. Additionally, we also want to be able to use kthread_flush_work structs in our own contexts so that we can block until a vblank work's target vblank has passed, _and_ said work has executed once since. And finally, we also want to be able to finish flushing on a work early if it's been cancelled at any point (e.g. before or after it's actually been queued on the kthread_worker).
So, let's make all of these things possible by exposing struct kthread_flush_work, and then splitting kthread_flush_work() into two
functions: kthread_queue_flush_work(); which handles possibly queuing up the kthread_flush_work on the work's respective kthread_worker, and kthread_flush_work(); which performs a simple synchronous flush just like before. We also add a DEFINE_KTHREAD_FLUSH_WORK() macro, which simply initializes a kthread_flush_work struct inline (I can't see anyone needing to use a kthread_flush_work that gets used outside of the scope of a single function, and that seems like it would be a bit overkill anyway).
--- include/linux/kthread.h | 16 ++++++++ kernel/kthread.c | 87 ++++++++++++++++++++++++++--------------- 2 files changed, 71 insertions(+), 32 deletions(-)
include/linux/kthread.h +16 -0
@@ -105,6 +105,11 @@ struct kthread_delayed_work {struct timer_list timer; }; +struct kthread_flush_work { +struct kthread_work work; +struct completion done; +}; +#define KTHREAD_WORKER_INIT (worker) { \ .lock = __RAW_SPIN_LOCK_UNLOCKED((worker).lock), \ .work_list = LIST_HEAD_INIT((worker).work_list), \
@@ -122,6 +127,11 @@ struct kthread_delayed_work { TIMER_IRQSAFE), \ } +#define KTHREAD_FLUSH_WORK_INIT (fwork) { \ + KTHREAD_WORK_INIT((fwork).work, __kthread_flush_work_fn), \ + COMPLETION_INITIALIZER_ONSTACK((fwork).done), \ + } +#define DEFINE_KTHREAD_WORKER (worker) \ struct kthread_worker worker = KTHREAD_WORKER_INIT(worker)
@@ -132,6 +142,9 @@ struct kthread_delayed_work {struct kthread_delayed_work dwork = \ KTHREAD_DELAYED_WORK_INIT(dwork, fn) +#define DEFINE_KTHREAD_FLUSH_WORK (fwork) \ + struct kthread_flush_work fwork = KTHREAD_FLUSH_WORK_INIT(fwork); +/* * kthread_worker.lock needs its own lockdep class key when defined on * stack with lockdep enabled. Use the following macros in such cases.
@@ -190,6 +203,9 @@ bool kthread_mod_delayed_work(struct kthread_worker *worker,struct kthread_delayed_work *dwork, unsigned long delay); +bool kthread_queue_flush_work (struct kthread_work *work, +struct kthread_flush_work *fwork); +void __kthread_flush_work_fn (struct kthread_work *work);void kthread_flush_work (struct kthread_work *work);void kthread_flush_worker (struct kthread_worker *worker);
kernel/kthread.c +55 -32
117 lines not on this page · raw message
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 2/12 kthread: Add kthread_(un)block_work_queuing() and kthread_work_queuable()
In reply to Lyude PaulAdd some simple wrappers around incrementing/decrementing kthread_work.cancelling under lock, along with checking whether queuing is currently allowed on a given kthread_work, which we'll use want to implement work cancelling with DRM's vblank work helpers.
--- include/linux/kthread.h | 19 +++++++++++++++++ kernel/kthread.c | 46 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+)
include/linux/kthread.h +19 -0
@@ -211,9 +211,28 @@ void kthread_flush_worker(struct kthread_worker *worker);bool kthread_cancel_work_sync (struct kthread_work *work);bool kthread_cancel_delayed_work_sync (struct kthread_delayed_work *work); +void kthread_block_work_queuing (struct kthread_worker *worker, +struct kthread_work *work); +void kthread_unblock_work_queuing (struct kthread_worker *worker, +struct kthread_work *work);void kthread_destroy_worker (struct kthread_worker *worker); +/** +* kthread_work_queuable - whether or not a kthread work can be queued +* @work: The kthread work to check +* +* Checks whether or not queuing @work is currently blocked from queuing, +* either by kthread_cancel_work_sync() and friends or +* kthread_block_work_queuing(). +* +* Returns: whether or not the @work may be queued. +*/ +static inline bool kthread_work_queuable (struct kthread_work *work) +{ +return READ_ONCE (work->canceling) ==0 ; +} +struct cgroup_subsys_state ;#ifdef CONFIG_BLK_CGROUP
kernel/kthread.c +46 -0
52 lines not on this page · raw message
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 3/12 drm/vblank: Register drmm cleanup action once per drm_vblank_crtc
In reply to Lyude PaulSince we'll be allocating resources for kthread_create_worker() in the next commit (which could fail and require us to clean up the mess), let's simplify the cleanup process a bit by registering a drm_vblank_init_release() action for each drm_vblank_crtc so they're still cleaned up if we fail to initialize one of them.
Changes since v3:
* Use drmm_add_action_or_reset() - Daniel Vetter
--- drivers/gpu/drm/drm_vblank.c | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-)
drivers/gpu/drm/drm_vblank.c +10 -13
@@ -491,16 +491,12 @@ static void vblank_disable_fn(struct timer_list *t)static void drm_vblank_init_release (struct drm_device *dev,void *ptr) { -unsigned int pipe; - -for (pipe =0 ; pipe < dev->num_crtcs; pipe++) { -struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; +struct drm_vblank_crtc *vblank = ptr; -WARN_ON (READ_ONCE (vblank->enabled) && -drm_core_check_feature (dev,DRIVER_MODESET )); +WARN_ON (READ_ONCE (vblank->enabled) && +drm_core_check_feature (dev,DRIVER_MODESET )); -del_timer_sync (&vblank->disable_timer); - } +del_timer_sync (&vblank->disable_timer); }/**
@@ -510,7 +506,7 @@ static void drm_vblank_init_release(struct drm_device *dev, void *ptr)* * This function initializes vblank support for @num_crtcs display pipelines. * Cleanup is handled automatically through a cleanup function added with -* drmm_add_action(). +* drmm_add_action_or_reset(). * * Returns: * Zero on success or a negative error code on failure.
@@ -529,10 +525,6 @@ int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs) dev->num_crtcs = num_crtcs; - ret =drmm_add_action (dev, drm_vblank_init_release,NULL ); -if (ret) -return ret; -for (i =0 ; i < num_crtcs; i++) {struct drm_vblank_crtc *vblank = &dev->vblank[i];
@@ -541,6 +533,11 @@ int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)init_waitqueue_head (&vblank->queue);timer_setup (&vblank->disable_timer, vblank_disable_fn,0 );seqlock_init (&vblank->seqlock); + + ret =drmm_add_action_or_reset (dev, drm_vblank_init_release, + vblank); +if (ret) +return ret; }DRM_INFO ("Supports vblank timestamp caching Rev 2 (21.10.2013).\n" );
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 4/12 drm/vblank: Add vblank works
In reply to Lyude PaulAdd some kind of vblank workers. The interface is similar to regular delayed works, and is mostly based off kthread_work. It allows for scheduling delayed works that execute once a particular vblank sequence has passed. It also allows for accurate flushing of scheduled vblank works - in that flushing waits for both the vblank sequence and job execution to complete, or for the work to get cancelled - whichever comes first.
Whatever hardware programming we do in the work must be fast (must at least complete during the vblank or scanout period, sometimes during the first few scanlines of the vblank). As such we use a high-priority per-CRTC thread to accomplish this.
[based off patches from Ville Syrjälä <[email protected]>, change below to signoff later]
Changes since v3:
* Use our own spinlocks, don't integrate so tightly with kthread_works Changes since v2:
* Use kthread_workers instead of reinventing the wheel.
--- drivers/gpu/drm/drm_vblank.c | 259 +++++++++++++++++++++++++++++++++++ include/drm/drm_vblank.h | 35 +++++ 2 files changed, 294 insertions(+)
drivers/gpu/drm/drm_vblank.c +259 -0
@@ -25,7 +25,9 @@*/ #include <linux/export.h> +#include <linux/kthread.h> #include <linux/moduleparam.h> +#include <uapi/linux/sched/types.h> #include <drm/drm_crtc.h> #include <drm/drm_drv.h>
@@ -155,6 +157,7 @@static bool drm_get_last_vbltimestamp (struct drm_device *dev,unsigned int pipe,ktime_t *tvblank,bool in_vblank_irq); +static int drm_vblank_get (struct drm_device *dev,unsigned int pipe);static unsigned int drm_timestamp_precision =20 ;/* Default to 20 usecs. */
@@ -496,9 +499,46 @@ static void drm_vblank_init_release(struct drm_device *dev, void *ptr)WARN_ON (READ_ONCE (vblank->enabled) &&drm_core_check_feature (dev,DRIVER_MODESET )); +if (vblank->worker && !IS_ERR (vblank->worker)) +kthread_destroy_worker (vblank->worker);del_timer_sync (&vblank->disable_timer); } +/** +* drm_vblank_work_init - initialize a vblank work item +* @work: vblank work item +* @crtc: CRTC whose vblank will trigger the work execution +* @func: work function to be executed +* +* Initialize a vblank work item for a specific crtc. +*/ +void drm_vblank_work_init (struct drm_vblank_work *work,struct drm_crtc *crtc, +void (*func)(struct kthread_work *work)) +{ +kthread_init_work (&work->base, func); +INIT_LIST_HEAD (&work->flush_work); +INIT_LIST_HEAD (&work->pending); + work->vblank = &crtc->dev->vblank[drm_crtc_index (crtc)]; +} +EXPORT_SYMBOL (drm_vblank_work_init); + +static int vblank_worker_init (struct drm_vblank_crtc *vblank) +{ +struct sched_param param = { + .sched_priority =MAX_RT_PRIO -1 , + }; + +INIT_LIST_HEAD (&vblank->pending_work); +spin_lock_init (&vblank->work_lock); + vblank->worker =kthread_create_worker (0 ,"card%d-crtc%d" , + vblank->dev->primary->index, + vblank->pipe); +if (IS_ERR (vblank->worker)) +return PTR_ERR (vblank->worker); + +return sched_setscheduler (vblank->worker->task,SCHED_FIFO , ¶m); +} +/** * drm_vblank_init - initialize vblank support * @dev: DRM device
@@ -538,6 +578,10 @@ int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs) vblank);if (ret)return ret; + + ret =vblank_worker_init (vblank); +if (ret) +return ret; }DRM_INFO ("Supports vblank timestamp caching Rev 2 (21.10.2013).\n" );
@@ -1878,6 +1922,45 @@ static void drm_handle_vblank_events(struct drm_device *dev, unsigned int pipe)trace_drm_vblank_event (pipe, seq, now, high_prec); } +static void queue_vbl_work (struct drm_vblank_work *work) +{ +struct kthread_flush_work *fwork, *tmp; +bool busy, reinit = false; + + busy =kthread_queue_work (work->vblank->worker, &work->base); +list_for_each_entry_safe (fwork, tmp, &work->flush_work, work.node) { +if (busy) { +list_del_init (&fwork->work.node); + busy =kthread_queue_flush_work (&work->base, fwork); +if (!busy) +complete (&fwork->done); + }else { +complete (&fwork->done); + reinit = true; + } + } + +if (reinit) +INIT_LIST_HEAD (&work->flush_work); +} + +static void drm_handle_vblank_works (struct drm_vblank_crtc *vblank) +{ +struct drm_vblank_work *work, *next; +u64 count =atomic64_read (&vblank->count); + +spin_lock (&vblank->work_lock); +list_for_each_entry_safe (work, next, &vblank->pending_work, pending) { +if (!vblank_passed (count, work->count)) +continue ; + +list_del_init (&work->pending); +drm_vblank_put (vblank->dev, vblank->pipe); +queue_vbl_work (work); + } +spin_unlock (&vblank->work_lock); +} +/** * drm_handle_vblank - handle a vblank event * @dev: DRM device
@@ -1919,6 +2002,7 @@ bool drm_handle_vblank(struct drm_device *dev, unsigned int pipe)spin_unlock (&dev->vblank_time_lock); +drm_handle_vblank_works (vblank);wake_up (&vblank->queue);/* With instant-off, we defer disabling the interrupt until after
@@ -2129,3 +2213,178 @@ int drm_crtc_queue_sequence_ioctl(struct drm_device *dev, void *data,kfree (e);return ret; } + +/** +* drm_vblank_work_schedule - schedule a vblank work +* @work: vblank work to schedule +* @count: target vblank count +* @nextonmiss: defer until the next vblank if target vblank was missed +* +* Schedule @work for execution once the crtc vblank count reaches @count. +* +* If the crtc vblank count has already reached @count and @nextonmiss is +* %false the work starts to execute immediately. +* +* If the crtc vblank count has already reached @count and @nextonmiss is +* %true the work is deferred until the next vblank (as if @count has been +* specified as crtc vblank count + 1). +* +* If @work is already scheduled, this function will reschedule said work +* using the new @count. +* +* Returns: +* 0 on success, error code on failure. +*/ +int drm_vblank_work_schedule (struct drm_vblank_work *work, +u64 count,bool nextonmiss) +{ +struct drm_vblank_crtc *vblank = work->vblank; +struct drm_device *dev = vblank->dev; +u64 cur_vbl; +unsigned long irqflags; +bool passed, rescheduling = false; +int ret =0 ; + +spin_lock_irqsave (&vblank->work_lock, irqflags); +if (!kthread_work_queuable (&work->base)) + goto out; + +if (list_empty (&work->pending)) { + ret =drm_vblank_get (dev, vblank->pipe); +if (ret <0 ) + goto out; + }else if (work->count == count) { +/* Already scheduled w/ same vbl count */ + goto out; + }else { + rescheduling = true; + } + + work->count = count; + cur_vbl =drm_vblank_count (dev, vblank->pipe); + passed =vblank_passed (cur_vbl, count); +if (passed) +DRM_ERROR ("crtc %d vblank %llu already passed (current %llu)\n" , + vblank->pipe, count, cur_vbl); + +if (!nextonmiss && passed) { +drm_vblank_put (dev, vblank->pipe); +if (rescheduling) +list_del_init (&work->pending); +queue_vbl_work (work); + }else if (rescheduling) { +list_move_tail (&work->pending, &vblank->pending_work); + }else { +list_add_tail (&work->pending, &vblank->pending_work); + } + + out: +spin_unlock_irqrestore (&vblank->work_lock, irqflags); +return ret; +} +EXPORT_SYMBOL (drm_vblank_work_schedule); + +static bool vblank_work_cancel (struct drm_vblank_work *work) +{ +struct kthread_flush_work *pos, *tmp; + +if (list_empty (&work->pending)) +return false; + +list_for_each_entry_safe (pos, tmp, &work->flush_work, work.node) +complete (&pos->done); + +list_del_init (&work->pending); +INIT_LIST_HEAD (&work->flush_work); +return true; +} + +/** +* drm_vblank_work_cancel - cancel a vblank work +* @work: vblank work to cancel +* +* Cancel an already scheduled vblank work. +* +* On return @work may still be executing, unless the return +* value is %true. +* +* Returns: +* True if the work was cancelled before it started to excute, false otherwise. +*/ +bool drm_vblank_work_cancel (struct drm_vblank_work *work) +{ +struct drm_vblank_crtc *vblank = work->vblank; +bool cancelled; + +spin_lock_irq (&vblank->work_lock); + cancelled =vblank_work_cancel (work); +spin_unlock_irq (&vblank->work_lock); +if (cancelled) +drm_vblank_put (vblank->dev, vblank->pipe); + +return cancelled; +} +EXPORT_SYMBOL (drm_vblank_work_cancel); + +/** +* drm_vblank_work_cancel_sync - cancel a vblank work and wait for it to +* finish executing +* @work: vblank work to cancel +* +* Cancel an already scheduled vblank work and wait for its +* execution to finish. +* +* On return @work is no longer guaraneed to be executing. +* +* Returns: +* %True if the work was cancelled before it started to execute, %false +* otherwise. +*/ +bool drm_vblank_work_cancel_sync (struct drm_vblank_work *work) +{ +struct drm_vblank_crtc *vblank = work->vblank; +bool vbl_put, cancelled; + +spin_lock_irq (&vblank->work_lock); + cancelled =vblank_work_cancel (work); + vbl_put = cancelled; + +kthread_block_work_queuing (vblank->worker, &work->base); +spin_unlock_irq (&vblank->work_lock); + + cancelled |=kthread_cancel_work_sync (&work->base); +if (vbl_put) +drm_vblank_put (vblank->dev, vblank->pipe); + +kthread_unblock_work_queuing (vblank->worker, &work->base); + +return cancelled; +} +EXPORT_SYMBOL (drm_vblank_work_cancel_sync); + +/** +* drm_vblank_work_flush - wait for a scheduled vblank work to finish +* executing +* @work: vblank work to flush +* +* Wait until @work has finished executing once. +*/ +void drm_vblank_work_flush (struct drm_vblank_work *work) +{ +struct drm_vblank_crtc *vblank = work->vblank; +bool scheduled; +DEFINE_KTHREAD_FLUSH_WORK (fwork); + +spin_lock_irq (&vblank->work_lock); + + scheduled = !list_empty (&work->pending); +if (scheduled) +list_add_tail (&fwork.work.node, &work->flush_work); +else + scheduled =kthread_queue_flush_work (&work->base, &fwork); + +spin_unlock_irq (&vblank->work_lock); +if (scheduled) +wait_for_completion (&fwork.done); +} +EXPORT_SYMBOL (drm_vblank_work_flush);
include/drm/drm_vblank.h +35 -0
@@ -27,6 +27,7 @@#include <linux/seqlock.h> #include <linux/idr.h> #include <linux/poll.h> +#include <linux/kthread.h> #include <drm/drm_file.h> #include <drm/drm_modes.h>
@@ -203,8 +204,42 @@ struct drm_vblank_crtc {* disabling functions multiple times. */ bool enabled; + +/** +* @worker: The &kthread_worker used for executing vblank works. +*/ +struct kthread_worker *worker; +/** +* @work_lock: The spinlock that protects @pending_work +*/ +spinlock_t work_lock; +/** +* @pending_work: A list of scheduled &drm_vblank_work that are +* waiting for a future vblank. +*/ +struct list_head pending_work; +}; + +struct drm_vblank_work { +struct kthread_work base; +struct drm_vblank_crtc *vblank; +u64 count; + +struct list_head pending; +struct list_head flush_work; }; +#define to_drm_vblank_work (_work) \ + container_of((_work), struct drm_vblank_work, base) + +int drm_vblank_work_schedule (struct drm_vblank_work *work, +u64 count,bool nextonmiss); +void drm_vblank_work_init (struct drm_vblank_work *work,struct drm_crtc *crtc, +void (*func)(struct kthread_work *work)); +bool drm_vblank_work_cancel (struct drm_vblank_work *work); +bool drm_vblank_work_cancel_sync (struct drm_vblank_work *work); +void drm_vblank_work_flush (struct drm_vblank_work *work); +int drm_vblank_init (struct drm_device *dev,unsigned int num_crtcs);bool drm_dev_has_vblank (const struct drm_device *dev);u64 drm_crtc_vblank_count (struct drm_crtc *crtc);
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 5/12 drm/nouveau/kms/nv50-: Unroll error cleanup in nv50_head_create()
In reply to Lyude PaulWe'll be rolling back more things in this function, and the way it's structured is a bit confusing. So, let's clean this up a bit and just unroll in the event of failure.
--- drivers/gpu/drm/nouveau/dispnv50/head.c | 33 +++++++++++++++++-------- 1 file changed, 23 insertions(+), 10 deletions(-)
drivers/gpu/drm/nouveau/dispnv50/head.c +23 -10
@@ -507,20 +507,28 @@ nv50_head_create(struct drm_device *dev, int index)if (disp->disp->object.oclass <GV100_DISP ) { ret =nv50_base_new (drm, head->base.index, &base); +if (ret) + goto fail_free; + ret =nv50_ovly_new (drm, head->base.index, &ovly); +if (ret) + goto fail_free; }else { ret =nv50_wndw_new (drm,DRM_PLANE_TYPE_PRIMARY , head->base.index *2 +0 , &base); +if (ret) + goto fail_free; + ret =nv50_wndw_new (drm,DRM_PLANE_TYPE_OVERLAY , head->base.index *2 +1 , &ovly); - } -if (ret ==0 ) - ret =nv50_curs_new (drm, head->base.index, &curs); -if (ret) { -kfree (head); -return ERR_PTR (ret); +if (ret) + goto fail_free; } + ret =nv50_curs_new (drm, head->base.index, &curs); +if (ret) + goto fail_free; + crtc = &head->base.base;drm_crtc_init_with_planes (dev, crtc, &base->plane, &curs->plane, &nv50_head_func,"head-%d" , head->base.index);
@@ -533,11 +541,16 @@ nv50_head_create(struct drm_device *dev, int index)if (head->func->olut_set) { ret =nv50_lut_init (disp, &drm->client.mmu, &head->olut); -if (ret) { -nv50_head_destroy (crtc); -return ERR_PTR (ret); - } +if (ret) + goto fail_crtc_cleanup; }return head; + +fail_crtc_cleanup: +drm_crtc_cleanup (crtc); +fail_free: +kfree (head); + +return ERR_PTR (ret); }
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 6/12 drm/nouveau/kms/nv140-: Don't modify depth in state during atomic commit
In reply to Lyude PaulCurrently, we modify the depth value stored in the atomic state when performing a commit in order to workaround the fact we haven't implemented support for depths higher then 10 yet. This isn't idempotent though, as it will happen every atomic commit where we modify the OR state even if the head's depth in the atomic state hasn't been modified.
Normally this wouldn't matter, since we don't modify OR state outside of modesets, but since the CRC capture region is implemented as part of the OR state in hardware we'll want to make sure all commits modifying OR state are idempotent so as to avoid changing the depth unexpectedly.
So, fix this by simply not writing the reduced depth value we come up with to the atomic state.
--- drivers/gpu/drm/nouveau/dispnv50/headc37d.c | 11 +++++++---- drivers/gpu/drm/nouveau/dispnv50/headc57d.c | 11 +++++++---- 2 files changed, 14 insertions(+), 8 deletions(-)
drivers/gpu/drm/nouveau/dispnv50/headc37d.c +7 -4
@@ -27,17 +27,20 @@ static void headc37d_or(struct nv50_head *head, struct nv50_head_atom *asyh) { struct nv50_dmac *core = &nv50_disp(head->base.base.dev)->core->chan; +u8 depth;u32 *push; +if ((push =evo_wait (core,2 ))) {/*XXX: This is a dirty hack until OR depth handling is * improved later for deep colour etc. */ switch (asyh->or.depth) { -case 6 : asyh->or.depth =5 ;break ; -case 5 : asyh->or.depth =4 ;break ; -case 2 : asyh->or.depth =1 ;break ; -case 0 : asyh->or.depth =4 ;break ; +case 6 : depth =5 ;break ; +case 5 : depth =4 ;break ; +case 2 : depth =1 ;break ; +case 0 : depth =4 ;break ;default : + depth = asyh->or.depth;WARN_ON (1 );break ; }
drivers/gpu/drm/nouveau/dispnv50/headc57d.c +7 -4
@@ -27,17 +27,20 @@ static void headc57d_or(struct nv50_head *head, struct nv50_head_atom *asyh) { struct nv50_dmac *core = &nv50_disp(head->base.base.dev)->core->chan; +u8 depth;u32 *push; +if ((push =evo_wait (core,2 ))) {/*XXX: This is a dirty hack until OR depth handling is * improved later for deep colour etc. */ switch (asyh->or.depth) { -case 6 : asyh->or.depth =5 ;break ; -case 5 : asyh->or.depth =4 ;break ; -case 2 : asyh->or.depth =1 ;break ; -case 0 : asyh->or.depth =4 ;break ; +case 6 : depth =5 ;break ; +case 5 : depth =4 ;break ; +case 2 : depth =1 ;break ; +case 0 : depth =4 ;break ;default : + depth = asyh->or.depth;WARN_ON (1 );break ; }
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 7/12 drm/nouveau/kms/nv50-: Fix disabling dithering
In reply to Lyude PaulWhile we expose the ability to turn off hardware dithering for nouveau, we actually make the mistake of turning it on anyway, due to dithering_depth containing a non-zero value if our dithering depth isn't also set to 6 bpc.
So, fix it by never enabling dithering when it's disabled.
--- drivers/gpu/drm/nouveau/dispnv50/head.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)
drivers/gpu/drm/nouveau/dispnv50/head.c +13 -11
@@ -84,18 +84,20 @@ nv50_head_atomic_check_dither(struct nv50_head_atom *armh, {u32 mode =0x00 ; -if (asyc->dither.mode ==DITHERING_MODE_AUTO ) { -if (asyh->base.depth > asyh->or.bpc *3 ) - mode =DITHERING_MODE_DYNAMIC2X2 ; - }else { - mode = asyc->dither.mode; - } +if (asyc->dither.mode) { +if (asyc->dither.mode ==DITHERING_MODE_AUTO ) { +if (asyh->base.depth > asyh->or.bpc *3 ) + mode =DITHERING_MODE_DYNAMIC2X2 ; + }else { + mode = asyc->dither.mode; + } -if (asyc->dither.depth ==DITHERING_DEPTH_AUTO ) { -if (asyh->or.bpc >=8 ) - mode |=DITHERING_DEPTH_8BPC ; - }else { - mode |= asyc->dither.depth; +if (asyc->dither.depth ==DITHERING_DEPTH_AUTO ) { +if (asyh->or.bpc >=8 ) + mode |=DITHERING_DEPTH_8BPC ; + }else { + mode |= asyc->dither.depth; + } } asyh->dither.enable = mode;
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 8/12 drm/nouveau/kms/nv50-: s/harm/armh/g
In reply to Lyude PaulWe refer to the armed hardware assembly as armh elsewhere in nouveau, so fix the naming here to make it consistent.
This patch contains no functional changes.
--- drivers/gpu/drm/nouveau/dispnv50/wndw.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/gpu/drm/nouveau/dispnv50/wndw.c +6 -6
@@ -397,7 +397,7 @@ nv50_wndw_atomic_check(struct drm_plane *plane, struct drm_plane_state *state)struct nv50_wndw *wndw =nv50_wndw (plane);struct nv50_wndw_atom *armw =nv50_wndw_atom (wndw->plane.state);struct nv50_wndw_atom *asyw =nv50_wndw_atom (state); -struct nv50_head_atom *harm =NULL , *asyh =NULL ; +struct nv50_head_atom *armh =NULL , *asyh =NULL ;bool modeset = false;int ret;
@@ -418,9 +418,9 @@ nv50_wndw_atomic_check(struct drm_plane *plane, struct drm_plane_state *state)/* Fetch assembly state for the head the window used to belong to. */ if (armw->state.crtc) { - harm =nv50_head_atom_get (asyw->state.state, armw->state.crtc); -if (IS_ERR (harm)) -return PTR_ERR (harm); + armh =nv50_head_atom_get (asyw->state.state, armw->state.crtc); +if (IS_ERR (armh)) +return PTR_ERR (armh); }/* LUT configuration can potentially cause the window to be disabled. */
@@ -444,8 +444,8 @@ nv50_wndw_atomic_check(struct drm_plane *plane, struct drm_plane_state *state) asyh->wndw.mask |=BIT (wndw->id); }else if (armw->visible) { -nv50_wndw_atomic_check_release (wndw, asyw, harm); - harm->wndw.mask &= ~BIT (wndw->id); +nv50_wndw_atomic_check_release (wndw, asyw, armh); + armh->wndw.mask &= ~BIT (wndw->id); }else {return 0 ; }
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 9/12 drm/nouveau/kms/nv140-: Track wndw mappings in nv50_head_atom
In reply to Lyude PaulWhile we're not quite ready yet to add support for flexible wndw mappings, we are going to need to at least keep track of the static wndw mappings we're currently using in each head's atomic state. We'll likely use this in the future to implement real flexible window mapping, but the primary reason we'll need this is for CRC support.
See: on nvidia hardware, each CRC entry in the CRC notifier dma context has a "tag". This tag corresponds to the nth update on a specific EVO/NvDisplay channel, which itself is referred to as the "controlling channel". For gf119+ this can be the core channel, ovly channel, or base channel. Since we don't expose CRC entry tags to userspace, we simply ignore this feature and always use the core channel as the controlling channel. Simple.
Things get a little bit more complicated on gv100+ though. GV100+ only lets us set the controlling channel to a specific wndw channel, and that wndw must be owned by the head that we're grabbing CRCs when we enable CRC generation. Thus, we always need to make sure that each atomic head state has at least one wndw that is mapped to the head, which will be used as the controlling channel.
Note that since we don't have flexible wndw mappings yet, we don't expect to run into any scenarios yet where we'd have a head with no mapped wndws. When we do add support for flexible wndw mappings however, we'll need to make sure that we handle reprogramming CRC capture if our controlling wndw is moved to another head (and potentially reject the new head state entirely if we can't find another available wndw to replace it).
With that being said, nouveau currently tracks wndw visibility on heads. It does not keep track of the actual ownership mappings, which are (currently) statically programmed. To fix this, we introduce another bitmask into nv50_head_atom.wndw to keep track of ownership separately from visibility. We then introduce a nv50_head callback to handle populating the wndw ownership map, and call it during the atomic check phase when core->assign_windows is set to true.
--- drivers/gpu/drm/nouveau/dispnv50/atom.h | 1 + drivers/gpu/drm/nouveau/dispnv50/disp.c | 16 ++++++++++++++++ drivers/gpu/drm/nouveau/dispnv50/head.h | 2 ++ drivers/gpu/drm/nouveau/dispnv50/headc37d.c | 10 ++++++++++ drivers/gpu/drm/nouveau/dispnv50/headc57d.c | 2 ++ 5 files changed, 31 insertions(+)
drivers/gpu/drm/nouveau/dispnv50/atom.h +1 -0
@@ -18,6 +18,7 @@ struct nv50_head_atom {struct {u32 mask; +u32 owned;u32 olut; } wndw;
drivers/gpu/drm/nouveau/dispnv50/disp.c +16 -0
@@ -2254,12 +2254,28 @@ static int nv50_disp_atomic_check(struct drm_device *dev, struct drm_atomic_state *state) { struct nv50_atom *atom = nv50_atom(state); +struct nv50_core *core =nv50_disp (dev)->core;struct drm_connector_state *old_connector_state, *new_connector_state;struct drm_connector *connector;struct drm_crtc_state *new_crtc_state;struct drm_crtc *crtc; +struct nv50_head *head; +struct nv50_head_atom *asyh;int ret, i; +if (core->assign_windows && core->func->head->static_wndw_map) { +drm_for_each_crtc (crtc, dev) { + new_crtc_state =drm_atomic_get_crtc_state (state, + crtc); +if (IS_ERR (new_crtc_state)) +return PTR_ERR (new_crtc_state); + + head =nv50_head (crtc); + asyh =nv50_head_atom (new_crtc_state); + core->func->head->static_wndw_map (head, asyh); + } + } +/* We need to handle colour management on a per-plane basis. */ for_each_new_crtc_in_state (state, crtc, new_crtc_state, i) {if (new_crtc_state->color_mgmt_changed) {
drivers/gpu/drm/nouveau/dispnv50/head.h +2 -0
@@ -40,6 +40,7 @@ struct nv50_head_func {void (*dither)(struct nv50_head *,struct nv50_head_atom *);void (*procamp)(struct nv50_head *,struct nv50_head_atom *);void (*or)(struct nv50_head *,struct nv50_head_atom *); +void (*static_wndw_map)(struct nv50_head *,struct nv50_head_atom *); };extern const struct nv50_head_func head507d;
@@ -86,6 +87,7 @@ int headc37d_curs_format(struct nv50_head *, struct nv50_wndw_atom *,void headc37d_curs_set (struct nv50_head *,struct nv50_head_atom *);void headc37d_curs_clr (struct nv50_head *);void headc37d_dither (struct nv50_head *,struct nv50_head_atom *); +void headc37d_static_wndw_map (struct nv50_head *,struct nv50_head_atom *);extern const struct nv50_head_func headc57d;#endif
drivers/gpu/drm/nouveau/dispnv50/headc37d.c +10 -0
@@ -203,6 +203,15 @@ headc37d_view(struct nv50_head *head, struct nv50_head_atom *asyh) } } +void +headc37d_static_wndw_map (struct nv50_head *head,struct nv50_head_atom *asyh) +{ +int i, end; + +for (i = head->base.index *2 , end = i +2 ; i < end; i++) + asyh->wndw.owned |=BIT (i); +} +const struct nv50_head_func headc37d = { .view = headc37d_view,
@@ -218,4 +227,5 @@ headc37d = { .dither = headc37d_dither, .procamp = headc37d_procamp, .or = headc37d_or, + .static_wndw_map = headc37d_static_wndw_map, };
drivers/gpu/drm/nouveau/dispnv50/headc57d.c +2 -0
@@ -210,4 +210,6 @@ headc57d = { .dither = headc37d_dither, .procamp = headc57d_procamp, .or = headc57d_or, + /* TODO: flexible window mappings */ + .static_wndw_map = headc37d_static_wndw_map, };
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 10/12 drm/nouveau/kms/nv50-: Expose nv50_outp_atom in disp.h
In reply to Lyude PaulIn order to make sure that we flush disable updates at the right time when disabling CRCs, we'll need to be able to look at the outp state to see if we're changing it at the same time that we're disabling CRCs.
So, expose the struct in disp.h.
--- drivers/gpu/drm/nouveau/dispnv50/disp.c | 18 ------------------ drivers/gpu/drm/nouveau/dispnv50/disp.h | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 18 deletions(-)
drivers/gpu/drm/nouveau/dispnv50/disp.c +0 -18
@@ -57,24 +57,6 @@#include <subdev/bios/dp.h> -/****************************************************************************** -* Atomic state -*****************************************************************************/ - -struct nv50_outp_atom { -struct list_head head; - -struct drm_encoder *encoder; -bool flush_disable; - -union nv50_outp_atom_mask { -struct { -bool ctrl:1 ; - }; -u8 mask; - } set, clr; -}; -/****************************************************************************** * EVO channel *****************************************************************************/
drivers/gpu/drm/nouveau/dispnv50/disp.h +14 -0
@@ -70,6 +70,20 @@ struct nv50_dmac {struct mutex lock; }; +struct nv50_outp_atom { +struct list_head head; + +struct drm_encoder *encoder; +bool flush_disable; + +union nv50_outp_atom_mask { +struct { +bool ctrl:1 ; + }; +u8 mask; + } set, clr; +}; +int nv50_dmac_create (struct nvif_device *device,struct nvif_object *disp,const s32 *oclass,u8 head,void *data,u32 size,u64 syncbuf,struct nv50_dmac *dmac);
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 11/12 drm/nouveau/kms/nv50-: Move hard-coded object handles into header
In reply to Lyude PaulWhile most of the functionality on Nvidia GPUs doesn't require using an explicit handle instead of the main VRAM handle + offset, there are a couple of places that do require explicit handles, such as CRC functionality. Since this means we're about to add another nouveau-chosen handle, let's just go ahead and move any hard-coded handles into a single header. This is just to keep things slightly organized, and to make it a little bit easier if we need to add more handles in the future.
This patch should contain no functional changes.
Changes since v3:
* Correct SPDX license identifier (checkpatch)
--- drivers/gpu/drm/nouveau/dispnv50/disp.c | 7 +++++-- drivers/gpu/drm/nouveau/dispnv50/handles.h | 15 +++++++++++++++ drivers/gpu/drm/nouveau/dispnv50/wndw.c | 3 ++- 3 files changed, 22 insertions(+), 3 deletions(-) create mode 100644 drivers/gpu/drm/nouveau/dispnv50/handles.h
drivers/gpu/drm/nouveau/dispnv50/disp.c +5 -2
@@ -26,6 +26,7 @@#include "core.h" #include "head.h" #include "wndw.h" +#include "handles.h" #include <linux/dma-mapping.h> #include <linux/hdmi.h>
@@ -154,7 +155,8 @@ nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp,if (!syncbuf)return 0 ; - ret = nvif_object_init(&dmac->base.user, 0xf0000000, NV_DMA_IN_MEMORY, + ret = nvif_object_init(&dmac->base.user, NV50_DISP_HANDLE_SYNCBUF, + NV_DMA_IN_MEMORY, &(struct nv_dma_v0) { .target = NV_DMA_V0_TARGET_VRAM, .access = NV_DMA_V0_ACCESS_RDWR,
@@ -165,7 +167,8 @@ nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp,if (ret)return ret; - ret = nvif_object_init(&dmac->base.user, 0xf0000001, NV_DMA_IN_MEMORY, + ret = nvif_object_init(&dmac->base.user, NV50_DISP_HANDLE_VRAM, + NV_DMA_IN_MEMORY, &(struct nv_dma_v0) { .target = NV_DMA_V0_TARGET_VRAM, .access = NV_DMA_V0_ACCESS_RDWR,
drivers/gpu/drm/nouveau/dispnv50/handles.h new file +15 -0
@@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +#ifndef __NV50_KMS_HANDLES_H__ +#define __NV50_KMS_HANDLES_H__ + +/* +* Various hard-coded object handles that nouveau uses. These are made-up by +* nouveau developers, not Nvidia. The only significance of the handles chosen +* is that they must all be unique. +*/ +#define NV50_DISP_HANDLE_SYNCBUF 0xf0000000 +#define NV50_DISP_HANDLE_VRAM 0xf0000001 + +#define NV50_DISP_HANDLE_WNDW_CTX (kind) (0xfb000000 | kind) + +#endif /* !__NV50_KMS_HANDLES_H__ */
drivers/gpu/drm/nouveau/dispnv50/wndw.c +2 -1
@@ -21,6 +21,7 @@*/ #include "wndw.h" #include "wimm.h" +#include "handles.h" #include <nvif/class.h> #include <nvif/cl0002.h>
@@ -44,7 +45,7 @@ nv50_wndw_ctxdma_new(struct nv50_wndw *wndw, struct nouveau_framebuffer *fb)struct nouveau_drm *drm =nouveau_drm (fb->base.dev);struct nv50_wndw_ctxdma *ctxdma;const u8 kind = fb->nvbo->kind; -const u32 handle =0xfb000000 | kind; +const u32 handle =NV50_DISP_HANDLE_WNDW_CTX (kind); struct { struct nv_dma_v0 base; union {
Signature · 1 line
2.25.4
Lyude Paul
maintainerRFC v4 12/12 drm/nouveau/kms/nvd9-: Add CRC support
In reply to Lyude PaulThis introduces support for CRC readback on gf119+, using the documentation generously provided to us by Nvidia:
https://github.com/NVIDIA/open-gpu-doc/blob/master/Display-CRC/display-crc.txt
We expose all available CRC sources. SF, SOR, PIOR, and DAC are exposed through a single set of "outp" sources: outp-active/auto for a CRC of the scanout region, outp-complete for a CRC of both the scanout and blanking/sync region combined, and outp-inactive for a CRC of only the blanking/sync region. For each source, nouveau selects the appropriate tap point based on the output path in use. We also expose an "rg" source, which allows for capturing CRCs of the scanout raster before it's encoded into a video signal in the output path. This tap point is referred to as the raster generator.
Note that while there's some other neat features that can be used with CRC capture on nvidia hardware, like capturing from two CRC sources simultaneously, I couldn't see any usecase for them and did not implement them.
Nvidia only allows for accessing CRCs through a shared DMA region that we program through the core EVO/NvDisplay channel which is referred to as the notifier context. The notifier context is limited to either 255 (for Fermi-Pascal) or 2047 (Volta+) entries to store CRCs in, and unfortunately the hardware simply drops CRCs and reports an overflow once all available entries in the notifier context are filled.
Since the DRM CRC API and igt-gpu-tools don't expect there to be a limit on how many CRCs can be captured, we work around this in nouveau by allocating two separate notifier contexts for each head instead of one. We schedule a vblank worker ahead of time so that once we start getting close to filling up all of the available entries in the notifier context, we can swap the currently used notifier context out with another pre-prepared notifier context in a manner similar to page flipping.
Unfortunately, the hardware only allows us to this by flushing two separate updates on the core channel: one to release the current notifier context handle, and one to program the next notifier context's handle. When the hardware processes the first update, the CRC for the current frame is lost. However, the second update can be flushed immediately without waiting for the first to complete so that CRC generation resumes on the next frame. According to Nvidia's hardware engineers, there isn't any cleaner way of flipping notifier contexts that would avoid this.
Since using vblank workers to swap out the notifier context will ensure we can usually flush both updates to hardware within the timespan of a single frame, we can also ensure that there will only be exactly one frame lost between the first and second update being executed by the hardware. This gives us the guarantee that we're always correctly matching each CRC entry with it's respective frame even after a context flip. And since IGT will retrieve the CRC entry for a frame by waiting until it receives a CRC for any subsequent frames, this doesn't cause an issue with any tests and is much simpler than trying to change the current DRM API to accommodate.
In order to facilitate testing of correct handling of this limitation, we also expose a debugfs interface to manually control the threshold for when we start trying to flip the notifier context. We will use this in igt to trigger a context flip for testing purposes without needing to wait for the notifier to completely fill up. This threshold is reset to the default value set by nouveau after each capture, and is exposed in a separate folder within each CRTC's debugfs directory labelled "nv_crc".
Changes since v1:
* Forgot to finish saving crc.h before saving, whoops. This just adds some corrections to the empty function declarations that we use if CONFIG_DEBUG_FS isn't enabled.
Changes since v2:
* Don't check return code from debugfs_create_dir() or debugfs_create_file() - Greg K-H
Changes since v3:
(no functional changes)
* Fix SPDX license identifiers (checkpatch)
* s/uint32_t/u32/ (checkpatch)
* Fix indenting in switch cases (checkpatch)
--- drivers/gpu/drm/nouveau/dispnv04/crtc.c | 25 +- drivers/gpu/drm/nouveau/dispnv50/Kbuild | 4 + drivers/gpu/drm/nouveau/dispnv50/atom.h | 20 + drivers/gpu/drm/nouveau/dispnv50/core.h | 4 + drivers/gpu/drm/nouveau/dispnv50/core907d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/core917d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/corec37d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/corec57d.c | 3 + drivers/gpu/drm/nouveau/dispnv50/crc.c | 715 ++++++++++++++++++++ drivers/gpu/drm/nouveau/dispnv50/crc.h | 125 ++++ drivers/gpu/drm/nouveau/dispnv50/crc907d.c | 139 ++++ drivers/gpu/drm/nouveau/dispnv50/crcc37d.c | 153 +++++ drivers/gpu/drm/nouveau/dispnv50/disp.c | 24 +- drivers/gpu/drm/nouveau/dispnv50/disp.h | 10 + drivers/gpu/drm/nouveau/dispnv50/handles.h | 1 + drivers/gpu/drm/nouveau/dispnv50/head.c | 85 ++- drivers/gpu/drm/nouveau/dispnv50/head.h | 11 +- drivers/gpu/drm/nouveau/dispnv50/head907d.c | 14 +- drivers/gpu/drm/nouveau/dispnv50/headc37d.c | 6 +- drivers/gpu/drm/nouveau/dispnv50/headc57d.c | 7 +- drivers/gpu/drm/nouveau/nouveau_display.c | 60 +- 21 files changed, 1341 insertions(+), 74 deletions(-) create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc.c create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc.h create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crc907d.c create mode 100644 drivers/gpu/drm/nouveau/dispnv50/crcc37d.c
drivers/gpu/drm/nouveau/dispnv04/crtc.c +24 -1
@@ -44,6 +44,9 @@#include <subdev/bios/pll.h> #include <subdev/clk.h> +#include <nvif/event.h> +#include <nvif/cl0046.h> +static int nv04_crtc_mode_set_base (struct drm_crtc *crtc,int x,int y,struct drm_framebuffer *old_fb);
@@ -755,6 +758,7 @@ static void nv_crtc_destroy(struct drm_crtc *crtc)nouveau_bo_unmap (nv_crtc->cursor.nvbo);nouveau_bo_unpin (nv_crtc->cursor.nvbo);nouveau_bo_ref (NULL , &nv_crtc->cursor.nvbo); +nvif_notify_fini (&nv_crtc->vblank);kfree (nv_crtc); }
@@ -1296,9 +1300,19 @@ create_primary_plane(struct drm_device *dev)return primary; } +static int nv04_crtc_vblank_handler (struct nvif_notify *notify) +{ +struct nouveau_crtc *nv_crtc = + container_of(notify, struct nouveau_crtc, vblank); + +drm_crtc_handle_vblank (&nv_crtc->base); +return NVIF_NOTIFY_KEEP ; +} +int nv04_crtc_create (struct drm_device *dev,int crtc_num) { +struct nouveau_display *disp =nouveau_display (dev);struct nouveau_crtc *nv_crtc;int ret;
@@ -1336,5 +1350,14 @@ nv04_crtc_create(struct drm_device *dev, int crtc_num)nv04_cursor_init (nv_crtc); -return 0 ; + ret =nvif_notify_init (&disp->disp.object, nv04_crtc_vblank_handler, + false,NV04_DISP_NTFY_VBLANK , + &(struct nvif_notify_head_req_v0 ) { + .head = nv_crtc->index, + }, +sizeof (struct nvif_notify_head_req_v0 ), +sizeof (struct nvif_notify_head_rep_v0 ), + &nv_crtc->vblank); + +return ret; }
drivers/gpu/drm/nouveau/dispnv50/Kbuild +4 -0
@@ -10,6 +10,10 @@ nouveau-y += dispnv50/core917d.o nouveau-y += dispnv50/corec37d.o nouveau-y += dispnv50/corec57d.o +nouveau-$(CONFIG_DEBUG_FS) += dispnv50/crc.o +nouveau-$(CONFIG_DEBUG_FS) += dispnv50/crc907d.o +nouveau-$(CONFIG_DEBUG_FS) += dispnv50/crcc37d.o + nouveau-y += dispnv50/dac507d.o nouveau-y += dispnv50/dac907d.o
drivers/gpu/drm/nouveau/dispnv50/atom.h +20 -0
@@ -2,6 +2,9 @@#define __NV50_KMS_ATOM_H__#define nv50_atom (p) container_of((p), struct nv50_atom, state)#include <drm/drm_atomic.h> +#include "crc.h" + +struct nouveau_encoder ;struct nv50_atom {struct drm_atomic_state state;
@@ -115,9 +118,12 @@ struct nv50_head_atom { u8 nhsync:1; u8 nvsync:1; u8 depth:4; + u8 crc_raster:2;u8 bpc; } or; +struct nv50_crc_atom crc; +/* Currently only used for MST */ struct {int pbn;
@@ -135,6 +141,7 @@ struct nv50_head_atom { bool ovly:1; bool dither:1; bool procamp:1; + bool crc:1; bool or:1; };u16 mask;
@@ -150,6 +157,19 @@ nv50_head_atom_get(struct drm_atomic_state *state, struct drm_crtc *crtc)return nv50_head_atom (statec); } +static inline struct drm_encoder * +nv50_head_atom_get_encoder (struct nv50_head_atom *atom) +{ +struct drm_encoder *encoder =NULL ; + +/* We only ever have a single encoder */ +drm_for_each_encoder_mask (encoder, atom->state.crtc->dev, + atom->state.encoder_mask) +break ; + +return encoder; +} +#define nv50_wndw_atom (p) container_of((p), struct nv50_wndw_atom, state)struct nv50_wndw_atom {
drivers/gpu/drm/nouveau/dispnv50/core.h +4 -0
@@ -2,6 +2,7 @@#define __NV50_KMS_CORE_H__#include "disp.h" #include "atom.h" +#include "crc.h" struct nv50_core {const struct nv50_core_func *func;
@@ -24,6 +25,9 @@ struct nv50_core_func { } wndw;const struct nv50_head_func *head; +#if IS_ENABLED (CONFIG_DEBUG_FS ) +const struct nv50_crc_func *crc; +#endif const struct nv50_outp_func { void (*ctrl)(struct nv50_core *, int or, u32 ctrl, struct nv50_head_atom *);
drivers/gpu/drm/nouveau/dispnv50/core907d.c +3 -0
@@ -29,6 +29,9 @@ core907d = { .ntfy_wait_done = core507d_ntfy_wait_done, .update = core507d_update, .head = &head907d, +#if IS_ENABLED(CONFIG_DEBUG_FS) + .crc = &crc907d, +#endif .dac = &dac907d, .sor = &sor907d, };
drivers/gpu/drm/nouveau/dispnv50/core917d.c +3 -0
@@ -29,6 +29,9 @@ core917d = { .ntfy_wait_done = core507d_ntfy_wait_done, .update = core507d_update, .head = &head917d, +#if IS_ENABLED(CONFIG_DEBUG_FS) + .crc = &crc907d, +#endif .dac = &dac907d, .sor = &sor907d, };
drivers/gpu/drm/nouveau/dispnv50/corec37d.c +3 -0
@@ -116,6 +116,9 @@ corec37d = { .wndw.owner = corec37d_wndw_owner, .head = &headc37d, .sor = &sorc37d, +#if IS_ENABLED (CONFIG_DEBUG_FS ) + .crc = &crcc37d, +#endif };int
drivers/gpu/drm/nouveau/dispnv50/corec57d.c +3 -0
@@ -51,6 +51,9 @@ corec57d = { .wndw.owner = corec37d_wndw_owner, .head = &headc57d, .sor = &sorc37d, +#if IS_ENABLED (CONFIG_DEBUG_FS ) + .crc = &crcc37d, +#endif };int
drivers/gpu/drm/nouveau/dispnv50/crc.c new file +715 -0
715 lines not on this page · raw message
drivers/gpu/drm/nouveau/dispnv50/crc.h new file +125 -0
125 lines not on this page · raw message
drivers/gpu/drm/nouveau/dispnv50/crc907d.c new file +139 -0
139 lines not on this page · raw message
drivers/gpu/drm/nouveau/dispnv50/crcc37d.c new file +153 -0
153 lines not on this page · raw message
drivers/gpu/drm/nouveau/dispnv50/disp.c +22 -2
@@ -776,6 +776,19 @@ struct nv50_msto {bool disabled; }; +struct nouveau_encoder *nv50_real_outp (struct drm_encoder *encoder) +{ +struct nv50_msto *msto; + +if (encoder->encoder_type !=DRM_MODE_ENCODER_DPMST ) +return nouveau_encoder (encoder); + + msto =nv50_msto (encoder); +if (!msto->mstc) +return NULL ; +return msto->mstc->mstm->outp; +} +static struct drm_dp_payload *nv50_msto_payload (struct nv50_msto *msto) {
@@ -1899,6 +1912,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state)int i;NV_ATOMIC (drm,"commit %d %d\n" , atom->lock_core, atom->flush_disable); +nv50_crc_atomic_stop_reporting (state);drm_atomic_helper_wait_for_fences (dev, state, false);drm_atomic_helper_wait_for_dependencies (state);drm_atomic_helper_update_legacy_modeset_state (dev, state);
@@ -1908,6 +1922,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state)/* Disable head(s). */ for_each_oldnew_crtc_in_state (state, crtc, old_crtc_state, new_crtc_state, i) { +struct nv50_head_atom *armh =nv50_head_atom (old_crtc_state);struct nv50_head_atom *asyh =nv50_head_atom (new_crtc_state);struct nv50_head *head =nv50_head (crtc);
@@ -1920,7 +1935,8 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state) }if (asyh->clr.mask) { -nv50_head_flush_clr (head, asyh, atom->flush_disable); +nv50_head_flush_clr (head, armh, asyh, + atom->flush_disable); interlock[NV50_DISP_INTERLOCK_CORE ] |=1 ; } }
@@ -1969,6 +1985,8 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state) } } +nv50_crc_atomic_prepare_notifier_contexts (state); +/* Update output path(s). */ list_for_each_entry_safe (outp, outt, &atom->outp, head) {const struct drm_encoder_helper_funcs *help;
@@ -1991,6 +2009,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state)/* Update head(s). */ for_each_oldnew_crtc_in_state (state, crtc, old_crtc_state, new_crtc_state, i) { +struct nv50_head_atom *armh =nv50_head_atom (old_crtc_state);struct nv50_head_atom *asyh =nv50_head_atom (new_crtc_state);struct nv50_head *head =nv50_head (crtc);
@@ -1998,7 +2017,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state) asyh->set.mask, asyh->clr.mask);if (asyh->set.mask) { -nv50_head_flush_set (head, asyh); +nv50_head_flush_set (head, armh, asyh); interlock[NV50_DISP_INTERLOCK_CORE ] =1 ; }
@@ -2082,6 +2101,7 @@ nv50_disp_atomic_commit_tail(struct drm_atomic_state *state) } } +nv50_crc_atomic_start_reporting (state);drm_atomic_helper_commit_hw_done (state);drm_atomic_helper_cleanup_planes (dev, state);drm_atomic_helper_commit_cleanup_done (state);
drivers/gpu/drm/nouveau/dispnv50/disp.h +10 -0
@@ -1,10 +1,12 @@ #ifndef __NV50_KMS_H__ #define __NV50_KMS_H__ +#include <linux/workqueue.h> #include <nvif/mem.h> #include "nouveau_display.h" struct nv50_msto; +struct nouveau_encoder; struct nv50_disp { struct nvif_disp *disp;
@@ -89,6 +91,14 @@ int nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp, u64 syncbuf, struct nv50_dmac *dmac);void nv50_dmac_destroy (struct nv50_dmac *); +/* +* For normal encoders this just returns the encoder. For active MST encoders, +* this returns the real outp that's driving displays on the topology. +* Inactive MST encoders return NULL, since they would have no real outp to +* return anyway. +*/ +struct nouveau_encoder *nv50_real_outp (struct drm_encoder *encoder); +u32 *evo_wait (struct nv50_dmac *,int nr);void evo_kick (u32 *,struct nv50_dmac *);
drivers/gpu/drm/nouveau/dispnv50/handles.h +1 -0
@@ -11,5 +11,6 @@#define NV50_DISP_HANDLE_VRAM 0xf0000001#define NV50_DISP_HANDLE_WNDW_CTX (kind) (0xfb000000 | kind) +#define NV50_DISP_HANDLE_CRC_CTX (head, i) (0xfc000000 | head->base.index << 1 | i)#endif /* !__NV50_KMS_HANDLES_H__ */
drivers/gpu/drm/nouveau/dispnv50/head.c +80 -5
180 lines not on this page · raw message
drivers/gpu/drm/nouveau/dispnv50/head.h +9 -2
@@ -1,22 +1,29 @@ #ifndef __NV50_KMS_HEAD_H__ #define __NV50_KMS_HEAD_H__ #define nv50_head(c) container_of((c), struct nv50_head, base.base) +#include <linux/workqueue.h> + #include "disp.h" #include "atom.h" +#include "crc.h" #include "lut.h" #include "nouveau_crtc.h" +#include "nouveau_encoder.h" struct nv50_head { const struct nv50_head_func *func; struct nouveau_crtc base; + struct nv50_crc crc; struct nv50_lut olut; struct nv50_msto *msto; }; struct nv50_head *nv50_head_create(struct drm_device *, int index); -void nv50_head_flush_set(struct nv50_head *, struct nv50_head_atom *); -void nv50_head_flush_clr(struct nv50_head *, struct nv50_head_atom *, bool y); +void nv50_head_flush_set(struct nv50_head *, struct nv50_head_atom *armh, + struct nv50_head_atom *asyh); +void nv50_head_flush_clr(struct nv50_head *, struct nv50_head_atom *armh, + struct nv50_head_atom *asyh, bool y); struct nv50_head_func { void (*view)(struct nv50_head *, struct nv50_head_atom *);
drivers/gpu/drm/nouveau/dispnv50/head907d.c +11 -3
@@ -19,8 +19,15 @@* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ +#include <drm/drm_connector.h> +#include <drm/drm_mode_config.h> +#include <drm/drm_vblank.h> +#include "nouveau_drv.h" +#include "nouveau_bios.h" +#include "nouveau_connector.h" #include "head.h" #include "core.h" +#include "crc.h" void head907d_or (struct nv50_head *head,struct nv50_head_atom *asyh)
@@ -29,9 +36,10 @@ head907d_or(struct nv50_head *head, struct nv50_head_atom *asyh)u32 *push;if ((push =evo_wait (core,3 ))) {evo_mthd (push,0x0404 + (head->base.index *0x300 ),2 ); -evo_data (push,0x00000001 | asyh->or.depth <<6 | - asyh->or.nvsync <<4 | - asyh->or.nhsync <<3 ); +evo_data (push, asyh->or.depth <<6 | + asyh->or.nvsync <<4 | + asyh->or.nhsync <<3 | + asyh->or.crc_raster);evo_data (push,0x31ec6000 | head->base.index <<25 | asyh->mode.interlace);evo_kick (push, core);
drivers/gpu/drm/nouveau/dispnv50/headc37d.c +3 -3
@@ -46,10 +46,10 @@ headc37d_or(struct nv50_head *head, struct nv50_head_atom *asyh) }evo_mthd (push,0x2004 + (head->base.index *0x400 ),1 ); -evo_data (push,0x00000001 | - asyh->or.depth <<4 | +evo_data (push, depth <<4 | asyh->or.nvsync <<3 | - asyh->or.nhsync <<2 ); + asyh->or.nhsync <<2 | + asyh->or.crc_raster);evo_kick (push, core); } }
drivers/gpu/drm/nouveau/dispnv50/headc57d.c +4 -3
@@ -46,10 +46,11 @@ headc57d_or(struct nv50_head *head, struct nv50_head_atom *asyh) }evo_mthd (push,0x2004 + (head->base.index *0x400 ),1 ); -evo_data (push,0xfc000001 | - asyh->or.depth <<4 | +evo_data (push,0xfc000000 | + depth <<4 | asyh->or.nvsync <<3 | - asyh->or.nhsync <<2 ); + asyh->or.nhsync <<2 | + asyh->or.crc_raster);evo_kick (push, core); } }
drivers/gpu/drm/nouveau/nouveau_display.c +5 -55
86 lines not on this page · raw message
Signature · 1 line
2.25.4
Re: [RFC v4 03/12] drm/vblank: Register drmm cleanup action once per drm_vblank_crtc
In reply to Lyude PaulQuoted 7 lines · Lyude Paul
Since we'll be allocating resources for
kthread_create_worker()in the next commit (which could fail and require us to clean up the mess), let's simplify the cleanup process a bit by registering adrm_vblank_init_release()action for eachdrm_vblank_crtcso they're still cleaned up if we fail to initialize one of them.
Quoted 8 lines
Changes since v3:
* Usedrmm_add_action_or_reset()- Daniel VetterCc Daniel Vetter <[email protected]>Cc Ville Syrjälä <[email protected]>Signed-off-by Lyude Paul <[email protected]>
I think the other patches need a brain that's less in w/e mode :-)
Cheers, Daniel
Quoted 64 lines
--- drivers/gpu/drm/drm_vblank.c | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-)drivers/gpu/drm/drm_vblank.c +10
-14@@ -491,16 +491,12 @@ static void vblank_disable_fn(struct timer_list *t)static void drm_vblank_init_release (struct drm_device *dev,void *ptr) { -unsigned int pipe; - -for (pipe =0 ; pipe < dev->num_crtcs; pipe++) { -struct drm_vblank_crtc *vblank = &dev->vblank[pipe]; +struct drm_vblank_crtc *vblank = ptr; -WARN_ON (READ_ONCE (vblank->enabled) && -drm_core_check_feature (dev,DRIVER_MODESET )); +WARN_ON (READ_ONCE (vblank->enabled) && +drm_core_check_feature (dev,DRIVER_MODESET )); -del_timer_sync (&vblank->disable_timer); - } +del_timer_sync (&vblank->disable_timer); }/** @@ -510,7 +506,7 @@ static void drm_vblank_init_release(struct drm_device *dev, void *ptr)* * This function initializes vblank support for @num_crtcs display pipelines. * Cleanup is handled automatically through a cleanup function added with -* drmm_add_action(). +* drmm_add_action_or_reset(). * * Returns: * Zero on success or a negative error code on failure. @@ -529,10 +525,6 @@ int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs) dev->num_crtcs = num_crtcs; - ret =drmm_add_action (dev, drm_vblank_init_release,NULL ); -if (ret) -return ret; -for (i =0 ; i < num_crtcs; i++) {struct drm_vblank_crtc *vblank = &dev->vblank[i];@@ -541,6 +533,11 @@ int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs)init_waitqueue_head (&vblank->queue);timer_setup (&vblank->disable_timer, vblank_disable_fn,0 );seqlock_init (&vblank->seqlock); + + ret =drmm_add_action_or_reset (dev, drm_vblank_init_release, + vblank); +if (ret) +return ret; }DRM_INFO ("Supports vblank timestamp caching Rev 2 (21.10.2013).\n" ); --2.25.4
Signature · 3 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch
kbuild test robot
build botRe: [RFC v4 01/12] kthread: Add kthread_queue_flush_work()
In reply to Lyude Paul[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please…
Hi Lyude,
[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on drm-exynos/exynos-drm-next]
[also build test ERROR on drm-intel/for-linux-next tegra-drm/drm/tegra/for-next drm-tip/drm-tip linus/master v5.7-rc4 next-20200508] [if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Lyude-Paul/drm-nouveau-Introduce-CRC-support-for-gf119/20200509-083258 base: https://git.kernel.org/pub/scm/linux/kernel/git/daeinki/drm-exynos.git exynos-drm-next config: microblaze-randconfig-r001-20200509 (attached as .config) compiler: microblaze-linux-gcc (GCC) 9.3.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day GCC_VERSION=9.3.0 make.cross ARCH=microblaze
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
In file included from drivers/usb/c67x00/c67x00-sched.c:10:
>> include/linux/kthread.h:110:20: error: field 'done' has incomplete type
110 | struct completion done;
| ^~~~vim +/done +110 include/linux/kthread.h
107
108 struct kthread_flush_work {
109 struct kthread_work work;
> 110 struct completion done;
111 };
112
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kbuild test robot
build botRe: [RFC v4 04/12] drm/vblank: Add vblank works
In reply to Lyude Paul[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please…
Hi Lyude,
[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on drm-exynos/exynos-drm-next]
[also build test ERROR on drm-tip/drm-tip]
[cannot apply to drm-intel/for-linux-next tegra-drm/drm/tegra/for-next linus/master drm/drm-next v5.7-rc4 next-20200508] [if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Lyude-Paul/drm-nouveau-Introduce-CRC-support-for-gf119/20200509-083258 base: https://git.kernel.org/pub/scm/linux/kernel/git/daeinki/drm-exynos.git exynos-drm-next config: x86_64-randconfig-a004-20200510 (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 68a9356bdea69dbcec1233f8b1fab47e72fca991)
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:177:1: warning: array index 2 is past the end of the array (which contains 1 element) [-Warray-bounds] _SIG_SET_OP(signotset, _sig_not)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/signal.h:165:3: note: expanded from macro '_SIG_SET_OP'
set->sig[2] = op(set->sig[2]); \
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:177:1: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
_SIG_SET_OP(signotset, _sig_not)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/signal.h:167:27: note: expanded from macro '_SIG_SET_OP'
case 2: set->sig[1] = op(set->sig[1]); \
^ ~
include/linux/signal.h:176:24: note: expanded from macro '_sig_not'
#define _sig_not(x) (~(x))
^
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:177:1: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
_SIG_SET_OP(signotset, _sig_not)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/signal.h:167:10: note: expanded from macro '_SIG_SET_OP'
case 2: set->sig[1] = op(set->sig[1]); \
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:188:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
case 2: set->sig[1] = 0;
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:201:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
case 2: set->sig[1] = -1;
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:232:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
case 2: set->sig[1] = 0;
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
In file included from drivers/gpu/drm/drm_vblank.c:32:
In file included from include/drm/drm_crtc.h:31:
In file included from include/linux/fb.h:10:
In file included from include/linux/fs.h:34:
In file included from include/linux/percpu-rwsem.h:7:
In file included from include/linux/rcuwait.h:6:
In file included from include/linux/sched/signal.h:6:
include/linux/signal.h:244:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
case 2: set->sig[1] = -1;
^ ~
arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here
unsigned long sig[_NSIG_WORDS];
^
>> drivers/gpu/drm/drm_vblank.c:2376:2: error: indirection requires pointer operand ('void' invalid)
DEFINE_KTHREAD_FLUSH_WORK(fwork);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/kthread.h:146:36: note: expanded from macro 'DEFINE_KTHREAD_FLUSH_WORK'
struct kthread_flush_work fwork = KTHREAD_FLUSH_WORK_INIT(fwork);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/kthread.h:132:2: note: expanded from macro 'KTHREAD_FLUSH_WORK_INIT'
COMPLETION_INITIALIZER_ONSTACK((fwork).done), \
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/completion.h:43:3: note: expanded from macro 'COMPLETION_INITIALIZER_ONSTACK'
(*({ init_completion(&work); &work; }))
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~49 warnings and 2 errors generated.
vim +2376 drivers/gpu/drm/drm_vblank.c
2364
2365 /**
2366 * drm_vblank_work_flush - wait for a scheduled vblank work to finish
2367 * executing
2368 * @work: vblank work to flush
2369 *
2370 * Wait until @work has finished executing once.
2371 */
2372 void drm_vblank_work_flush(struct drm_vblank_work *work)
2373 {
2374 struct drm_vblank_crtc *vblank = work->vblank;
2375 bool scheduled;
> 2376 DEFINE_KTHREAD_FLUSH_WORK(fwork);
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [RFC v4 01/12] kthread: Add kthread_queue_flush_work()
In reply to Lyude PaulHello,
include/linux/kthread.h bool kthread_mod_delayed_work(struct kthread_worker *worker, · line 208
Quoted 3 lines · Lyude Paul
include/linux/kthread.h +3
-0+bool kthread_queue_flush_work (struct kthread_work *work, +struct kthread_flush_work *fwork); +void __kthread_flush_work_fn (struct kthread_work *work);
As an exposed interface, this doesn't seem great. What the user wants to say is "wait for the current instance of this guy" and the interface is asking them to queue an extra work item whose queueing return state should be checked and depending on that result wait on its internal completion.
I'm skeptical this is a good idea in general given that unless you define "this instance" at the time of queueing the work item which is being waited-upon, there's no way to guarantee that the instance you're queueing the flush work item on is the instance you want unless the queuer is holding external synchronization which prevents the instance from running. That's a really confusing semantics to expose in the interface.
What the above means is that the ordering that you want is only defined through your own locking and that maybe suggests that the sequencing should be implemented on that side too. It may be a bit more code but a sequence counter + wait queue might be the better solution here.
Thanks.
Signature · 1 line
tejun
Re: [RFC v4 02/12] kthread: Add kthread_(un)block_work_queuing() and kthread_work_queuable()
In reply to Lyude PaulQuoted 4 lines · Lyude Paul
Add some simple wrappers around incrementing/decrementing kthread_work.cancelling under lock, along with checking whether queuing is currently allowed on a given
kthread_work, which we'll use want to implement work cancelling with DRM's vblank work helpers.
Am I correct in assuming that what you want is "cancel this and block further queueing until the state is cleared"? I agree that'd be something really useful to have. That said, There are a few areas that I think can be improved upon:
* It'd be better if we separate this state into its own thing rather than mixing with canceling state which has potential to make things really confusing. It doesn't have to be a separate field unless you want disable depth for work item disable (and I don't think you do). It can just be a high bit in the same field but I think the two states should be separate one way or the other.
* I'm always a bit skeptical about state querying interfaces which aren't synchronized to anything. They're useful in many cases but also prone to being misused. If you absoultely have to have them, can you please add explicit comment explaining the lack of synchronization around it - ie. unless you're the one setting and clearing the flag and queueing the task, it isn't synchronized against anything.
* In the same vein, I'm not too sure about stand-alone block interface. Unless I'm the sole queuer or there are further locking around queueing, what good does setting blocking do? There's no way to guarantee that the flag is seen by someone else trying to queue it and trying to flush the work item after queueing doesn't help either. The only way to make that interface meaningful is doing it together with cancel - so, you say "block further queueing and cancel / flush whatever is in flight or queued", which actually gives you a useful invariant.
* A simliar argument can be made about unblock too although that's an a lot more relaxed situation in that unblocking and queueing oneself always works and that the user might not care which future instance of queueing will start succeeding.
Thanks.
Signature · 1 line
tejun
Re: [RFC v4 01/12] kthread: Add kthread_queue_flush_work()
In reply to Tejun HeoQuoted 20 lines · Tejun Heo
Hello,
include/linux/kthread.h bool kthread_mod_delayed_work(struct kthread_worker *worker, · line 208
Quoted 3 lines · Lyude Paul
include/linux/kthread.h +3
-0+bool kthread_queue_flush_work (struct kthread_work *work, +struct kthread_flush_work *fwork); +void __kthread_flush_work_fn (struct kthread_work *work);As an exposed interface, this doesn't seem great. What the user wants to say is "wait for the current instance of this guy" and the interface is asking them to queue an extra work item whose queueing return state should be checked and depending on that result wait on its internal completion.
I'm skeptical this is a good idea in general given that unless you define "this instance" at the time of queueing the work item which is being waited-upon, there's no way to guarantee that the instance you're queueing the flush work item on is the instance you want unless the queuer is holding external synchronization which prevents the instance from running. That's a really confusing semantics to expose in the interface.
Quoted 4 lines
What the above means is that the ordering that you want is only defined through your own locking and that maybe suggests that the sequencing should be implemented on that side too. It may be a bit more code but a sequence counter + wait queue might be the better solution here.
Aside from this, flush_$stuff interfaces are very easy to deadlock. That's why e.g. flush_work() for normal workqueues has lockdep annotations (lockdep doesn't see through wait/wake_up dependencies without some help because cross-release didn't land for real). So I think if we need something like this, it needs to be a lot more explicit, and come with the right lockdep annotations. -Daniel
Signature · 3 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch
Re: [RFC v4 04/12] drm/vblank: Add vblank works
In reply to kbuild test robotHi Lyude,
Sorry for the noise. This report is unrelated to your patch. It has to do with Clang validating dead code. At least now we have a randconfig to reliably reproduce.
Quoted 166 lines · kbuild test robot
Hi Lyude,
[FYI, it's a private test report for your RFC patch.]
[auto build test ERROR on drm-exynos/exynos-drm-next]
[also build test ERROR on drm-tip/drm-tip]
[cannot apply to drm-intel/for-linux-next tegra-drm/drm/tegra/for-next linus/master drm/drm-next v5.7-rc4 next-20200508] [if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]url: https://github.com/0day-ci/linux/commits/Lyude-Paul/drm-nouveau-Introduce-CRC-support-for-gf119/20200509-083258 base: https://git.kernel.org/pub/scm/linux/kernel/git/daeinki/drm-exynos.git exynos-drm-next config: x86_64-randconfig-a004-20200510 (attached as .config) compiler: clang version 11.0.0 (https://github.com/llvm/llvm-project 68a9356bdea69dbcec1233f8b1fab47e72fca991)reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# installx86_64cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64If you fix the issue, kindly add following tag as appropriate
Reported-by kbuild test robot <[email protected]>All errors (new ones prefixed by >>):
In file included from
include/linux/fs.h:34:
In file included frominclude/linux/percpu-rwsem.h:7:
In file included frominclude/linux/rcuwait.h:6:
In file included frominclude/linux/sched/signal.h:6:
include/linux/signal.h:177:1: warning: array index 2 is past the end of the array (which contains 1 element) [-Warray-bounds]_SIG_SET_OP(signotset, _sig_not)
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/signal.h:165:3: note: expanded from macro '_SIG_SET_OP'set->sig[2] = op(set->sig[2]); \ ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:177:1: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] _SIG_SET_OP(signotset, _sig_not) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/signal.h:167:27: note: expanded from macro '_SIG_SET_OP' case 2: set->sig[1] = op(set->sig[1]); \ ^ ~ include/linux/signal.h:176:24: note: expanded from macro '_sig_not' #define _sig_not(x) (~(x)) ^ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:177:1: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] _SIG_SET_OP(signotset, _sig_not) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/signal.h:167:10: note: expanded from macro '_SIG_SET_OP' case 2: set->sig[1] = op(set->sig[1]); \ ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:188:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] case 2: set->sig[1] = 0; ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:201:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] case 2: set->sig[1] = -1; ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:232:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] case 2: set->sig[1] = 0; ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^ In file included from drivers/gpu/drm/drm_vblank.c:32: In file included from include/drm/drm_crtc.h:31: In file included from include/linux/fb.h:10: In file included from include/linux/fs.h:34: In file included from include/linux/percpu-rwsem.h:7: In file included from include/linux/rcuwait.h:6: In file included from include/linux/sched/signal.h:6: include/linux/signal.h:244:10: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds] case 2: set->sig[1] = -1; ^ ~ arch/x86/include/asm/signal.h:24:2: note: array 'sig' declared here unsigned long sig[_NSIG_WORDS]; ^Quoted 1 line
Quoted 1 line
drivers/gpu/drm/drm_vblank.c:2376:2: error: indirection requires pointer operand ('void' invalid)DEFINE_KTHREAD_FLUSH_WORK(fwork); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/kthread.h:146:36: note: expanded from macro 'DEFINE_KTHREAD_FLUSH_WORK' struct kthread_flush_work fwork = KTHREAD_FLUSH_WORK_INIT(fwork); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/kthread.h:132:2: note: expanded from macro 'KTHREAD_FLUSH_WORK_INIT' COMPLETION_INITIALIZER_ONSTACK((fwork).done), \ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/completion.h:43:3: note: expanded from macro 'COMPLETION_INITIALIZER_ONSTACK' (*({ init_completion(&work); &work; })) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~49 warnings and 2 errors generated.
vim +2376
drivers/gpu/drm/drm_vblank.c2364
2365 /**2366 * drm_vblank_work_flush - wait for a scheduled vblank work to finish 2367 * executing 2368 * @work: vblank work to flush 2369 * 2370 * Wait until @work has finished executing once. 2371 */ 2372 void drm_vblank_work_flush(struct drm_vblank_work *work) 2373 { 2374 struct drm_vblank_crtc *vblank = work->vblank; 2375 bool scheduled; > 2376 DEFINE_KTHREAD_FLUSH_WORK(fwork);---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org--
You received this message because you are subscribed to the Google Groups "Clang Built Linux" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clang-built-linux+unsubscribe(a)googlegroups.com. To view this discussion on the web visit https://groups.google.com/d/msgid/clang-built-linux/202005101057.9xhrjs8z%25lkp%40intel.com.
Signature · 2 lines
Thanks, ~Nick Desaulniers
Re: [RFC v4 02/12] kthread: Add kthread_(un)block_work_queuing() and kthread_work_queuable()
In reply to a message not in the archiveMinor nitpick. s/queuing/queueing/ and s/queuable/queueable/.
Quoted 96 lines · Lyude Paul
Add some simple wrappers around incrementing/decrementing kthread_work.cancelling under lock, along with checking whether queuing is currently allowed on a given
kthread_work, which we'll use want to implement work cancelling with DRM's vblank work helpers.Cc Daniel Vetter <[email protected]>Cc Tejun Heo <[email protected]>Cc Ville Syrjälä <[email protected]>Signed-off-by Lyude Paul <[email protected]>--- include/linux/kthread.h | 19 +++++++++++++++++ kernel/kthread.c | 46 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+)include/linux/kthread.h +19
-0@@ -211,9 +211,28 @@ void kthread_flush_worker(struct kthread_worker *worker);bool kthread_cancel_work_sync (struct kthread_work *work);bool kthread_cancel_delayed_work_sync (struct kthread_delayed_work *work); +void kthread_block_work_queuing (struct kthread_worker *worker, +struct kthread_work *work); +void kthread_unblock_work_queuing (struct kthread_worker *worker, +struct kthread_work *work);void kthread_destroy_worker (struct kthread_worker *worker); +/** +* kthread_work_queuable - whether or not a kthread work can be queued +* @work: The kthread work to check +* +* Checks whether or not queuing @work is currently blocked from queuing, +* either by kthread_cancel_work_sync() and friends or +* kthread_block_work_queuing(). +* +* Returns: whether or not the @work may be queued. +*/ +static inline bool kthread_work_queuable (struct kthread_work *work) +{ +return READ_ONCE (work->canceling) ==0 ; +} +struct cgroup_subsys_state ;#ifdef CONFIG_BLK_CGROUP kernel/kthread.c +39
-0@@ -1187,6 +1187,52 @@ bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork) }EXPORT_SYMBOL_GPL (kthread_cancel_delayed_work_sync); +/** +* kthread_block_work_queuing - prevent a kthread_work from being queued +* without actually cancelling it +* @worker: kthread worker to use +* @work: work to block queuing on +* +* Prevents @work from being queued using kthread_queue_work() and friends, +* but doesn't attempt to cancel any previous queuing. The caller must unblock +* queuing later by calling kthread_unblock_work_queuing(). This call can be +* called multiple times. +* +* See also: kthread_work_queuable() +*/ +void kthread_block_work_queuing (struct kthread_worker *worker, +struct kthread_work *work) +{ +unsigned long flags; + +raw_spin_lock_irqsave (&worker->lock, flags); + work->canceling++; +raw_spin_unlock_irqrestore (&worker->lock, flags); +} +EXPORT_SYMBOL_GPL (kthread_block_work_queuing); + +/** +* kthread_unblock_work_queuing - unblock queuing on a kthread_work +* @worker: kthread worker to use +* @work: work to unblock queuing on +* +* Removes a request to prevent @work from being queued with +* kthread_queue_work() and friends, so that it may potentially be queued +* again. +* +* See also: kthread_work_queuable() +*/ +void kthread_unblock_work_queuing (struct kthread_worker *worker, +struct kthread_work *work) +{ +unsigned long flags;
kernel/kthread.c bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork) · line 1238
Quoted 10 lines
kernel/kthread.c +7
-0+ +raw_spin_lock_irqsave (&worker->lock, flags); +WARN_ON_ONCE (--work->canceling <0 ); +raw_spin_unlock_irqrestore (&worker->lock, flags); +} +EXPORT_SYMBOL_GPL (kthread_unblock_work_queuing); +/** * kthread_flush_worker - flush all current works on a kthread_worker * @worker: worker to flush
_______________________________________________
Nouveau mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/nouveau