[PATCH v2 1/3] drm/xe/guc: Add more GuC CT states
Matthew Brost
matthew.brost at intel.com
Fri Jan 12 17:50:49 UTC 2024
On Thu, Jan 11, 2024 at 12:01:55PM +0100, Michal Wajdeczko wrote:
>
>
> On 10.01.2024 00:01, Matthew Brost wrote:
> > The Guc CT has more than enabled / disables states rather it has 4. The
> > 4 states are not initialized, disabled, stopped, and enabled. Change the
> > code to reflect this. These states will enable proper return codes from
> > functions and therefore enable proper error messages.
> >
> > v2:
> > - s/XE_GUC_CT_STATE_DROP_MESSAGES/XE_GUC_CT_STATE_STOPPED (Michal)
> > - Add assert for CT being initialized (Michal)
> > - Fix kernel for CT state enum (Michal)
> >
> > Cc: Michal Wajdeczko <michal.wajdeczko at intel.com>
> > Cc: Tejas Upadhyay <tejas.upadhyay at intel.com>
> > Signed-off-by: Matthew Brost <matthew.brost at intel.com>
> > ---
> > drivers/gpu/drm/xe/xe_guc.c | 4 +-
> > drivers/gpu/drm/xe/xe_guc_ct.c | 56 ++++++++++++++++++++--------
> > drivers/gpu/drm/xe/xe_guc_ct.h | 8 +++-
> > drivers/gpu/drm/xe/xe_guc_ct_types.h | 18 ++++++++-
> > 4 files changed, 65 insertions(+), 21 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/xe/xe_guc.c b/drivers/gpu/drm/xe/xe_guc.c
> > index 311a0364bff1..c28410958990 100644
> > --- a/drivers/gpu/drm/xe/xe_guc.c
> > +++ b/drivers/gpu/drm/xe/xe_guc.c
> > @@ -656,7 +656,7 @@ int xe_guc_mmio_send_recv(struct xe_guc *guc, const u32 *request,
> >
> > BUILD_BUG_ON(VF_SW_FLAG_COUNT != MED_VF_SW_FLAG_COUNT);
> >
> > - xe_assert(xe, !guc->ct.enabled);
> > + xe_assert(xe, !xe_guc_ct_enabled(&guc->ct));
>
> btw, what was the rationale to not allow MMIO communication together
> with communication over CTB ? note that GuC still monitors MMIO for new
> messages after each H2G IRQ and in upcoming VF specific scenarios we
> will have to send some acks over the MMIO, even after CTB was enabled
>
See reply on your patch.
> > xe_assert(xe, len);
> > xe_assert(xe, len <= VF_SW_FLAG_COUNT);
> > xe_assert(xe, len <= MED_VF_SW_FLAG_COUNT);
> > @@ -838,7 +838,7 @@ int xe_guc_stop(struct xe_guc *guc)
> > {
> > int ret;
> >
> > - xe_guc_ct_disable(&guc->ct);
> > + xe_guc_ct_stop(&guc->ct);
> >
> > ret = xe_guc_submit_stop(guc);
> > if (ret)
> > diff --git a/drivers/gpu/drm/xe/xe_guc_ct.c b/drivers/gpu/drm/xe/xe_guc_ct.c
> > index c29f095aa1b9..5b122a926ccf 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_ct.c
> > +++ b/drivers/gpu/drm/xe/xe_guc_ct.c
> > @@ -164,6 +164,7 @@ int xe_guc_ct_init(struct xe_guc_ct *ct)
> > if (err)
> > return err;
> >
> > + ct->state = XE_GUC_CT_STATE_DISABLED;
>
> maybe it's worth to assert that ct->state was UNINITIALIZED (unset)
> prior to this initialization ?
>
Sure.
> > return 0;
> > }
> >
> > @@ -283,12 +284,25 @@ static int guc_ct_control_toggle(struct xe_guc_ct *ct, bool enable)
> > return ret > 0 ? -EPROTO : ret;
> > }
> >
> > +static void xe_guc_ct_set_state(struct xe_guc_ct *ct,
> > + enum xe_guc_ct_state state)
> > +{
> > + mutex_lock(&ct->lock); /* Serialise dequeue_one_g2h() */
> > + spin_lock_irq(&ct->fast_lock); /* Serialise CT fast-path */
> > +
> > + ct->g2h_outstanding = 0;
>
> we used to clear g2h_outstanding only while enabling CT, now this is
> done on every state transition - it's not what the function name says
>
It really should be set to zero on disable now that I'm thinking about
but regardless it is harmless to change on every state transition. I'd
prefer to leave this as is. Also fine with the function name.
> > + ct->state = state;
> > +
> > + spin_unlock_irq(&ct->fast_lock);
> > + mutex_unlock(&ct->lock);
> > +}
> > +
> > int xe_guc_ct_enable(struct xe_guc_ct *ct)
> > {
> > struct xe_device *xe = ct_to_xe(ct);
> > int err;
> >
> > - xe_assert(xe, !ct->enabled);
> > + xe_assert(xe, !xe_guc_ct_enabled(ct));
> >
> > guc_ct_ctb_h2g_init(xe, &ct->ctbs.h2g, &ct->bo->vmap);
> > guc_ct_ctb_g2h_init(xe, &ct->ctbs.g2h, &ct->bo->vmap);
> > @@ -305,12 +319,7 @@ int xe_guc_ct_enable(struct xe_guc_ct *ct)
> > if (err)
> > goto err_out;
> >
> > - mutex_lock(&ct->lock);
> > - spin_lock_irq(&ct->fast_lock);
> > - ct->g2h_outstanding = 0;
> > - ct->enabled = true;
> > - spin_unlock_irq(&ct->fast_lock);
> > - mutex_unlock(&ct->lock);
> > + xe_guc_ct_set_state(ct, XE_GUC_CT_STATE_ENABLED);
> >
> > smp_mb();
> > wake_up_all(&ct->wq);
> > @@ -326,12 +335,12 @@ int xe_guc_ct_enable(struct xe_guc_ct *ct)
> >
> > void xe_guc_ct_disable(struct xe_guc_ct *ct)
> > {
> > - mutex_lock(&ct->lock); /* Serialise dequeue_one_g2h() */
> > - spin_lock_irq(&ct->fast_lock); /* Serialise CT fast-path */
> > - ct->enabled = false; /* Finally disable CT communication */
> > - spin_unlock_irq(&ct->fast_lock);
> > - mutex_unlock(&ct->lock);
> > + xe_guc_ct_set_state(ct, XE_GUC_CT_STATE_DISABLED);
> > +}
> >
>
> shouldn't we provide kernel-doc for all public functions ?
>
> while there is no documentation for old functions, this xe_guc_ct_stop()
> is the new one so shouldn't benefit from relaxed _initial_drop_ rules.
>
Yes, will fix.
> > +void xe_guc_ct_stop(struct xe_guc_ct *ct)
> > +{
> > + xe_guc_ct_set_state(ct, XE_GUC_CT_STATE_STOPPED);
> > xa_destroy(&ct->fence_lookup);
>
> maybe it's worth to destroy xa under the lock in xe_guc_ct_set_state()
> to protect against another ct_enable() followed by ct_send() ?
>
It shouldn't be possible to enable immediately but sure I move this to
xe_guc_ct_set_state with an argument to xe_guc_ct_set_state which
indicates fence_lookup should be destroyed.
> > }
> >
> > @@ -507,6 +516,7 @@ static int __guc_ct_send_locked(struct xe_guc_ct *ct, const u32 *action,
> > u16 seqno;
> > int ret;
> >
> > + xe_assert(xe, ct->state != XE_GUC_CT_STATE_NOT_INITIALIZED);
> > xe_assert(xe, !g2h_len || !g2h_fence);
> > xe_assert(xe, !num_g2h || !g2h_fence);
> > xe_assert(xe, !g2h_len || num_g2h);
> > @@ -518,11 +528,18 @@ static int __guc_ct_send_locked(struct xe_guc_ct *ct, const u32 *action,
> > goto out;
> > }
> >
> > - if (unlikely(!ct->enabled)) {
> > + if (ct->state == XE_GUC_CT_STATE_DISABLED) {
> > ret = -ENODEV;
> > goto out;
> > }
> >
> > + if (ct->state == XE_GUC_CT_STATE_STOPPED) {
> > + ret = -ECANCELED;
> > + goto out;
> > + }
> > +
> > + xe_assert(xe, xe_guc_ct_enabled(ct));
> > +
> > if (g2h_fence) {
> > g2h_len = GUC_CTB_HXG_MSG_MAX_LEN;
> > num_g2h = 1;
> > @@ -710,7 +727,8 @@ static bool retry_failure(struct xe_guc_ct *ct, int ret)
> > return false;
> >
> > #define ct_alive(ct) \
> > - (ct->enabled && !ct->ctbs.h2g.info.broken && !ct->ctbs.g2h.info.broken)
> > + (xe_guc_ct_enabled(ct) && !ct->ctbs.h2g.info.broken && \
> > + !ct->ctbs.g2h.info.broken)
>
> maybe instead of having two extra 'broken' flags better option would be
> to also add XE_GUC_CT_STATE_BROKEN as new state ?
>
Good idea. Can I do that in a follow up as this series is needed to
unblock.
[1] https://patchwork.freedesktop.org/series/125804/#rev1
> > if (!wait_event_interruptible_timeout(ct->wq, ct_alive(ct), HZ * 5))
> > return false;
> > #undef ct_alive
> > @@ -996,14 +1014,20 @@ static int g2h_read(struct xe_guc_ct *ct, u32 *msg, bool fast_path)
> > s32 avail;
> > u32 action;
> >
> > + xe_assert(xe, ct->state != XE_GUC_CT_STATE_NOT_INITIALIZED);
>
> this seems redundant as you've also added assert(enable) below
>
Even if redundant I prefer this as it self documenting. Also compiles
out without a debug Kconfig.
> > lockdep_assert_held(&ct->fast_lock);
> >
> > - if (!ct->enabled)
> > + if (ct->state == XE_GUC_CT_STATE_DISABLED)
> > return -ENODEV;
> >
> > + if (ct->state == XE_GUC_CT_STATE_STOPPED)
> > + return -ECANCELED;
> > +
> > if (g2h->info.broken)
> > return -EPIPE;
> >
> > + xe_assert(xe, xe_guc_ct_enabled(ct));
> > +
> > /* Calculate DW available to read */
> > tail = desc_read(xe, g2h, tail);
> > avail = tail - g2h->info.head;
> > @@ -1302,7 +1326,7 @@ struct xe_guc_ct_snapshot *xe_guc_ct_snapshot_capture(struct xe_guc_ct *ct,
> > return NULL;
> > }
> >
> > - if (ct->enabled) {
> > + if (xe_guc_ct_enabled(ct)) {
> > snapshot->ct_enabled = true;
> > snapshot->g2h_outstanding = READ_ONCE(ct->g2h_outstanding);
> > guc_ctb_snapshot_capture(xe, &ct->ctbs.h2g,
> > diff --git a/drivers/gpu/drm/xe/xe_guc_ct.h b/drivers/gpu/drm/xe/xe_guc_ct.h
> > index 9ecb67db8ec4..5083e099064f 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_ct.h
> > +++ b/drivers/gpu/drm/xe/xe_guc_ct.h
> > @@ -13,6 +13,7 @@ struct drm_printer;
> > int xe_guc_ct_init(struct xe_guc_ct *ct);
> > int xe_guc_ct_enable(struct xe_guc_ct *ct);
> > void xe_guc_ct_disable(struct xe_guc_ct *ct);
> > +void xe_guc_ct_stop(struct xe_guc_ct *ct);
> > void xe_guc_ct_fast_path(struct xe_guc_ct *ct);
> >
> > struct xe_guc_ct_snapshot *
> > @@ -22,9 +23,14 @@ void xe_guc_ct_snapshot_print(struct xe_guc_ct_snapshot *snapshot,
> > void xe_guc_ct_snapshot_free(struct xe_guc_ct_snapshot *snapshot);
> > void xe_guc_ct_print(struct xe_guc_ct *ct, struct drm_printer *p, bool atomic);
> >
>
> not sure about rules for kernel-doc for public inlines
>
> @Rodrigo ?
>
I think we are allow no kernel doc.
> > +static inline bool xe_guc_ct_enabled(struct xe_guc_ct *ct)
> > +{
> > + return ct->state == XE_GUC_CT_STATE_ENABLED;
> > +}
> > +
> > static inline void xe_guc_ct_irq_handler(struct xe_guc_ct *ct)
> > {
> > - if (!ct->enabled)
> > + if (!xe_guc_ct_enabled(ct))
> > return;
> >
> > wake_up_all(&ct->wq);
> > diff --git a/drivers/gpu/drm/xe/xe_guc_ct_types.h b/drivers/gpu/drm/xe/xe_guc_ct_types.h
> > index d814d4ee3fc6..e146dbeddedb 100644
> > --- a/drivers/gpu/drm/xe/xe_guc_ct_types.h
> > +++ b/drivers/gpu/drm/xe/xe_guc_ct_types.h
> > @@ -72,6 +72,20 @@ struct xe_guc_ct_snapshot {
> > struct guc_ctb_snapshot h2g;
> > };
> >
> > +/**
> > + * enum xe_guc_ct_state - CT state
> > + * @XE_GUC_CT_STATE_NOT_INITIALIZED: CT not initialized, messages not expected in this state
>
> with little effort we can drop this enum and just assert that state
> shall be non-zero, note that we never explicitly set this state, so we
> can just rely on compiler that already zeroed this field
>
Agree I prefer that state as it is self documenting.
> > + * @XE_GUC_CT_STATE_DISABLED: CT disabled, messages not expected in this state
> > + * @XE_GUC_CT_STATE_STOPPED: CT stopped, drop messages without errors
> > + * @XE_GUC_CT_STATE_ENABLED: CT enabled, messages sent / recieved in this state
>
> still a typo
>
> -:223: WARNING:TYPO_SPELLING: 'recieved' may be misspelled - perhaps
> 'received'?
> #223: FILE: drivers/gpu/drm/xe/xe_guc_ct_types.h:80:
> + * @XE_GUC_CT_STATE_ENABLED: CT enabled, messages sent / recieved in
> this state
> ^^^^^^^^
Will fix.
Matt
>
> > + */
> > +enum xe_guc_ct_state {
> > + XE_GUC_CT_STATE_NOT_INITIALIZED = 0,
> > + XE_GUC_CT_STATE_DISABLED,
> > + XE_GUC_CT_STATE_STOPPED,
> > + XE_GUC_CT_STATE_ENABLED,
> > +};
> > +
> > /**
> > * struct xe_guc_ct - GuC command transport (CT) layer
> > *
> > @@ -96,8 +110,8 @@ struct xe_guc_ct {
> > u32 g2h_outstanding;
> > /** @g2h_worker: worker to process G2H messages */
> > struct work_struct g2h_worker;
> > - /** @enabled: CT enabled */
> > - bool enabled;
> > + /** @state: CT state */
> > + enum xe_guc_ct_state state;
> > /** @fence_seqno: G2H fence seqno - 16 bits used by CT */
> > u32 fence_seqno;
> > /** @fence_lookup: G2H fence lookup */
More information about the Intel-xe
mailing list