1 files changed, 45 insertions, 260 deletions
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
index b3a2cd5118d7..92f56bc594eb 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -27,7 +27,6 @@
 #include "vmwgfx_kms.h"
-#define VMWGFX_LDU_NUM_DU 8
 #define vmw_crtc_to_ldu(x) \
        container_of(x, struct vmw_legacy_display_unit, base.crtc)
@@ -51,11 +50,6 @@ struct vmw_legacy_display {
 struct vmw_legacy_display_unit {
        struct vmw_display_unit base;
-        unsigned pref_width;
-        unsigned pref_height;
-        bool pref_active;
-        struct drm_display_mode *pref_mode;
        struct list_head active;
 };
@@ -71,20 +65,6 @@ static void vmw_ldu_destroy(struct vmw_legacy_display_unit *ldu)
 * Legacy Display Unit CRTC functions
 */
-static void vmw_ldu_crtc_save(struct drm_crtc *crtc)
-{
-}
-static void vmw_ldu_crtc_restore(struct drm_crtc *crtc)
-{
-}
-static void vmw_ldu_crtc_gamma_set(struct drm_crtc *crtc,
-                                   u16 *r, u16 *g, u16 *b,
-                                   uint32_t start, uint32_t size)
-{
-}
 static void vmw_ldu_crtc_destroy(struct drm_crtc *crtc)
 {
        vmw_ldu_destroy(vmw_crtc_to_ldu(crtc));
@@ -114,10 +94,8 @@ static int vmw_ldu_commit_list(struct vmw_private *dev_priv)
                        return 0;
                fb = entry->base.crtc.fb;
-                vmw_kms_write_svga(dev_priv, w, h, fb->pitch,
+                return vmw_kms_write_svga(dev_priv, w, h, fb->pitch,
-                                   fb->bits_per_pixel, fb->depth);
+                                          fb->bits_per_pixel, fb->depth);
-                return 0;
        }
        if (!list_empty(&lds->active)) {
@@ -265,9 +243,7 @@ static int vmw_ldu_crtc_set_config(struct drm_mode_set *set)
                vmw_ldu_del_active(dev_priv, ldu);
-                vmw_ldu_commit_list(dev_priv);
+                return vmw_ldu_commit_list(dev_priv);
-                return 0;
        }
@@ -292,21 +268,20 @@ static int vmw_ldu_crtc_set_config(struct drm_mode_set *set)
        vmw_ldu_add_active(dev_priv, ldu, vfb);
-        vmw_ldu_commit_list(dev_priv);
+        return vmw_ldu_commit_list(dev_priv);
-        return 0;
 }
 static struct drm_crtc_funcs vmw_legacy_crtc_funcs = {
-        .save = vmw_ldu_crtc_save,
+        .save = vmw_du_crtc_save,
-        .restore = vmw_ldu_crtc_restore,
+        .restore = vmw_du_crtc_restore,
        .cursor_set = vmw_du_crtc_cursor_set,
        .cursor_move = vmw_du_crtc_cursor_move,
-        .gamma_set = vmw_ldu_crtc_gamma_set,
+        .gamma_set = vmw_du_crtc_gamma_set,
        .destroy = vmw_ldu_crtc_destroy,
        .set_config = vmw_ldu_crtc_set_config,
 };
 /*
 * Legacy Display Unit encoder functions
 */
@@ -324,183 +299,18 @@ static struct drm_encoder_funcs vmw_legacy_encoder_funcs = {
 * Legacy Display Unit connector functions
 */
-static void vmw_ldu_connector_dpms(struct drm_connector *connector, int mode)
-{
-}
-static void vmw_ldu_connector_save(struct drm_connector *connector)
-{
-}
-static void vmw_ldu_connector_restore(struct drm_connector *connector)
-{
-}
-static enum drm_connector_status
-        vmw_ldu_connector_detect(struct drm_connector *connector,
-                                 bool force)
-{
-        if (vmw_connector_to_ldu(connector)->pref_active)
-                return connector_status_connected;
-        return connector_status_disconnected;
-}
-static const struct drm_display_mode vmw_ldu_connector_builtin[] = {
-        /* 640x480@60Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
-                   752, 800, 0, 480, 489, 492, 525, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 800x600@60Hz */
-        { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
-                   968, 1056, 0, 600, 601, 605, 628, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1024x768@60Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
-                   1184, 1344, 0, 768, 771, 777, 806, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1152x864@75Hz */
-        { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
-                   1344, 1600, 0, 864, 865, 868, 900, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x768@60Hz */
-        { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
-                   1472, 1664, 0, 768, 771, 778, 798, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x800@60Hz */
-        { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
-                   1480, 1680, 0, 800, 803, 809, 831, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
-        /* 1280x960@60Hz */
-        { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
-                   1488, 1800, 0, 960, 961, 964, 1000, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1280x1024@60Hz */
-        { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
-                   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1360x768@60Hz */
-        { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
-                   1536, 1792, 0, 768, 771, 777, 795, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x1050@60Hz */
-        { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
-                   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1440x900@60Hz */
-        { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
-                   1672, 1904, 0, 900, 903, 909, 934, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1600x1200@60Hz */
-        { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
-                   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
-                   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1680x1050@60Hz */
-        { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
-                   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1792x1344@60Hz */
-        { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
-                   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1853x1392@60Hz */
-        { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
-                   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1200@60Hz */
-        { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
-                   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 1920x1440@60Hz */
-        { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
-                   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* 2560x1600@60Hz */
-        { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
-                   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
-                   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
-        /* Terminate */
-        { DRM_MODE("", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) },
-};
-static int vmw_ldu_connector_fill_modes(struct drm_connector *connector,
-                                        uint32_t max_width, uint32_t max_height)
-{
-        struct vmw_legacy_display_unit *ldu = vmw_connector_to_ldu(connector);
-        struct drm_device *dev = connector->dev;
-        struct vmw_private *dev_priv = vmw_priv(dev);
-        struct drm_display_mode *mode = NULL;
-        struct drm_display_mode prefmode = { DRM_MODE("preferred",
-                DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
-        };
-        int i;
-        /* Add preferred mode */
-        {
-                mode = drm_mode_duplicate(dev, &prefmode);
-                if (!mode)
-                        return 0;
-                mode->hdisplay = ldu->pref_width;
-                mode->vdisplay = ldu->pref_height;
-                mode->vrefresh = drm_mode_vrefresh(mode);
-                if (vmw_kms_validate_mode_vram(dev_priv, mode->hdisplay * 2,
-                                               mode->vdisplay)) {
-                        drm_mode_probed_add(connector, mode);
-                        if (ldu->pref_mode) {
-                                list_del_init(&ldu->pref_mode->head);
-                                drm_mode_destroy(dev, ldu->pref_mode);
-                        }
-                        ldu->pref_mode = mode;
-                }
-        }
-        for (i = 0; vmw_ldu_connector_builtin[i].type != 0; i++) {
-                const struct drm_display_mode *bmode;
-                bmode = &vmw_ldu_connector_builtin[i];
-                if (bmode->hdisplay > max_width ||
-                    bmode->vdisplay > max_height)
-                        continue;
-                if (!vmw_kms_validate_mode_vram(dev_priv, bmode->hdisplay * 2,
-                                                bmode->vdisplay))
-                        continue;
-                mode = drm_mode_duplicate(dev, bmode);
-                if (!mode)
-                        return 0;
-                mode->vrefresh = drm_mode_vrefresh(mode);
-                drm_mode_probed_add(connector, mode);
-        }
-        drm_mode_connector_list_update(connector);
-        return 1;
-}
-static int vmw_ldu_connector_set_property(struct drm_connector *connector,
-                                          struct drm_property *property,
-                                          uint64_t val)
-{
-        return 0;
-}
 static void vmw_ldu_connector_destroy(struct drm_connector *connector)
 {
        vmw_ldu_destroy(vmw_connector_to_ldu(connector));
 }
 static struct drm_connector_funcs vmw_legacy_connector_funcs = {
-        .dpms = vmw_ldu_connector_dpms,
+        .dpms = vmw_du_connector_dpms,
-        .save = vmw_ldu_connector_save,
+        .save = vmw_du_connector_save,
-        .restore = vmw_ldu_connector_restore,
+        .restore = vmw_du_connector_restore,
-        .detect = vmw_ldu_connector_detect,
+        .detect = vmw_du_connector_detect,
-        .fill_modes = vmw_ldu_connector_fill_modes,
+        .fill_modes = vmw_du_connector_fill_modes,
-        .set_property = vmw_ldu_connector_set_property,
+        .set_property = vmw_du_connector_set_property,
        .destroy = vmw_ldu_connector_destroy,
 };
@@ -523,14 +333,14 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
        INIT_LIST_HEAD(&ldu->active);
-        ldu->pref_active = (unit == 0);
+        ldu->base.pref_active = (unit == 0);
-        ldu->pref_width = 800;
+        ldu->base.pref_width = 800;
-        ldu->pref_height = 600;
+        ldu->base.pref_height = 600;
-        ldu->pref_mode = NULL;
+        ldu->base.pref_mode = NULL;
        drm_connector_init(dev, connector, &vmw_legacy_connector_funcs,
                           DRM_MODE_CONNECTOR_LVDS);
-        connector->status = vmw_ldu_connector_detect(connector, true);
+        connector->status = vmw_du_connector_detect(connector, true);
        drm_encoder_init(dev, encoder, &vmw_legacy_encoder_funcs,
                         DRM_MODE_ENCODER_LVDS);
@@ -540,6 +350,8 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
        drm_crtc_init(dev, crtc, &vmw_legacy_crtc_funcs);
+        drm_mode_crtc_set_gamma_size(crtc, 256);
        drm_connector_attach_property(connector,
                                      dev->mode_config.dirty_info_property,
                                      1);
@@ -550,8 +362,7 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
 int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
-        int i;
+        int i, ret;
-        int ret;
        if (dev_priv->ldu_priv) {
                DRM_INFO("ldu system already on\n");
@@ -559,7 +370,6 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
        }
        dev_priv->ldu_priv = kmalloc(sizeof(*dev_priv->ldu_priv), GFP_KERNEL);
        if (!dev_priv->ldu_priv)
                return -ENOMEM;
@@ -568,18 +378,31 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
        dev_priv->ldu_priv->last_num_active = 0;
        dev_priv->ldu_priv->fb = NULL;
-        drm_mode_create_dirty_info_property(dev_priv->dev);
+        /* for old hardware without multimon only enable one display */
+        if (dev_priv->capabilities & SVGA_CAP_MULTIMON)
+                ret = drm_vblank_init(dev, VMWGFX_NUM_DISPLAY_UNITS);
+        else
+                ret = drm_vblank_init(dev, 1);
+        if (ret != 0)
+                goto err_free;
+        ret = drm_mode_create_dirty_info_property(dev);
+        if (ret != 0)
+                goto err_vblank_cleanup;
-        if (dev_priv->capabilities & SVGA_CAP_MULTIMON) {
+        if (dev_priv->capabilities & SVGA_CAP_MULTIMON)
-                for (i = 0; i < VMWGFX_LDU_NUM_DU; ++i)
+                for (i = 0; i < VMWGFX_NUM_DISPLAY_UNITS; ++i)
                        vmw_ldu_init(dev_priv, i);
-                ret = drm_vblank_init(dev, VMWGFX_LDU_NUM_DU);
+        else
-        } else {
-                /* for old hardware without multimon only enable one display */
                vmw_ldu_init(dev_priv, 0);
-                ret = drm_vblank_init(dev, 1);
-        }
+        return 0;
+err_vblank_cleanup:
+        drm_vblank_cleanup(dev);
+err_free:
+        kfree(dev_priv->ldu_priv);
+        dev_priv->ldu_priv = NULL;
        return ret;
 }
@@ -587,52 +410,14 @@ int vmw_kms_close_legacy_display_system(struct vmw_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
-        drm_vblank_cleanup(dev);
        if (!dev_priv->ldu_priv)
                return -ENOSYS;
+        drm_vblank_cleanup(dev);
        BUG_ON(!list_empty(&dev_priv->ldu_priv->active));
        kfree(dev_priv->ldu_priv);
        return 0;
 }
-int vmw_kms_ldu_update_layout(struct vmw_private *dev_priv, unsigned num,
-                              struct drm_vmw_rect *rects)
-{
-        struct drm_device *dev = dev_priv->dev;
-        struct vmw_legacy_display_unit *ldu;
-        struct drm_connector *con;
-        int i;
-        mutex_lock(&dev->mode_config.mutex);
-#if 0
-        DRM_INFO("%s: new layout ", __func__);
-        for (i = 0; i < (int)num; i++)
-                DRM_INFO("(%i, %i %ux%u) ", rects[i].x, rects[i].y,
-                         rects[i].w, rects[i].h);
-        DRM_INFO("\n");
-#else
-        (void)i;
-#endif
-        list_for_each_entry(con, &dev->mode_config.connector_list, head) {
-                ldu = vmw_connector_to_ldu(con);
-                if (num > ldu->base.unit) {
-                        ldu->pref_width = rects[ldu->base.unit].w;
-                        ldu->pref_height = rects[ldu->base.unit].h;
-                        ldu->pref_active = true;
-                } else {
-                        ldu->pref_width = 800;
-                        ldu->pref_height = 600;
-                        ldu->pref_active = false;
-                }
-                con->status = vmw_ldu_connector_detect(con, true);
-        }
-        mutex_unlock(&dev->mode_config.mutex);
-        return 0;
-}

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c index b3a2cd5118d7..92f56bc594eb 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c
@@ -27,7 +27,6 @@
27		27
28	#include "vmwgfx_kms.h"	28	#include "vmwgfx_kms.h"
29		29
30	#define VMWGFX_LDU_NUM_DU 8
31		30
32	#define vmw_crtc_to_ldu(x) \	31	#define vmw_crtc_to_ldu(x) \
33	container_of(x, struct vmw_legacy_display_unit, base.crtc)	32	container_of(x, struct vmw_legacy_display_unit, base.crtc)
@@ -51,11 +50,6 @@ struct vmw_legacy_display {
51	struct vmw_legacy_display_unit {	50	struct vmw_legacy_display_unit {
52	struct vmw_display_unit base;	51	struct vmw_display_unit base;
53		52
54	unsigned pref_width;
55	unsigned pref_height;
56	bool pref_active;
57	struct drm_display_mode *pref_mode;
58
59	struct list_head active;	53	struct list_head active;
60	};	54	};
61		55
@@ -71,20 +65,6 @@ static void vmw_ldu_destroy(struct vmw_legacy_display_unit *ldu)
71	* Legacy Display Unit CRTC functions	65	* Legacy Display Unit CRTC functions
72	*/	66	*/
73		67
74	static void vmw_ldu_crtc_save(struct drm_crtc *crtc)
75	{
76	}
77
78	static void vmw_ldu_crtc_restore(struct drm_crtc *crtc)
79	{
80	}
81
82	static void vmw_ldu_crtc_gamma_set(struct drm_crtc *crtc,
83	u16 r, u16 g, u16 *b,
84	uint32_t start, uint32_t size)
85	{
86	}
87
88	static void vmw_ldu_crtc_destroy(struct drm_crtc *crtc)	68	static void vmw_ldu_crtc_destroy(struct drm_crtc *crtc)
89	{	69	{
90	vmw_ldu_destroy(vmw_crtc_to_ldu(crtc));	70	vmw_ldu_destroy(vmw_crtc_to_ldu(crtc));
@@ -114,10 +94,8 @@ static int vmw_ldu_commit_list(struct vmw_private *dev_priv)
114	return 0;	94	return 0;
115	fb = entry->base.crtc.fb;	95	fb = entry->base.crtc.fb;
116		96
117	vmw_kms_write_svga(dev_priv, w, h, fb->pitch,	97	return vmw_kms_write_svga(dev_priv, w, h, fb->pitch,
118	fb->bits_per_pixel, fb->depth);	98	fb->bits_per_pixel, fb->depth);
119
120	return 0;
121	}	99	}
122		100
123	if (!list_empty(&lds->active)) {	101	if (!list_empty(&lds->active)) {
@@ -265,9 +243,7 @@ static int vmw_ldu_crtc_set_config(struct drm_mode_set *set)
265		243
266	vmw_ldu_del_active(dev_priv, ldu);	244	vmw_ldu_del_active(dev_priv, ldu);
267		245
268	vmw_ldu_commit_list(dev_priv);	246	return vmw_ldu_commit_list(dev_priv);
269
270	return 0;
271	}	247	}
272		248
273		249
@@ -292,21 +268,20 @@ static int vmw_ldu_crtc_set_config(struct drm_mode_set *set)
292		268
293	vmw_ldu_add_active(dev_priv, ldu, vfb);	269	vmw_ldu_add_active(dev_priv, ldu, vfb);
294		270
295	vmw_ldu_commit_list(dev_priv);	271	return vmw_ldu_commit_list(dev_priv);
296
297	return 0;
298	}	272	}
299		273
300	static struct drm_crtc_funcs vmw_legacy_crtc_funcs = {	274	static struct drm_crtc_funcs vmw_legacy_crtc_funcs = {
301	.save = vmw_ldu_crtc_save,	275	.save = vmw_du_crtc_save,
302	.restore = vmw_ldu_crtc_restore,	276	.restore = vmw_du_crtc_restore,
303	.cursor_set = vmw_du_crtc_cursor_set,	277	.cursor_set = vmw_du_crtc_cursor_set,
304	.cursor_move = vmw_du_crtc_cursor_move,	278	.cursor_move = vmw_du_crtc_cursor_move,
305	.gamma_set = vmw_ldu_crtc_gamma_set,	279	.gamma_set = vmw_du_crtc_gamma_set,
306	.destroy = vmw_ldu_crtc_destroy,	280	.destroy = vmw_ldu_crtc_destroy,
307	.set_config = vmw_ldu_crtc_set_config,	281	.set_config = vmw_ldu_crtc_set_config,
308	};	282	};
309		283
		284
310	/*	285	/*
311	* Legacy Display Unit encoder functions	286	* Legacy Display Unit encoder functions
312	*/	287	*/
@@ -324,183 +299,18 @@ static struct drm_encoder_funcs vmw_legacy_encoder_funcs = {
324	* Legacy Display Unit connector functions	299	* Legacy Display Unit connector functions
325	*/	300	*/
326		301
327	static void vmw_ldu_connector_dpms(struct drm_connector *connector, int mode)
328	{
329	}
330
331	static void vmw_ldu_connector_save(struct drm_connector *connector)
332	{
333	}
334
335	static void vmw_ldu_connector_restore(struct drm_connector *connector)
336	{
337	}
338
339	static enum drm_connector_status
340	vmw_ldu_connector_detect(struct drm_connector *connector,
341	bool force)
342	{
343	if (vmw_connector_to_ldu(connector)->pref_active)
344	return connector_status_connected;
345	return connector_status_disconnected;
346	}
347
348	static const struct drm_display_mode vmw_ldu_connector_builtin[] = {
349	/* 640x480@60Hz */
350	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
351	752, 800, 0, 480, 489, 492, 525, 0,
352	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_NVSYNC) },
353	/* 800x600@60Hz */
354	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
355	968, 1056, 0, 600, 601, 605, 628, 0,
356	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
357	/* 1024x768@60Hz */
358	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
359	1184, 1344, 0, 768, 771, 777, 806, 0,
360	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_NVSYNC) },
361	/* 1152x864@75Hz */
362	{ DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
363	1344, 1600, 0, 864, 865, 868, 900, 0,
364	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
365	/* 1280x768@60Hz */
366	{ DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
367	1472, 1664, 0, 768, 771, 778, 798, 0,
368	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
369	/* 1280x800@60Hz */
370	{ DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
371	1480, 1680, 0, 800, 803, 809, 831, 0,
372	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_NVSYNC) },
373	/* 1280x960@60Hz */
374	{ DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
375	1488, 1800, 0, 960, 961, 964, 1000, 0,
376	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
377	/* 1280x1024@60Hz */
378	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
379	1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
380	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
381	/* 1360x768@60Hz */
382	{ DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
383	1536, 1792, 0, 768, 771, 777, 795, 0,
384	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
385	/* 1440x1050@60Hz */
386	{ DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
387	1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
388	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
389	/* 1440x900@60Hz */
390	{ DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
391	1672, 1904, 0, 900, 903, 909, 934, 0,
392	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
393	/* 1600x1200@60Hz */
394	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
395	1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
396	DRM_MODE_FLAG_PHSYNC \| DRM_MODE_FLAG_PVSYNC) },
397	/* 1680x1050@60Hz */
398	{ DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
399	1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
400	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
401	/* 1792x1344@60Hz */
402	{ DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
403	2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
404	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
405	/* 1853x1392@60Hz */
406	{ DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
407	2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
408	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
409	/* 1920x1200@60Hz */
410	{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
411	2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
412	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
413	/* 1920x1440@60Hz */
414	{ DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
415	2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
416	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
417	/* 2560x1600@60Hz */
418	{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
419	3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
420	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC) },
421	/* Terminate */
422	{ DRM_MODE("", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) },
423	};
424
425	static int vmw_ldu_connector_fill_modes(struct drm_connector *connector,
426	uint32_t max_width, uint32_t max_height)
427	{
428	struct vmw_legacy_display_unit *ldu = vmw_connector_to_ldu(connector);
429	struct drm_device *dev = connector->dev;
430	struct vmw_private *dev_priv = vmw_priv(dev);
431	struct drm_display_mode *mode = NULL;
432	struct drm_display_mode prefmode = { DRM_MODE("preferred",
433	DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED,
434	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
435	DRM_MODE_FLAG_NHSYNC \| DRM_MODE_FLAG_PVSYNC)
436	};
437	int i;
438
439	/* Add preferred mode */
440	{
441	mode = drm_mode_duplicate(dev, &prefmode);
442	if (!mode)
443	return 0;
444	mode->hdisplay = ldu->pref_width;
445	mode->vdisplay = ldu->pref_height;
446	mode->vrefresh = drm_mode_vrefresh(mode);
447	if (vmw_kms_validate_mode_vram(dev_priv, mode->hdisplay * 2,
448	mode->vdisplay)) {
449	drm_mode_probed_add(connector, mode);
450
451	if (ldu->pref_mode) {
452	list_del_init(&ldu->pref_mode->head);
453	drm_mode_destroy(dev, ldu->pref_mode);
454	}
455
456	ldu->pref_mode = mode;
457	}
458	}
459
460	for (i = 0; vmw_ldu_connector_builtin[i].type != 0; i++) {
461	const struct drm_display_mode *bmode;
462
463	bmode = &vmw_ldu_connector_builtin[i];
464	if (bmode->hdisplay > max_width \|\|
465	bmode->vdisplay > max_height)
466	continue;
467
468	if (!vmw_kms_validate_mode_vram(dev_priv, bmode->hdisplay * 2,
469	bmode->vdisplay))
470	continue;
471
472	mode = drm_mode_duplicate(dev, bmode);
473	if (!mode)
474	return 0;
475	mode->vrefresh = drm_mode_vrefresh(mode);
476
477	drm_mode_probed_add(connector, mode);
478	}
479
480	drm_mode_connector_list_update(connector);
481
482	return 1;
483	}
484
485	static int vmw_ldu_connector_set_property(struct drm_connector *connector,
486	struct drm_property *property,
487	uint64_t val)
488	{
489	return 0;
490	}
491
492	static void vmw_ldu_connector_destroy(struct drm_connector *connector)	302	static void vmw_ldu_connector_destroy(struct drm_connector *connector)
493	{	303	{
494	vmw_ldu_destroy(vmw_connector_to_ldu(connector));	304	vmw_ldu_destroy(vmw_connector_to_ldu(connector));
495	}	305	}
496		306
497	static struct drm_connector_funcs vmw_legacy_connector_funcs = {	307	static struct drm_connector_funcs vmw_legacy_connector_funcs = {
498	.dpms = vmw_ldu_connector_dpms,	308	.dpms = vmw_du_connector_dpms,
499	.save = vmw_ldu_connector_save,	309	.save = vmw_du_connector_save,
500	.restore = vmw_ldu_connector_restore,	310	.restore = vmw_du_connector_restore,
501	.detect = vmw_ldu_connector_detect,	311	.detect = vmw_du_connector_detect,
502	.fill_modes = vmw_ldu_connector_fill_modes,	312	.fill_modes = vmw_du_connector_fill_modes,
503	.set_property = vmw_ldu_connector_set_property,	313	.set_property = vmw_du_connector_set_property,
504	.destroy = vmw_ldu_connector_destroy,	314	.destroy = vmw_ldu_connector_destroy,
505	};	315	};
506		316
@@ -523,14 +333,14 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
523		333
524	INIT_LIST_HEAD(&ldu->active);	334	INIT_LIST_HEAD(&ldu->active);
525		335
526	ldu->pref_active = (unit == 0);	336	ldu->base.pref_active = (unit == 0);
527	ldu->pref_width = 800;	337	ldu->base.pref_width = 800;
528	ldu->pref_height = 600;	338	ldu->base.pref_height = 600;
529	ldu->pref_mode = NULL;	339	ldu->base.pref_mode = NULL;
530		340
531	drm_connector_init(dev, connector, &vmw_legacy_connector_funcs,	341	drm_connector_init(dev, connector, &vmw_legacy_connector_funcs,
532	DRM_MODE_CONNECTOR_LVDS);	342	DRM_MODE_CONNECTOR_LVDS);
533	connector->status = vmw_ldu_connector_detect(connector, true);	343	connector->status = vmw_du_connector_detect(connector, true);
534		344
535	drm_encoder_init(dev, encoder, &vmw_legacy_encoder_funcs,	345	drm_encoder_init(dev, encoder, &vmw_legacy_encoder_funcs,
536	DRM_MODE_ENCODER_LVDS);	346	DRM_MODE_ENCODER_LVDS);
@@ -540,6 +350,8 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
540		350
541	drm_crtc_init(dev, crtc, &vmw_legacy_crtc_funcs);	351	drm_crtc_init(dev, crtc, &vmw_legacy_crtc_funcs);
542		352
		353	drm_mode_crtc_set_gamma_size(crtc, 256);
		354
543	drm_connector_attach_property(connector,	355	drm_connector_attach_property(connector,
544	dev->mode_config.dirty_info_property,	356	dev->mode_config.dirty_info_property,
545	1);	357	1);
@@ -550,8 +362,7 @@ static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit)
550	int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)	362	int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
551	{	363	{
552	struct drm_device *dev = dev_priv->dev;	364	struct drm_device *dev = dev_priv->dev;
553	int i;	365	int i, ret;
554	int ret;
555		366
556	if (dev_priv->ldu_priv) {	367	if (dev_priv->ldu_priv) {
557	DRM_INFO("ldu system already on\n");	368	DRM_INFO("ldu system already on\n");
@@ -559,7 +370,6 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
559	}	370	}
560		371
561	dev_priv->ldu_priv = kmalloc(sizeof(*dev_priv->ldu_priv), GFP_KERNEL);	372	dev_priv->ldu_priv = kmalloc(sizeof(*dev_priv->ldu_priv), GFP_KERNEL);
562
563	if (!dev_priv->ldu_priv)	373	if (!dev_priv->ldu_priv)
564	return -ENOMEM;	374	return -ENOMEM;
565		375
@@ -568,18 +378,31 @@ int vmw_kms_init_legacy_display_system(struct vmw_private *dev_priv)
568	dev_priv->ldu_priv->last_num_active = 0;	378	dev_priv->ldu_priv->last_num_active = 0;
569	dev_priv->ldu_priv->fb = NULL;	379	dev_priv->ldu_priv->fb = NULL;
570		380
571	drm_mode_create_dirty_info_property(dev_priv->dev);	381	/* for old hardware without multimon only enable one display */
		382	if (dev_priv->capabilities & SVGA_CAP_MULTIMON)
		383	ret = drm_vblank_init(dev, VMWGFX_NUM_DISPLAY_UNITS);
		384	else
		385	ret = drm_vblank_init(dev, 1);
		386	if (ret != 0)
		387	goto err_free;
		388
		389	ret = drm_mode_create_dirty_info_property(dev);
		390	if (ret != 0)
		391	goto err_vblank_cleanup;
572		392
573	if (dev_priv->capabilities & SVGA_CAP_MULTIMON) {	393	if (dev_priv->capabilities & SVGA_CAP_MULTIMON)
574	for (i = 0; i < VMWGFX_LDU_NUM_DU; ++i)	394	for (i = 0; i < VMWGFX_NUM_DISPLAY_UNITS; ++i)
575	vmw_ldu_init(dev_priv, i);	395	vmw_ldu_init(dev_priv, i);
576	ret = drm_vblank_init(dev, VMWGFX_LDU_NUM_DU);	396	else
577	} else {
578	/* for old hardware without multimon only enable one display */
579	vmw_ldu_init(dev_priv, 0);	397	vmw_ldu_init(dev_priv, 0);
580	ret = drm_vblank_init(dev, 1);
581	}
582		398
		399	return 0;
		400
		401	err_vblank_cleanup:
		402	drm_vblank_cleanup(dev);
		403	err_free:
		404	kfree(dev_priv->ldu_priv);
		405	dev_priv->ldu_priv = NULL;
583	return ret;	406	return ret;
584	}	407	}
585		408
@@ -587,52 +410,14 @@ int vmw_kms_close_legacy_display_system(struct vmw_private *dev_priv)
587	{	410	{
588	struct drm_device *dev = dev_priv->dev;	411	struct drm_device *dev = dev_priv->dev;
589		412
590	drm_vblank_cleanup(dev);
591	if (!dev_priv->ldu_priv)	413	if (!dev_priv->ldu_priv)
592	return -ENOSYS;	414	return -ENOSYS;
593		415
		416	drm_vblank_cleanup(dev);
		417
594	BUG_ON(!list_empty(&dev_priv->ldu_priv->active));	418	BUG_ON(!list_empty(&dev_priv->ldu_priv->active));
595		419
596	kfree(dev_priv->ldu_priv);	420	kfree(dev_priv->ldu_priv);
597		421
598	return 0;	422	return 0;
599	}	423	}
600
601	int vmw_kms_ldu_update_layout(struct vmw_private *dev_priv, unsigned num,
602	struct drm_vmw_rect *rects)
603	{
604	struct drm_device *dev = dev_priv->dev;
605	struct vmw_legacy_display_unit *ldu;
606	struct drm_connector *con;
607	int i;
608
609	mutex_lock(&dev->mode_config.mutex);
610
611	#if 0
612	DRM_INFO("%s: new layout ", __func__);
613	for (i = 0; i < (int)num; i++)
614	DRM_INFO("(%i, %i %ux%u) ", rects[i].x, rects[i].y,
615	rects[i].w, rects[i].h);
616	DRM_INFO("\n");
617	#else
618	(void)i;
619	#endif
620
621	list_for_each_entry(con, &dev->mode_config.connector_list, head) {
622	ldu = vmw_connector_to_ldu(con);
623	if (num > ldu->base.unit) {
624	ldu->pref_width = rects[ldu->base.unit].w;
625	ldu->pref_height = rects[ldu->base.unit].h;
626	ldu->pref_active = true;
627	} else {
628	ldu->pref_width = 800;
629	ldu->pref_height = 600;
630	ldu->pref_active = false;
631	}
632	con->status = vmw_ldu_connector_detect(con, true);
633	}
634
635	mutex_unlock(&dev->mode_config.mutex);
636
637	return 0;
638	}