Code Review / kvmfornfv.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
These changes are the raw update to linux-4.4.6-rt14. Kernel sources
[kvmfornfv.git] / kernel / drivers / gpu / drm / sti / sti_mixer.c
diff --git a/kernel/drivers/gpu/drm/sti/sti_mixer.c b/kernel/drivers/gpu/drm/sti/sti_mixer.c
index 13a4b84..49db835 100644 (file)
--- a/kernel/drivers/gpu/drm/sti/sti_mixer.c
+++ b/kernel/drivers/gpu/drm/sti/sti_mixer.c
@@ -10,6 +10,11 @@
 #include "sti_mixer.h"
 #include "sti_vtg.h"
 
+/* Module parameter to set the background color of the mixer */
+static unsigned int bkg_color = 0x000000;
+MODULE_PARM_DESC(bkgcolor, "Value of the background color 0xRRGGBB");
+module_param_named(bkgcolor, bkg_color, int, 0644);
+
 /* Identity: G=Y , B=Cb , R=Cr */
 static const u32 mixerColorSpaceMatIdentity[] = {
        0x10000000, 0x00000000, 0x10000000, 0x00001000,
@@ -80,11 +85,9 @@ void sti_mixer_set_background_status(struct sti_mixer *mixer, bool enable)
 }
 
 static void sti_mixer_set_background_color(struct sti_mixer *mixer,
-                                          u8 red, u8 green, u8 blue)
+                                          unsigned int rgb)
 {
-       u32 val = (red << 16) | (green << 8) | blue;
-
-       sti_mixer_reg_write(mixer, GAM_MIXER_BKC, val);
+       sti_mixer_reg_write(mixer, GAM_MIXER_BKC, rgb);
 }
 
 static void sti_mixer_set_background_area(struct sti_mixer *mixer,
@@ -101,52 +104,57 @@ static void sti_mixer_set_background_area(struct sti_mixer *mixer,
        sti_mixer_reg_write(mixer, GAM_MIXER_BCS, yds << 16 | xds);
 }
 
-int sti_mixer_set_layer_depth(struct sti_mixer *mixer, struct sti_layer *layer)
+int sti_mixer_set_plane_depth(struct sti_mixer *mixer, struct sti_plane *plane)
 {
-       int layer_id = 0, depth = layer->zorder;
+       int plane_id, depth = plane->zorder;
+       unsigned int i;
        u32 mask, val;
 
-       if (depth >= GAM_MIXER_NB_DEPTH_LEVEL)
+       if ((depth < 1) || (depth > GAM_MIXER_NB_DEPTH_LEVEL))
                return 1;
 
-       switch (layer->desc) {
+       switch (plane->desc) {
        case STI_GDP_0:
-               layer_id = GAM_DEPTH_GDP0_ID;
+               plane_id = GAM_DEPTH_GDP0_ID;
                break;
        case STI_GDP_1:
-               layer_id = GAM_DEPTH_GDP1_ID;
+               plane_id = GAM_DEPTH_GDP1_ID;
                break;
        case STI_GDP_2:
-               layer_id = GAM_DEPTH_GDP2_ID;
+               plane_id = GAM_DEPTH_GDP2_ID;
                break;
        case STI_GDP_3:
-               layer_id = GAM_DEPTH_GDP3_ID;
+               plane_id = GAM_DEPTH_GDP3_ID;
                break;
-       case STI_VID_0:
        case STI_HQVDP_0:
-               layer_id = GAM_DEPTH_VID0_ID;
-               break;
-       case STI_VID_1:
-               layer_id = GAM_DEPTH_VID1_ID;
+               plane_id = GAM_DEPTH_VID0_ID;
                break;
        case STI_CURSOR:
                /* no need to set depth for cursor */
                return 0;
        default:
-               DRM_ERROR("Unknown layer %d\n", layer->desc);
+               DRM_ERROR("Unknown plane %d\n", plane->desc);
                return 1;
        }
-       mask = GAM_DEPTH_MASK_ID << (3 * depth);
-       layer_id = layer_id << (3 * depth);
+
+       /* Search if a previous depth was already assigned to the plane */
+       val = sti_mixer_reg_read(mixer, GAM_MIXER_CRB);
+       for (i = 0; i < GAM_MIXER_NB_DEPTH_LEVEL; i++) {
+               mask = GAM_DEPTH_MASK_ID << (3 * i);
+               if ((val & mask) == plane_id << (3 * i))
+                       break;
+       }
+
+       mask |= GAM_DEPTH_MASK_ID << (3 * (depth - 1));
+       plane_id = plane_id << (3 * (depth - 1));
 
        DRM_DEBUG_DRIVER("%s %s depth=%d\n", sti_mixer_to_str(mixer),
-                        sti_layer_to_str(layer), depth);
+                        sti_plane_to_str(plane), depth);
        dev_dbg(mixer->dev, "GAM_MIXER_CRB val 0x%x mask 0x%x\n",
-               layer_id, mask);
+               plane_id, mask);
 
-       val = sti_mixer_reg_read(mixer, GAM_MIXER_CRB);
        val &= ~mask;
-       val |= layer_id;
+       val |= plane_id;
        sti_mixer_reg_write(mixer, GAM_MIXER_CRB, val);
 
        dev_dbg(mixer->dev, "Read GAM_MIXER_CRB 0x%x\n",
@@ -169,16 +177,16 @@ int sti_mixer_active_video_area(struct sti_mixer *mixer,
        sti_mixer_reg_write(mixer, GAM_MIXER_AVO, ydo << 16 | xdo);
        sti_mixer_reg_write(mixer, GAM_MIXER_AVS, yds << 16 | xds);
 
-       sti_mixer_set_background_color(mixer, 0xFF, 0, 0);
+       sti_mixer_set_background_color(mixer, bkg_color);
 
        sti_mixer_set_background_area(mixer, mode);
        sti_mixer_set_background_status(mixer, true);
        return 0;
 }
 
-static u32 sti_mixer_get_layer_mask(struct sti_layer *layer)
+static u32 sti_mixer_get_plane_mask(struct sti_plane *plane)
 {
-       switch (layer->desc) {
+       switch (plane->desc) {
        case STI_BACK:
                return GAM_CTL_BACK_MASK;
        case STI_GDP_0:
@@ -189,11 +197,8 @@ static u32 sti_mixer_get_layer_mask(struct sti_layer *layer)
                return GAM_CTL_GDP2_MASK;
        case STI_GDP_3:
                return GAM_CTL_GDP3_MASK;
-       case STI_VID_0:
        case STI_HQVDP_0:
                return GAM_CTL_VID0_MASK;
-       case STI_VID_1:
-               return GAM_CTL_VID1_MASK;
        case STI_CURSOR:
                return GAM_CTL_CURSOR_MASK;
        default:
@@ -201,17 +206,17 @@ static u32 sti_mixer_get_layer_mask(struct sti_layer *layer)
        }
 }
 
-int sti_mixer_set_layer_status(struct sti_mixer *mixer,
-                              struct sti_layer *layer, bool status)
+int sti_mixer_set_plane_status(struct sti_mixer *mixer,
+                              struct sti_plane *plane, bool status)
 {
        u32 mask, val;
 
        DRM_DEBUG_DRIVER("%s %s %s\n", status ? "enable" : "disable",
-                        sti_mixer_to_str(mixer), sti_layer_to_str(layer));
+                        sti_mixer_to_str(mixer), sti_plane_to_str(plane));
 
-       mask = sti_mixer_get_layer_mask(layer);
+       mask = sti_mixer_get_plane_mask(plane);
        if (!mask) {
-               DRM_ERROR("Can not find layer mask\n");
+               DRM_ERROR("Can't find layer mask\n");
                return -EINVAL;
        }
 
@@ -223,15 +228,6 @@ int sti_mixer_set_layer_status(struct sti_mixer *mixer,
        return 0;
 }
 
-void sti_mixer_clear_all_layers(struct sti_mixer *mixer)
-{
-       u32 val;
-
-       DRM_DEBUG_DRIVER("%s clear all layer\n", sti_mixer_to_str(mixer));
-       val = sti_mixer_reg_read(mixer, GAM_MIXER_CTL) & 0xFFFF0000;
-       sti_mixer_reg_write(mixer, GAM_MIXER_CTL, val);
-}
-
 void sti_mixer_set_matrix(struct sti_mixer *mixer)
 {
        unsigned int i;