Loading...
1/*
2 * Copyright (C) STMicroelectronics SA 2014
3 * Authors: Benjamin Gaignard <benjamin.gaignard@st.com>
4 * Fabien Dessenne <fabien.dessenne@st.com>
5 * for STMicroelectronics.
6 * License terms: GNU General Public License (GPL), version 2
7 */
8
9#include <drm/drmP.h>
10#include <drm/drm_fb_cma_helper.h>
11#include <drm/drm_gem_cma_helper.h>
12
13#include "sti_compositor.h"
14#include "sti_drv.h"
15#include "sti_plane.h"
16
17/* (Background) < GDP0 < GDP1 < HQVDP0 < GDP2 < GDP3 < (ForeGround) */
18enum sti_plane_desc sti_plane_default_zorder[] = {
19 STI_GDP_0,
20 STI_GDP_1,
21 STI_HQVDP_0,
22 STI_GDP_2,
23 STI_GDP_3,
24};
25
26const char *sti_plane_to_str(struct sti_plane *plane)
27{
28 switch (plane->desc) {
29 case STI_GDP_0:
30 return "GDP0";
31 case STI_GDP_1:
32 return "GDP1";
33 case STI_GDP_2:
34 return "GDP2";
35 case STI_GDP_3:
36 return "GDP3";
37 case STI_HQVDP_0:
38 return "HQVDP0";
39 case STI_CURSOR:
40 return "CURSOR";
41 default:
42 return "<UNKNOWN PLANE>";
43 }
44}
45
46#define STI_FPS_INTERVAL_MS 3000
47
48static int sti_plane_timespec_ms_diff(struct timespec lhs, struct timespec rhs)
49{
50 struct timespec tmp_ts = timespec_sub(lhs, rhs);
51 u64 tmp_ns = (u64)timespec_to_ns(&tmp_ts);
52
53 do_div(tmp_ns, NSEC_PER_MSEC);
54
55 return (u32)tmp_ns;
56}
57
58void sti_plane_update_fps(struct sti_plane *plane,
59 bool new_frame,
60 bool new_field)
61{
62 struct timespec now;
63 struct sti_fps_info *fps;
64 int fpks, fipks, ms_since_last, num_frames, num_fields;
65
66 getrawmonotonic(&now);
67
68 /* Compute number of frame updates */
69 fps = &plane->fps_info;
70
71 if (new_field)
72 fps->curr_field_counter++;
73
74 /* do not perform fps calcul if new_frame is false */
75 if (!new_frame)
76 return;
77
78 fps->curr_frame_counter++;
79 ms_since_last = sti_plane_timespec_ms_diff(now, fps->last_timestamp);
80 num_frames = fps->curr_frame_counter - fps->last_frame_counter;
81
82 if (num_frames <= 0 || ms_since_last < STI_FPS_INTERVAL_MS)
83 return;
84
85 fps->last_timestamp = now;
86 fps->last_frame_counter = fps->curr_frame_counter;
87 fpks = (num_frames * 1000000) / ms_since_last;
88 snprintf(plane->fps_info.fps_str, FPS_LENGTH, "%-6s @ %d.%.3d fps",
89 sti_plane_to_str(plane), fpks / 1000, fpks % 1000);
90
91 if (fps->curr_field_counter) {
92 /* Compute number of field updates */
93 num_fields = fps->curr_field_counter - fps->last_field_counter;
94 fps->last_field_counter = fps->curr_field_counter;
95 fipks = (num_fields * 1000000) / ms_since_last;
96 snprintf(plane->fps_info.fips_str,
97 FPS_LENGTH, " - %d.%.3d field/sec",
98 fipks / 1000, fipks % 1000);
99 } else {
100 plane->fps_info.fips_str[0] = '\0';
101 }
102
103 if (fps->output)
104 DRM_INFO("%s%s\n",
105 plane->fps_info.fps_str,
106 plane->fps_info.fips_str);
107}
108
109static void sti_plane_destroy(struct drm_plane *drm_plane)
110{
111 DRM_DEBUG_DRIVER("\n");
112
113 drm_plane_helper_disable(drm_plane);
114 drm_plane_cleanup(drm_plane);
115}
116
117static int sti_plane_set_property(struct drm_plane *drm_plane,
118 struct drm_property *property,
119 uint64_t val)
120{
121 struct drm_device *dev = drm_plane->dev;
122 struct sti_private *private = dev->dev_private;
123 struct sti_plane *plane = to_sti_plane(drm_plane);
124
125 DRM_DEBUG_DRIVER("\n");
126
127 if (property == private->plane_zorder_property) {
128 plane->zorder = val;
129 return 0;
130 }
131
132 return -EINVAL;
133}
134
135static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
136{
137 struct drm_device *dev = drm_plane->dev;
138 struct sti_private *private = dev->dev_private;
139 struct sti_plane *plane = to_sti_plane(drm_plane);
140 struct drm_property *prop;
141
142 prop = private->plane_zorder_property;
143 if (!prop) {
144 prop = drm_property_create_range(dev, 0, "zpos", 1,
145 GAM_MIXER_NB_DEPTH_LEVEL);
146 if (!prop)
147 return;
148
149 private->plane_zorder_property = prop;
150 }
151
152 drm_object_attach_property(&drm_plane->base, prop, plane->zorder);
153}
154
155void sti_plane_init_property(struct sti_plane *plane,
156 enum drm_plane_type type)
157{
158 unsigned int i;
159
160 for (i = 0; i < ARRAY_SIZE(sti_plane_default_zorder); i++)
161 if (sti_plane_default_zorder[i] == plane->desc)
162 break;
163
164 plane->zorder = i + 1;
165
166 if (type == DRM_PLANE_TYPE_OVERLAY)
167 sti_plane_attach_zorder_property(&plane->drm_plane);
168
169 DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%d\n",
170 plane->drm_plane.base.id,
171 sti_plane_to_str(plane), plane->zorder);
172}
173
174struct drm_plane_funcs sti_plane_helpers_funcs = {
175 .update_plane = drm_atomic_helper_update_plane,
176 .disable_plane = drm_atomic_helper_disable_plane,
177 .destroy = sti_plane_destroy,
178 .set_property = sti_plane_set_property,
179 .reset = drm_atomic_helper_plane_reset,
180 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
181 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
182};
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) STMicroelectronics SA 2014
4 * Authors: Benjamin Gaignard <benjamin.gaignard@st.com>
5 * Fabien Dessenne <fabien.dessenne@st.com>
6 * for STMicroelectronics.
7 */
8
9#include <linux/types.h>
10
11#include <drm/drm_fb_cma_helper.h>
12#include <drm/drm_fourcc.h>
13#include <drm/drm_gem_cma_helper.h>
14
15#include "sti_compositor.h"
16#include "sti_drv.h"
17#include "sti_plane.h"
18
19const char *sti_plane_to_str(struct sti_plane *plane)
20{
21 switch (plane->desc) {
22 case STI_GDP_0:
23 return "GDP0";
24 case STI_GDP_1:
25 return "GDP1";
26 case STI_GDP_2:
27 return "GDP2";
28 case STI_GDP_3:
29 return "GDP3";
30 case STI_HQVDP_0:
31 return "HQVDP0";
32 case STI_CURSOR:
33 return "CURSOR";
34 default:
35 return "<UNKNOWN PLANE>";
36 }
37}
38
39#define STI_FPS_INTERVAL_MS 3000
40
41void sti_plane_update_fps(struct sti_plane *plane,
42 bool new_frame,
43 bool new_field)
44{
45 struct drm_plane_state *state = plane->drm_plane.state;
46 ktime_t now;
47 struct sti_fps_info *fps;
48 int fpks, fipks, ms_since_last, num_frames, num_fields;
49
50 now = ktime_get();
51
52 /* Compute number of frame updates */
53 fps = &plane->fps_info;
54
55 if (new_field)
56 fps->curr_field_counter++;
57
58 /* do not perform fps calcul if new_frame is false */
59 if (!new_frame)
60 return;
61
62 fps->curr_frame_counter++;
63 ms_since_last = ktime_to_ms(ktime_sub(now, fps->last_timestamp));
64 num_frames = fps->curr_frame_counter - fps->last_frame_counter;
65
66 if (num_frames <= 0 || ms_since_last < STI_FPS_INTERVAL_MS)
67 return;
68
69 fps->last_timestamp = now;
70 fps->last_frame_counter = fps->curr_frame_counter;
71
72 if (state->fb) {
73 fpks = (num_frames * 1000000) / ms_since_last;
74 snprintf(plane->fps_info.fps_str, FPS_LENGTH,
75 "%-8s %4dx%-4d %.4s @ %3d.%-3.3d fps (%s)",
76 plane->drm_plane.name,
77 state->fb->width,
78 state->fb->height,
79 (char *)&state->fb->format->format,
80 fpks / 1000, fpks % 1000,
81 sti_plane_to_str(plane));
82 }
83
84 if (fps->curr_field_counter) {
85 /* Compute number of field updates */
86 num_fields = fps->curr_field_counter - fps->last_field_counter;
87 fps->last_field_counter = fps->curr_field_counter;
88 fipks = (num_fields * 1000000) / ms_since_last;
89 snprintf(plane->fps_info.fips_str,
90 FPS_LENGTH, " - %3d.%-3.3d field/sec",
91 fipks / 1000, fipks % 1000);
92 } else {
93 plane->fps_info.fips_str[0] = '\0';
94 }
95
96 if (fps->output)
97 DRM_INFO("%s%s\n",
98 plane->fps_info.fps_str,
99 plane->fps_info.fips_str);
100}
101
102static int sti_plane_get_default_zpos(enum drm_plane_type type)
103{
104 switch (type) {
105 case DRM_PLANE_TYPE_PRIMARY:
106 return 0;
107 case DRM_PLANE_TYPE_OVERLAY:
108 return 1;
109 case DRM_PLANE_TYPE_CURSOR:
110 return 7;
111 }
112 return 0;
113}
114
115void sti_plane_reset(struct drm_plane *plane)
116{
117 drm_atomic_helper_plane_reset(plane);
118 plane->state->zpos = sti_plane_get_default_zpos(plane->type);
119}
120
121static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane,
122 enum drm_plane_type type)
123{
124 int zpos = sti_plane_get_default_zpos(type);
125
126 switch (type) {
127 case DRM_PLANE_TYPE_PRIMARY:
128 case DRM_PLANE_TYPE_OVERLAY:
129 drm_plane_create_zpos_property(drm_plane, zpos, 0, 6);
130 break;
131 case DRM_PLANE_TYPE_CURSOR:
132 drm_plane_create_zpos_immutable_property(drm_plane, zpos);
133 break;
134 }
135}
136
137void sti_plane_init_property(struct sti_plane *plane,
138 enum drm_plane_type type)
139{
140 sti_plane_attach_zorder_property(&plane->drm_plane, type);
141
142 DRM_DEBUG_DRIVER("drm plane:%d mapped to %s\n",
143 plane->drm_plane.base.id, sti_plane_to_str(plane));
144}