mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Benjamin Gaignard](/assets/img/avatar_default.png)
Make sti driver use register callback to move debugfs initialization out of sub-components creation. This will allow to convert driver .load() to drm_dev_alloc() and drm_dev_register(). sti_compositor bring up 2 crtc but only one debugfs init is needed so use drm_crtc_index to do it on the first one. This can't be done in sti_drv because only sti_compositor have access to the devices. It is almost the same for sti_encoder which handle multiple encoder while one only debugfs entry is needed so add a boolean to avoid multiple debugfs initialization Signed-off-by: Benjamin Gaignard <benjamin.gaignard@linaro.org> Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch> Link: http://patchwork.freedesktop.org/patch/msgid/1466514580-15194-3-git-send-email-benjamin.gaignard@linaro.org
164 lines
4 KiB
C
164 lines
4 KiB
C
/*
|
|
* Copyright (C) STMicroelectronics SA 2014
|
|
* Authors: Benjamin Gaignard <benjamin.gaignard@st.com>
|
|
* Fabien Dessenne <fabien.dessenne@st.com>
|
|
* for STMicroelectronics.
|
|
* License terms: GNU General Public License (GPL), version 2
|
|
*/
|
|
|
|
#include <drm/drmP.h>
|
|
#include <drm/drm_fb_cma_helper.h>
|
|
#include <drm/drm_gem_cma_helper.h>
|
|
|
|
#include "sti_compositor.h"
|
|
#include "sti_drv.h"
|
|
#include "sti_plane.h"
|
|
|
|
/* (Background) < GDP0 < GDP1 < HQVDP0 < GDP2 < GDP3 < (ForeGround) */
|
|
enum sti_plane_desc sti_plane_default_zorder[] = {
|
|
STI_GDP_0,
|
|
STI_GDP_1,
|
|
STI_HQVDP_0,
|
|
STI_GDP_2,
|
|
STI_GDP_3,
|
|
};
|
|
|
|
const char *sti_plane_to_str(struct sti_plane *plane)
|
|
{
|
|
switch (plane->desc) {
|
|
case STI_GDP_0:
|
|
return "GDP0";
|
|
case STI_GDP_1:
|
|
return "GDP1";
|
|
case STI_GDP_2:
|
|
return "GDP2";
|
|
case STI_GDP_3:
|
|
return "GDP3";
|
|
case STI_HQVDP_0:
|
|
return "HQVDP0";
|
|
case STI_CURSOR:
|
|
return "CURSOR";
|
|
default:
|
|
return "<UNKNOWN PLANE>";
|
|
}
|
|
}
|
|
|
|
#define STI_FPS_INTERVAL_MS 3000
|
|
|
|
static int sti_plane_timespec_ms_diff(struct timespec lhs, struct timespec rhs)
|
|
{
|
|
struct timespec tmp_ts = timespec_sub(lhs, rhs);
|
|
u64 tmp_ns = (u64)timespec_to_ns(&tmp_ts);
|
|
|
|
do_div(tmp_ns, NSEC_PER_MSEC);
|
|
|
|
return (u32)tmp_ns;
|
|
}
|
|
|
|
void sti_plane_update_fps(struct sti_plane *plane,
|
|
bool new_frame,
|
|
bool new_field)
|
|
{
|
|
struct timespec now;
|
|
struct sti_fps_info *fps;
|
|
int fpks, fipks, ms_since_last, num_frames, num_fields;
|
|
|
|
getrawmonotonic(&now);
|
|
|
|
/* Compute number of frame updates */
|
|
fps = &plane->fps_info;
|
|
|
|
if (new_field)
|
|
fps->curr_field_counter++;
|
|
|
|
/* do not perform fps calcul if new_frame is false */
|
|
if (!new_frame)
|
|
return;
|
|
|
|
fps->curr_frame_counter++;
|
|
ms_since_last = sti_plane_timespec_ms_diff(now, fps->last_timestamp);
|
|
num_frames = fps->curr_frame_counter - fps->last_frame_counter;
|
|
|
|
if (num_frames <= 0 || ms_since_last < STI_FPS_INTERVAL_MS)
|
|
return;
|
|
|
|
fps->last_timestamp = now;
|
|
fps->last_frame_counter = fps->curr_frame_counter;
|
|
fpks = (num_frames * 1000000) / ms_since_last;
|
|
snprintf(plane->fps_info.fps_str, FPS_LENGTH, "%-6s @ %d.%.3d fps",
|
|
sti_plane_to_str(plane), fpks / 1000, fpks % 1000);
|
|
|
|
if (fps->curr_field_counter) {
|
|
/* Compute number of field updates */
|
|
num_fields = fps->curr_field_counter - fps->last_field_counter;
|
|
fps->last_field_counter = fps->curr_field_counter;
|
|
fipks = (num_fields * 1000000) / ms_since_last;
|
|
snprintf(plane->fps_info.fips_str,
|
|
FPS_LENGTH, " - %d.%.3d field/sec",
|
|
fipks / 1000, fipks % 1000);
|
|
} else {
|
|
plane->fps_info.fips_str[0] = '\0';
|
|
}
|
|
|
|
if (fps->output)
|
|
DRM_INFO("%s%s\n",
|
|
plane->fps_info.fps_str,
|
|
plane->fps_info.fips_str);
|
|
}
|
|
|
|
int sti_plane_set_property(struct drm_plane *drm_plane,
|
|
struct drm_property *property,
|
|
uint64_t val)
|
|
{
|
|
struct drm_device *dev = drm_plane->dev;
|
|
struct sti_private *private = dev->dev_private;
|
|
struct sti_plane *plane = to_sti_plane(drm_plane);
|
|
|
|
DRM_DEBUG_DRIVER("\n");
|
|
|
|
if (property == private->plane_zorder_property) {
|
|
plane->zorder = val;
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
|
|
{
|
|
struct drm_device *dev = drm_plane->dev;
|
|
struct sti_private *private = dev->dev_private;
|
|
struct sti_plane *plane = to_sti_plane(drm_plane);
|
|
struct drm_property *prop;
|
|
|
|
prop = private->plane_zorder_property;
|
|
if (!prop) {
|
|
prop = drm_property_create_range(dev, 0, "zpos", 1,
|
|
GAM_MIXER_NB_DEPTH_LEVEL);
|
|
if (!prop)
|
|
return;
|
|
|
|
private->plane_zorder_property = prop;
|
|
}
|
|
|
|
drm_object_attach_property(&drm_plane->base, prop, plane->zorder);
|
|
}
|
|
|
|
void sti_plane_init_property(struct sti_plane *plane,
|
|
enum drm_plane_type type)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sti_plane_default_zorder); i++)
|
|
if (sti_plane_default_zorder[i] == plane->desc)
|
|
break;
|
|
|
|
plane->zorder = i + 1;
|
|
|
|
if (type == DRM_PLANE_TYPE_OVERLAY)
|
|
sti_plane_attach_zorder_property(&plane->drm_plane);
|
|
|
|
DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%d\n",
|
|
plane->drm_plane.base.id,
|
|
sti_plane_to_str(plane), plane->zorder);
|
|
}
|