omap_plane.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
  4. * Author: Rob Clark <rob.clark@linaro.org>
  5. */
  6. #include <drm/drm_atomic.h>
  7. #include <drm/drm_atomic_helper.h>
  8. #include <drm/drm_plane_helper.h>
  9. #include "omap_dmm_tiler.h"
  10. #include "omap_drv.h"
  11. /*
  12. * plane funcs
  13. */
  14. #define to_omap_plane(x) container_of(x, struct omap_plane, base)
  15. struct omap_plane {
  16. struct drm_plane base;
  17. enum omap_plane_id id;
  18. const char *name;
  19. };
  20. static int omap_plane_prepare_fb(struct drm_plane *plane,
  21. struct drm_plane_state *new_state)
  22. {
  23. if (!new_state->fb)
  24. return 0;
  25. return omap_framebuffer_pin(new_state->fb);
  26. }
  27. static void omap_plane_cleanup_fb(struct drm_plane *plane,
  28. struct drm_plane_state *old_state)
  29. {
  30. if (old_state->fb)
  31. omap_framebuffer_unpin(old_state->fb);
  32. }
  33. static void omap_plane_atomic_update(struct drm_plane *plane,
  34. struct drm_plane_state *old_state)
  35. {
  36. struct omap_drm_private *priv = plane->dev->dev_private;
  37. struct omap_plane *omap_plane = to_omap_plane(plane);
  38. struct drm_plane_state *state = plane->state;
  39. struct omap_overlay_info info;
  40. int ret;
  41. DBG("%s, crtc=%p fb=%p", omap_plane->name, state->crtc, state->fb);
  42. memset(&info, 0, sizeof(info));
  43. info.rotation_type = OMAP_DSS_ROT_NONE;
  44. info.rotation = DRM_MODE_ROTATE_0;
  45. info.global_alpha = state->alpha >> 8;
  46. info.zorder = state->normalized_zpos;
  47. if (state->pixel_blend_mode == DRM_MODE_BLEND_PREMULTI)
  48. info.pre_mult_alpha = 1;
  49. else
  50. info.pre_mult_alpha = 0;
  51. /* update scanout: */
  52. omap_framebuffer_update_scanout(state->fb, state, &info);
  53. DBG("%dx%d -> %dx%d (%d)", info.width, info.height,
  54. info.out_width, info.out_height,
  55. info.screen_width);
  56. DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
  57. &info.paddr, &info.p_uv_addr);
  58. /* and finally, update omapdss: */
  59. ret = priv->dispc_ops->ovl_setup(priv->dispc, omap_plane->id, &info,
  60. omap_crtc_timings(state->crtc), false,
  61. omap_crtc_channel(state->crtc));
  62. if (ret) {
  63. dev_err(plane->dev->dev, "Failed to setup plane %s\n",
  64. omap_plane->name);
  65. priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
  66. return;
  67. }
  68. priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, true);
  69. }
  70. static void omap_plane_atomic_disable(struct drm_plane *plane,
  71. struct drm_plane_state *old_state)
  72. {
  73. struct omap_drm_private *priv = plane->dev->dev_private;
  74. struct omap_plane *omap_plane = to_omap_plane(plane);
  75. plane->state->rotation = DRM_MODE_ROTATE_0;
  76. plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
  77. ? 0 : omap_plane->id;
  78. priv->dispc_ops->ovl_enable(priv->dispc, omap_plane->id, false);
  79. }
  80. static int omap_plane_atomic_check(struct drm_plane *plane,
  81. struct drm_plane_state *state)
  82. {
  83. struct drm_crtc_state *crtc_state;
  84. if (!state->fb)
  85. return 0;
  86. /* crtc should only be NULL when disabling (i.e., !state->fb) */
  87. if (WARN_ON(!state->crtc))
  88. return 0;
  89. crtc_state = drm_atomic_get_existing_crtc_state(state->state, state->crtc);
  90. /* we should have a crtc state if the plane is attached to a crtc */
  91. if (WARN_ON(!crtc_state))
  92. return 0;
  93. if (!crtc_state->enable)
  94. return 0;
  95. if (state->crtc_x < 0 || state->crtc_y < 0)
  96. return -EINVAL;
  97. if (state->crtc_x + state->crtc_w > crtc_state->adjusted_mode.hdisplay)
  98. return -EINVAL;
  99. if (state->crtc_y + state->crtc_h > crtc_state->adjusted_mode.vdisplay)
  100. return -EINVAL;
  101. if (state->rotation != DRM_MODE_ROTATE_0 &&
  102. !omap_framebuffer_supports_rotation(state->fb))
  103. return -EINVAL;
  104. return 0;
  105. }
  106. static const struct drm_plane_helper_funcs omap_plane_helper_funcs = {
  107. .prepare_fb = omap_plane_prepare_fb,
  108. .cleanup_fb = omap_plane_cleanup_fb,
  109. .atomic_check = omap_plane_atomic_check,
  110. .atomic_update = omap_plane_atomic_update,
  111. .atomic_disable = omap_plane_atomic_disable,
  112. };
  113. static void omap_plane_destroy(struct drm_plane *plane)
  114. {
  115. struct omap_plane *omap_plane = to_omap_plane(plane);
  116. DBG("%s", omap_plane->name);
  117. drm_plane_cleanup(plane);
  118. kfree(omap_plane);
  119. }
  120. /* helper to install properties which are common to planes and crtcs */
  121. void omap_plane_install_properties(struct drm_plane *plane,
  122. struct drm_mode_object *obj)
  123. {
  124. struct drm_device *dev = plane->dev;
  125. struct omap_drm_private *priv = dev->dev_private;
  126. if (priv->has_dmm) {
  127. if (!plane->rotation_property)
  128. drm_plane_create_rotation_property(plane,
  129. DRM_MODE_ROTATE_0,
  130. DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 |
  131. DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270 |
  132. DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y);
  133. /* Attach the rotation property also to the crtc object */
  134. if (plane->rotation_property && obj != &plane->base)
  135. drm_object_attach_property(obj, plane->rotation_property,
  136. DRM_MODE_ROTATE_0);
  137. }
  138. drm_object_attach_property(obj, priv->zorder_prop, 0);
  139. }
  140. static void omap_plane_reset(struct drm_plane *plane)
  141. {
  142. struct omap_plane *omap_plane = to_omap_plane(plane);
  143. drm_atomic_helper_plane_reset(plane);
  144. if (!plane->state)
  145. return;
  146. /*
  147. * Set the zpos default depending on whether we are a primary or overlay
  148. * plane.
  149. */
  150. plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
  151. ? 0 : omap_plane->id;
  152. }
  153. static int omap_plane_atomic_set_property(struct drm_plane *plane,
  154. struct drm_plane_state *state,
  155. struct drm_property *property,
  156. u64 val)
  157. {
  158. struct omap_drm_private *priv = plane->dev->dev_private;
  159. if (property == priv->zorder_prop)
  160. state->zpos = val;
  161. else
  162. return -EINVAL;
  163. return 0;
  164. }
  165. static int omap_plane_atomic_get_property(struct drm_plane *plane,
  166. const struct drm_plane_state *state,
  167. struct drm_property *property,
  168. u64 *val)
  169. {
  170. struct omap_drm_private *priv = plane->dev->dev_private;
  171. if (property == priv->zorder_prop)
  172. *val = state->zpos;
  173. else
  174. return -EINVAL;
  175. return 0;
  176. }
  177. static const struct drm_plane_funcs omap_plane_funcs = {
  178. .update_plane = drm_atomic_helper_update_plane,
  179. .disable_plane = drm_atomic_helper_disable_plane,
  180. .reset = omap_plane_reset,
  181. .destroy = omap_plane_destroy,
  182. .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
  183. .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
  184. .atomic_set_property = omap_plane_atomic_set_property,
  185. .atomic_get_property = omap_plane_atomic_get_property,
  186. };
  187. static const char *plane_id_to_name[] = {
  188. [OMAP_DSS_GFX] = "gfx",
  189. [OMAP_DSS_VIDEO1] = "vid1",
  190. [OMAP_DSS_VIDEO2] = "vid2",
  191. [OMAP_DSS_VIDEO3] = "vid3",
  192. };
  193. static const enum omap_plane_id plane_idx_to_id[] = {
  194. OMAP_DSS_GFX,
  195. OMAP_DSS_VIDEO1,
  196. OMAP_DSS_VIDEO2,
  197. OMAP_DSS_VIDEO3,
  198. };
  199. /* initialize plane */
  200. struct drm_plane *omap_plane_init(struct drm_device *dev,
  201. int idx, enum drm_plane_type type,
  202. u32 possible_crtcs)
  203. {
  204. struct omap_drm_private *priv = dev->dev_private;
  205. unsigned int num_planes = priv->dispc_ops->get_num_ovls(priv->dispc);
  206. struct drm_plane *plane;
  207. struct omap_plane *omap_plane;
  208. enum omap_plane_id id;
  209. int ret;
  210. u32 nformats;
  211. const u32 *formats;
  212. if (WARN_ON(idx >= ARRAY_SIZE(plane_idx_to_id)))
  213. return ERR_PTR(-EINVAL);
  214. id = plane_idx_to_id[idx];
  215. DBG("%s: type=%d", plane_id_to_name[id], type);
  216. omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
  217. if (!omap_plane)
  218. return ERR_PTR(-ENOMEM);
  219. formats = priv->dispc_ops->ovl_get_color_modes(priv->dispc, id);
  220. for (nformats = 0; formats[nformats]; ++nformats)
  221. ;
  222. omap_plane->id = id;
  223. omap_plane->name = plane_id_to_name[id];
  224. plane = &omap_plane->base;
  225. ret = drm_universal_plane_init(dev, plane, possible_crtcs,
  226. &omap_plane_funcs, formats,
  227. nformats, NULL, type, NULL);
  228. if (ret < 0)
  229. goto error;
  230. drm_plane_helper_add(plane, &omap_plane_helper_funcs);
  231. omap_plane_install_properties(plane, &plane->base);
  232. drm_plane_create_zpos_property(plane, 0, 0, num_planes - 1);
  233. drm_plane_create_alpha_property(plane);
  234. drm_plane_create_blend_mode_property(plane, BIT(DRM_MODE_BLEND_PREMULTI) |
  235. BIT(DRM_MODE_BLEND_COVERAGE));
  236. return plane;
  237. error:
  238. dev_err(dev->dev, "%s(): could not create plane: %s\n",
  239. __func__, plane_id_to_name[id]);
  240. kfree(omap_plane);
  241. return NULL;
  242. }