displayport: save and restore compound query state around speculative MST pre-check

The speculative uncompressed pre-check calls compoundQueryAttachMSTGeneric
to determine if DSC can be skipped. However, this function mutates shared
state that the subsequent DSC path depends on:

1. compoundQueryResult is set to false on failure but never reset,
   poisoning all subsequent compoundQueryAttachMSTGeneric calls which
   unconditionally return the (now-false) flag.

2. Per-device compound_query_state (timeslots_used_by_query and
   bandwidthAllocatedForIndex) is only partially rolled back on failure.
   Intermediate branch devices between the source and the bottleneck
   retain their uncompressed timeslot allocations. When the DSC path
   calls compoundQueryAttachMSTGeneric again, these devices are skipped
   via the bandwidthAllocatedForIndex bitmask, keeping incorrect
   (too-large) uncompressed allocations instead of the correct
   (smaller) compressed ones.

Fix this by saving all relevant state before the speculative call and
restoring it on failure, so the DSC path always starts from a clean
slate. Also clear pErrorCode on rollback since the speculative failure
is not a real error.

Author: coleleavitt

src/common/displayport/src/dp_connectorimpl.cpp

@@ -1422,22 +1422,75 @@ bool ConnectorImpl::compoundQueryAttachMST(Group * target,
             {
                 //
                 // The uncompressed mode fits within available local link PBN.
-                // Try the full generic validation (watermark, per-device
-                // bandwidth at intermediate MST branches). If it succeeds,
-                // DSC is unnecessary.
+                // Speculatively try the full generic validation (watermark,
+                // per-device bandwidth at intermediate MST branches). If it
+                // succeeds, DSC is unnecessary.
                 //
+                // compoundQueryAttachMSTGeneric mutates connector and
+                // per-device state (compoundQueryResult, compoundQueryLocalLinkPBN,
+                // and device compound_query_state). Since this is a speculative
+                // check, save the state before and restore it on failure so the
+                // DSC path starts from a clean slate.
+                //
+                bool savedCompoundQueryResult = compoundQueryResult;
+
+                //
+                // Save per-device compound_query_state for all devices in this
+                // group's MST path. On failure, intermediate branch devices may
+                // retain stale timeslot allocations from the uncompressed attempt
+                // which would cause the DSC path to either skip them (via
+                // bandwidthAllocatedForIndex) or over-count their timeslots.
+                //
+                struct {
+                    DeviceImpl *dev;
+                    unsigned timeslots_used_by_query;
+                    unsigned bandwidthAllocatedForIndex;
+                } savedDevState[63];
+                unsigned savedDevCount = 0;
+
+                for (Device * d = target->enumDevices(0); d;
+                     d = target->enumDevices(d))
+                {
+                    DeviceImpl * tail = (DeviceImpl *)d;
+                    while (tail && tail->getParent() &&
+                           savedDevCount < 63)
+                    {
+                        savedDevState[savedDevCount].dev = tail;
+                        savedDevState[savedDevCount].timeslots_used_by_query =
+                            tail->bandwidth.compound_query_state.timeslots_used_by_query;
+                        savedDevState[savedDevCount].bandwidthAllocatedForIndex =
+                            tail->bandwidth.compound_query_state.bandwidthAllocatedForIndex;
+                        savedDevCount++;
+                        tail = (DeviceImpl*)tail->getParent();
+                    }
+                }
                 if (compoundQueryAttachMSTGeneric(target, modesetParams,
                                                   &localInfo, pDscParams,
                                                   pErrorCode))
                 {
                     return true;
                 }
+
+                //
+                // Generic validation failed — restore all state so the DSC
+                // path runs on a clean slate.
                 //
-                // Generic validation failed — possibly due to insufficient
-                // bandwidth at an intermediate MST branch link. DSC can
-                // reduce PBN enough to fit through the bottleneck, so fall
-                // through to the DSC path below.
+                // compoundQueryLocalLinkPBN is already rolled back by
+                // compoundQueryAttachMSTGeneric on failure.
                 //
+                compoundQueryResult = savedCompoundQueryResult;
+                for (unsigned idx = 0; idx < savedDevCount; idx++)
+                {
+                    savedDevState[idx].dev->bandwidth.compound_query_state
+                        .timeslots_used_by_query =
+                            savedDevState[idx].timeslots_used_by_query;
+                    savedDevState[idx].dev->bandwidth.compound_query_state
+                        .bandwidthAllocatedForIndex =
+                            savedDevState[idx].bandwidthAllocatedForIndex;
+                }
+
+                if (pErrorCode)
+                    *pErrorCode = DP_IMP_ERROR_NONE;
             }
         }