1 /* 2 * Copyright (C) 2015 Free Electrons 3 * Copyright (C) 2015 NextThing Co 4 * 5 * Maxime Ripard <maxime.ripard@free-electrons.com> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 of 10 * the License, or (at your option) any later version. 11 */ 12 13 #include <drm/drm_atomic_helper.h> 14 #include <drm/drm_crtc.h> 15 #include <drm/drm_plane_helper.h> 16 #include <drm/drmP.h> 17 18 #include "sun4i_backend.h" 19 #include "sun4i_layer.h" 20 21 struct sun4i_plane_desc { 22 enum drm_plane_type type; 23 u8 pipe; 24 const uint32_t *formats; 25 uint32_t nformats; 26 }; 27 28 static int sun4i_backend_layer_atomic_check(struct drm_plane *plane, 29 struct drm_plane_state *state) 30 { 31 return 0; 32 } 33 34 static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane, 35 struct drm_plane_state *old_state) 36 { 37 struct sun4i_layer *layer = plane_to_sun4i_layer(plane); 38 struct sun4i_backend *backend = layer->backend; 39 40 sun4i_backend_layer_enable(backend, layer->id, false); 41 } 42 43 static void sun4i_backend_layer_atomic_update(struct drm_plane *plane, 44 struct drm_plane_state *old_state) 45 { 46 struct sun4i_layer *layer = plane_to_sun4i_layer(plane); 47 struct sun4i_backend *backend = layer->backend; 48 49 sun4i_backend_update_layer_coord(backend, layer->id, plane); 50 sun4i_backend_update_layer_formats(backend, layer->id, plane); 51 sun4i_backend_update_layer_buffer(backend, layer->id, plane); 52 sun4i_backend_layer_enable(backend, layer->id, true); 53 } 54 55 static struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = { 56 .atomic_check = sun4i_backend_layer_atomic_check, 57 .atomic_disable = sun4i_backend_layer_atomic_disable, 58 .atomic_update = sun4i_backend_layer_atomic_update, 59 }; 60 61 static const struct drm_plane_funcs sun4i_backend_layer_funcs = { 62 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, 63 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, 64 .destroy = drm_plane_cleanup, 65 .disable_plane = drm_atomic_helper_disable_plane, 66 .reset = drm_atomic_helper_plane_reset, 67 .update_plane = drm_atomic_helper_update_plane, 68 }; 69 70 static const uint32_t sun4i_backend_layer_formats_primary[] = { 71 DRM_FORMAT_ARGB8888, 72 DRM_FORMAT_RGB888, 73 DRM_FORMAT_RGB565, 74 DRM_FORMAT_XRGB8888, 75 }; 76 77 static const uint32_t sun4i_backend_layer_formats_overlay[] = { 78 DRM_FORMAT_ARGB8888, 79 DRM_FORMAT_ARGB4444, 80 DRM_FORMAT_ARGB1555, 81 DRM_FORMAT_RGBA5551, 82 DRM_FORMAT_RGBA4444, 83 DRM_FORMAT_RGB888, 84 DRM_FORMAT_RGB565, 85 DRM_FORMAT_XRGB8888, 86 }; 87 88 static const struct sun4i_plane_desc sun4i_backend_planes[] = { 89 { 90 .type = DRM_PLANE_TYPE_PRIMARY, 91 .pipe = 0, 92 .formats = sun4i_backend_layer_formats_primary, 93 .nformats = ARRAY_SIZE(sun4i_backend_layer_formats_primary), 94 }, 95 { 96 .type = DRM_PLANE_TYPE_OVERLAY, 97 .pipe = 1, 98 .formats = sun4i_backend_layer_formats_overlay, 99 .nformats = ARRAY_SIZE(sun4i_backend_layer_formats_overlay), 100 }, 101 }; 102 103 static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm, 104 struct sun4i_backend *backend, 105 const struct sun4i_plane_desc *plane) 106 { 107 struct sun4i_layer *layer; 108 int ret; 109 110 layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL); 111 if (!layer) 112 return ERR_PTR(-ENOMEM); 113 114 /* possible crtcs are set later */ 115 ret = drm_universal_plane_init(drm, &layer->plane, 0, 116 &sun4i_backend_layer_funcs, 117 plane->formats, plane->nformats, 118 plane->type, NULL); 119 if (ret) { 120 dev_err(drm->dev, "Couldn't initialize layer\n"); 121 return ERR_PTR(ret); 122 } 123 124 drm_plane_helper_add(&layer->plane, 125 &sun4i_backend_layer_helper_funcs); 126 layer->backend = backend; 127 128 return layer; 129 } 130 131 struct sun4i_layer **sun4i_layers_init(struct drm_device *drm, 132 struct sun4i_backend *backend) 133 { 134 struct sun4i_layer **layers; 135 int i; 136 137 layers = devm_kcalloc(drm->dev, ARRAY_SIZE(sun4i_backend_planes) + 1, 138 sizeof(*layers), GFP_KERNEL); 139 if (!layers) 140 return ERR_PTR(-ENOMEM); 141 142 /* 143 * The hardware is a bit unusual here. 144 * 145 * Even though it supports 4 layers, it does the composition 146 * in two separate steps. 147 * 148 * The first one is assigning a layer to one of its two 149 * pipes. If more that 1 layer is assigned to the same pipe, 150 * and if pixels overlaps, the pipe will take the pixel from 151 * the layer with the highest priority. 152 * 153 * The second step is the actual alpha blending, that takes 154 * the two pipes as input, and uses the eventual alpha 155 * component to do the transparency between the two. 156 * 157 * This two steps scenario makes us unable to guarantee a 158 * robust alpha blending between the 4 layers in all 159 * situations. So we just expose two layers, one per pipe. On 160 * SoCs that support it, sprites could fill the need for more 161 * layers. 162 */ 163 for (i = 0; i < ARRAY_SIZE(sun4i_backend_planes); i++) { 164 const struct sun4i_plane_desc *plane = &sun4i_backend_planes[i]; 165 struct sun4i_layer *layer; 166 167 layer = sun4i_layer_init_one(drm, backend, plane); 168 if (IS_ERR(layer)) { 169 dev_err(drm->dev, "Couldn't initialize %s plane\n", 170 i ? "overlay" : "primary"); 171 return ERR_CAST(layer); 172 }; 173 174 DRM_DEBUG_DRIVER("Assigning %s plane to pipe %d\n", 175 i ? "overlay" : "primary", plane->pipe); 176 regmap_update_bits(backend->regs, SUN4I_BACKEND_ATTCTL_REG0(i), 177 SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL_MASK, 178 SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL(plane->pipe)); 179 180 layer->id = i; 181 layers[i] = layer; 182 }; 183 184 return layers; 185 } 186