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) */ 18 enum 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 26 const 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 48 static 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 58 void 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 109 static 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 117 static 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 135 static 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 155 void 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 174 struct 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 }; 183