Merge tag 'drm-misc-next-2017-05-16' of git://anongit.freedesktop.org/git/drm-misc into drm-next

UAPI Changes:
- Return -ENODEV instead of -ENXIO when creating cma fb w/o valid gem (Daniel)
- Add aspect ratio and custom scaling propertis to connector state (Maarten)

Cross-subsystem Changes:
- None

Core Changes:
- Add Laurent as bridge reviewer and Andrzej as bridge maintainer (Archit)
- Maintain new STM driver through -misc (Yannick)
- Misc doc improvements (as is tradition) (Daniel)
- Add driver-private objects to atomic state (Dhinakaran)
- Deprecate preclose hook in modern drivers (use postclose) (Daniel)
- Add hwmode to vblank struct. This fixes mode access in irq context and reduced
  a bunch of boilerplate (Daniel)

Driver Changes:
- vc4: Add out-fence support to vc4 V3D rendering (Eric)
- stm: Add stm32f429 display hw and am-480272h3tmqw-t01h panel support (Yannick)
- vc4: Remove 256MB cma limit from vc4 (Eric)
- dw-hdmi: Disable audio when inactive, instead of always enabled (Romain)
- zte: Add support for VGA to the ZTE driver (Shawn)
- i915: Track DP MST bandwidth and check it in atomic_check (Dhinakaran)
- vgem: Enable gem dmabuf import iface to facilitate ion testing (Laura)
- vc4: Add support for Cygnus (new dt compat string + couple bug fixes) (Eric)
- pl111: Add driver for pl111 CLCD display controller (Eric/Tom)
- vgem: Subclass drm_device instead of standalone platform device (Chris)

Cc: Archit Taneja <architt@codeaurora.org>
Cc: Eric Anholt <eric@anholt.net>
Cc: Yannick Fertre <yannick.fertre@st.com>
Cc: Romain Perier <romain.perier@collabora.com>
Cc: Navare, Manasi D <manasi.d.navare@intel.com>
Cc: Shawn Guo <shawn.guo@linaro.org>
Cc: Dhinakaran Pandiyan <dhinakaran.pandiyan@intel.com>
Cc: Laura Abbott <labbott@redhat.com>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Tom Cooksey <tom.cooksey@arm.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>

* tag 'drm-misc-next-2017-05-16' of git://anongit.freedesktop.org/git/drm-misc: (72 commits)
  drm: add missing declaration to drm_blend.h
  drm/dp: Wait up all outstanding tx waiters
  drm/dp: Read the tx msg state once after checking for an event
  drm/prime: Forward declare struct device
  drm/vblank: Lock down vblank->hwmode more
  drm/vblank: drop the mode argument from drm_calc_vbltimestamp_from_scanoutpos
  drm/vblank: Add FIXME comments about moving the vblank ts hooks
  drm/vblank: Switch to bool in_vblank_irq in get_vblank_timestamp
  drm/vblank: Switch drm_driver->get_vblank_timestamp to return a bool
  drm/vgem: Convert to a struct drm_device subclass
  gpu: drm: gma500: remove dead code
  drm/sti: Adjust two checks for null pointers in sti_hqvdp_probe()
  drm/sti: Fix typos in a comment line
  drm/sti: Fix a typo in a comment line
  drm/sti: Replace 17 seq_puts() calls by seq_putc()
  drm/sti: Reduce function calls for sequence output at five places
  drm/sti: use seq_puts to display a string
  drm: Nerf the preclose callback for modern drivers
  drm/exynos: Merge pre/postclose hooks
  drm/tegra: switch to postclose
  ...

1 files changed, 157 insertions, 7 deletions

diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c
index d3fc7e4e85b7..222eb1a8549b 100644
--- a/drivers/gpu/drm/drm_dp_mst_topology.c
+++ b/drivers/gpu/drm/drm_dp_mst_topology.c
@@ -737,16 +737,16 @@ static void drm_dp_mst_put_payload_id(struct drm_dp_mst_topology_mgr *mgr,
 static bool check_txmsg_state(struct drm_dp_mst_topology_mgr *mgr,
                               struct drm_dp_sideband_msg_tx *txmsg)
 {
-        bool ret;
+        unsigned int state;
 
         /*
          * All updates to txmsg->state are protected by mgr->qlock, and the two
          * cases we check here are terminal states. For those the barriers
          * provided by the wake_up/wait_event pair are enough.
          */
-        ret = (txmsg->state == DRM_DP_SIDEBAND_TX_RX ||
-               txmsg->state == DRM_DP_SIDEBAND_TX_TIMEOUT);
-        return ret;
+        state = READ_ONCE(txmsg->state);
+        return (state == DRM_DP_SIDEBAND_TX_RX ||
+                state == DRM_DP_SIDEBAND_TX_TIMEOUT);
 }
 
 static int drm_dp_mst_wait_tx_reply(struct drm_dp_mst_branch *mstb,
@@ -855,7 +855,7 @@ static void drm_dp_destroy_mst_branch_device(struct kref *kref)
         mutex_unlock(&mstb->mgr->qlock);
 
         if (wake_tx)
-                wake_up(&mstb->mgr->tx_waitq);
+                wake_up_all(&mstb->mgr->tx_waitq);
 
         kref_put(kref, drm_dp_free_mst_branch_device);
 }
@@ -1510,7 +1510,7 @@ static void process_single_down_tx_qlock(struct drm_dp_mst_topology_mgr *mgr)
                 if (txmsg->seqno != -1)
                         txmsg->dst->tx_slots[txmsg->seqno] = NULL;
                 txmsg->state = DRM_DP_SIDEBAND_TX_TIMEOUT;
-                wake_up(&mgr->tx_waitq);
+                wake_up_all(&mgr->tx_waitq);
         }
 }
 
@@ -2258,7 +2258,7 @@ static int drm_dp_mst_handle_down_rep(struct drm_dp_mst_topology_mgr *mgr)
                 mstb->tx_slots[slot] = NULL;
                 mutex_unlock(&mgr->qlock);
 
-                wake_up(&mgr->tx_waitq);
+                wake_up_all(&mgr->tx_waitq);
         }
         return ret;
 }
@@ -2498,6 +2498,81 @@ static int drm_dp_init_vcpi(struct drm_dp_mst_topology_mgr *mgr,
 }
 
 /**
+ * drm_dp_atomic_find_vcpi_slots() - Find and add vcpi slots to the state
+ * @state: global atomic state
+ * @mgr: MST topology manager for the port
+ * @port: port to find vcpi slots for
+ * @pbn: bandwidth required for the mode in PBN
+ *
+ * RETURNS:
+ * Total slots in the atomic state assigned for this port or error
+ */
+int drm_dp_atomic_find_vcpi_slots(struct drm_atomic_state *state,
+                                  struct drm_dp_mst_topology_mgr *mgr,
+                                  struct drm_dp_mst_port *port, int pbn)
+{
+        struct drm_dp_mst_topology_state *topology_state;
+        int req_slots;
+
+        topology_state = drm_atomic_get_mst_topology_state(state, mgr);
+        if (topology_state == NULL)
+                return -ENOMEM;
+
+        port = drm_dp_get_validated_port_ref(mgr, port);
+        if (port == NULL)
+                return -EINVAL;
+        req_slots = DIV_ROUND_UP(pbn, mgr->pbn_div);
+        DRM_DEBUG_KMS("vcpi slots req=%d, avail=%d\n",
+                        req_slots, topology_state->avail_slots);
+
+        if (req_slots > topology_state->avail_slots) {
+                drm_dp_put_port(port);
+                return -ENOSPC;
+        }
+
+        topology_state->avail_slots -= req_slots;
+        DRM_DEBUG_KMS("vcpi slots avail=%d", topology_state->avail_slots);
+
+        drm_dp_put_port(port);
+        return req_slots;
+}
+EXPORT_SYMBOL(drm_dp_atomic_find_vcpi_slots);
+
+/**
+ * drm_dp_atomic_release_vcpi_slots() - Release allocated vcpi slots
+ * @state: global atomic state
+ * @mgr: MST topology manager for the port
+ * @slots: number of vcpi slots to release
+ *
+ * RETURNS:
+ * 0 if @slots were added back to &drm_dp_mst_topology_state->avail_slots or
+ * negative error code
+ */
+int drm_dp_atomic_release_vcpi_slots(struct drm_atomic_state *state,
+                                     struct drm_dp_mst_topology_mgr *mgr,
+                                     int slots)
+{
+        struct drm_dp_mst_topology_state *topology_state;
+
+        topology_state = drm_atomic_get_mst_topology_state(state, mgr);
+        if (topology_state == NULL)
+                return -ENOMEM;
+
+        /* We cannot rely on port->vcpi.num_slots to update
+         * topology_state->avail_slots as the port may not exist if the parent
+         * branch device was unplugged. This should be fixed by tracking
+         * per-port slot allocation in drm_dp_mst_topology_state instead of
+         * depending on the caller to tell us how many slots to release.
+         */
+        topology_state->avail_slots += slots;
+        DRM_DEBUG_KMS("vcpi slots released=%d, avail=%d\n",
+                        slots, topology_state->avail_slots);
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_dp_atomic_release_vcpi_slots);
+
+/**
  * drm_dp_mst_allocate_vcpi() - Allocate a virtual channel
  * @mgr: manager for this port
  * @port: port to allocate a virtual channel for.
@@ -2936,6 +3011,69 @@ static void drm_dp_destroy_connector_work(struct work_struct *work)
                 (*mgr->cbs->hotplug)(mgr);
 }
 
+void *drm_dp_mst_duplicate_state(struct drm_atomic_state *state, void *obj)
+{
+        struct drm_dp_mst_topology_mgr *mgr = obj;
+        struct drm_dp_mst_topology_state *new_mst_state;
+
+        if (WARN_ON(!mgr->state))
+                return NULL;
+
+        new_mst_state = kmemdup(mgr->state, sizeof(*new_mst_state), GFP_KERNEL);
+        if (new_mst_state)
+                new_mst_state->state = state;
+        return new_mst_state;
+}
+
+void drm_dp_mst_swap_state(void *obj, void **obj_state_ptr)
+{
+        struct drm_dp_mst_topology_mgr *mgr = obj;
+        struct drm_dp_mst_topology_state **topology_state_ptr;
+
+        topology_state_ptr = (struct drm_dp_mst_topology_state **)obj_state_ptr;
+
+        mgr->state->state = (*topology_state_ptr)->state;
+        swap(*topology_state_ptr, mgr->state);
+        mgr->state->state = NULL;
+}
+
+void drm_dp_mst_destroy_state(void *obj_state)
+{
+        kfree(obj_state);
+}
+
+static const struct drm_private_state_funcs mst_state_funcs = {
+        .duplicate_state = drm_dp_mst_duplicate_state,
+        .swap_state = drm_dp_mst_swap_state,
+        .destroy_state = drm_dp_mst_destroy_state,
+};
+
+/**
+ * drm_atomic_get_mst_topology_state: get MST topology state
+ *
+ * @state: global atomic state
+ * @mgr: MST topology manager, also the private object in this case
+ *
+ * This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic
+ * state vtable so that the private object state returned is that of a MST
+ * topology object. Also, drm_atomic_get_private_obj_state() expects the caller
+ * to care of the locking, so warn if don't hold the connection_mutex.
+ *
+ * RETURNS:
+ *
+ * The MST topology state or error pointer.
+ */
+struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_state *state,
+                                                                    struct drm_dp_mst_topology_mgr *mgr)
+{
+        struct drm_device *dev = mgr->dev;
+
+        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
+        return drm_atomic_get_private_obj_state(state, mgr,
+                                                &mst_state_funcs);
+}
+EXPORT_SYMBOL(drm_atomic_get_mst_topology_state);
+
 /**
  * drm_dp_mst_topology_mgr_init - initialise a topology manager
  * @mgr: manager struct to initialise
@@ -2980,6 +3118,15 @@ int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr *mgr,
         if (test_calc_pbn_mode() < 0)
                 DRM_ERROR("MST PBN self-test failed\n");
 
+        mgr->state = kzalloc(sizeof(*mgr->state), GFP_KERNEL);
+        if (mgr->state == NULL)
+                return -ENOMEM;
+        mgr->state->mgr = mgr;
+
+        /* max. time slots - one slot for MTP header */
+        mgr->state->avail_slots = 63;
+        mgr->funcs = &mst_state_funcs;
+
         return 0;
 }
 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_init);
@@ -3000,6 +3147,9 @@ void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr *mgr)
         mutex_unlock(&mgr->payload_lock);
         mgr->dev = NULL;
         mgr->aux = NULL;
+        kfree(mgr->state);
+        mgr->state = NULL;
+        mgr->funcs = NULL;
 }
 EXPORT_SYMBOL(drm_dp_mst_topology_mgr_destroy);