Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 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> |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 14 | #include <drm/drm_plane_helper.h> |
| 15 | #include <drm/drmP.h> |
| 16 | |
| 17 | #include "sun4i_backend.h" |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 18 | #include "sun4i_frontend.h" |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 19 | #include "sun4i_layer.h" |
Icenowy Zheng | 8796933 | 2017-05-17 22:47:17 +0800 | [diff] [blame] | 20 | #include "sunxi_engine.h" |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 21 | |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 22 | static void sun4i_backend_layer_reset(struct drm_plane *plane) |
| 23 | { |
Maxime Ripard | 2bebcc4 | 2017-12-17 17:32:21 +0100 | [diff] [blame] | 24 | struct sun4i_layer *layer = plane_to_sun4i_layer(plane); |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 25 | struct sun4i_layer_state *state; |
| 26 | |
| 27 | if (plane->state) { |
| 28 | state = state_to_sun4i_layer_state(plane->state); |
| 29 | |
| 30 | __drm_atomic_helper_plane_destroy_state(&state->state); |
| 31 | |
| 32 | kfree(state); |
| 33 | plane->state = NULL; |
| 34 | } |
| 35 | |
| 36 | state = kzalloc(sizeof(*state), GFP_KERNEL); |
| 37 | if (state) { |
| 38 | plane->state = &state->state; |
| 39 | plane->state->plane = plane; |
Maxime Ripard | 2bebcc4 | 2017-12-17 17:32:21 +0100 | [diff] [blame] | 40 | plane->state->zpos = layer->id; |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 41 | } |
| 42 | } |
| 43 | |
| 44 | static struct drm_plane_state * |
| 45 | sun4i_backend_layer_duplicate_state(struct drm_plane *plane) |
| 46 | { |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 47 | struct sun4i_layer_state *orig = state_to_sun4i_layer_state(plane->state); |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 48 | struct sun4i_layer_state *copy; |
| 49 | |
| 50 | copy = kzalloc(sizeof(*copy), GFP_KERNEL); |
| 51 | if (!copy) |
| 52 | return NULL; |
| 53 | |
| 54 | __drm_atomic_helper_plane_duplicate_state(plane, ©->state); |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 55 | copy->uses_frontend = orig->uses_frontend; |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 56 | |
| 57 | return ©->state; |
| 58 | } |
| 59 | |
| 60 | static void sun4i_backend_layer_destroy_state(struct drm_plane *plane, |
| 61 | struct drm_plane_state *state) |
| 62 | { |
| 63 | struct sun4i_layer_state *s_state = state_to_sun4i_layer_state(state); |
| 64 | |
| 65 | __drm_atomic_helper_plane_destroy_state(state); |
| 66 | |
| 67 | kfree(s_state); |
| 68 | } |
| 69 | |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 70 | static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane, |
| 71 | struct drm_plane_state *old_state) |
| 72 | { |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 73 | struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(old_state); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 74 | struct sun4i_layer *layer = plane_to_sun4i_layer(plane); |
Chen-Yu Tsai | ace6c09 | 2017-02-23 16:05:42 +0800 | [diff] [blame] | 75 | struct sun4i_backend *backend = layer->backend; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 76 | |
| 77 | sun4i_backend_layer_enable(backend, layer->id, false); |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 78 | |
| 79 | if (layer_state->uses_frontend) { |
| 80 | unsigned long flags; |
| 81 | |
| 82 | spin_lock_irqsave(&backend->frontend_lock, flags); |
| 83 | backend->frontend_teardown = true; |
| 84 | spin_unlock_irqrestore(&backend->frontend_lock, flags); |
| 85 | } |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | static void sun4i_backend_layer_atomic_update(struct drm_plane *plane, |
| 89 | struct drm_plane_state *old_state) |
| 90 | { |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 91 | struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(plane->state); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 92 | struct sun4i_layer *layer = plane_to_sun4i_layer(plane); |
Chen-Yu Tsai | ace6c09 | 2017-02-23 16:05:42 +0800 | [diff] [blame] | 93 | struct sun4i_backend *backend = layer->backend; |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 94 | struct sun4i_frontend *frontend = backend->frontend; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 95 | |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 96 | if (layer_state->uses_frontend) { |
| 97 | sun4i_frontend_init(frontend); |
| 98 | sun4i_frontend_update_coord(frontend, plane); |
| 99 | sun4i_frontend_update_buffer(frontend, plane); |
| 100 | sun4i_frontend_update_formats(frontend, plane, |
| 101 | DRM_FORMAT_ARGB8888); |
| 102 | sun4i_backend_update_layer_frontend(backend, layer->id, |
| 103 | DRM_FORMAT_ARGB8888); |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 104 | sun4i_frontend_enable(frontend); |
| 105 | } else { |
Maxime Ripard | ca07b21 | 2018-01-22 10:25:23 +0100 | [diff] [blame] | 106 | sun4i_backend_update_layer_formats(backend, layer->id, plane); |
| 107 | sun4i_backend_update_layer_buffer(backend, layer->id, plane); |
| 108 | } |
| 109 | |
Maxime Ripard | 098b338 | 2017-12-17 17:34:26 +0100 | [diff] [blame] | 110 | sun4i_backend_update_layer_coord(backend, layer->id, plane); |
Maxime Ripard | 47a05f4 | 2017-05-01 10:52:32 +0200 | [diff] [blame] | 111 | sun4i_backend_update_layer_zpos(backend, layer->id, plane); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 112 | sun4i_backend_layer_enable(backend, layer->id, true); |
| 113 | } |
| 114 | |
Arvind Yadav | 934d143 | 2017-07-03 21:35:20 +0530 | [diff] [blame] | 115 | static const struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = { |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 116 | .atomic_disable = sun4i_backend_layer_atomic_disable, |
| 117 | .atomic_update = sun4i_backend_layer_atomic_update, |
| 118 | }; |
| 119 | |
| 120 | static const struct drm_plane_funcs sun4i_backend_layer_funcs = { |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 121 | .atomic_destroy_state = sun4i_backend_layer_destroy_state, |
| 122 | .atomic_duplicate_state = sun4i_backend_layer_duplicate_state, |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 123 | .destroy = drm_plane_cleanup, |
| 124 | .disable_plane = drm_atomic_helper_disable_plane, |
Maxime Ripard | d540f82 | 2018-01-22 10:25:18 +0100 | [diff] [blame] | 125 | .reset = sun4i_backend_layer_reset, |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 126 | .update_plane = drm_atomic_helper_update_plane, |
| 127 | }; |
| 128 | |
Maxime Ripard | 70d2850 | 2018-02-16 18:39:33 +0100 | [diff] [blame] | 129 | static const uint32_t sun4i_backend_layer_formats[] = { |
Maxime Ripard | c222f39 | 2016-09-19 22:17:50 +0200 | [diff] [blame] | 130 | DRM_FORMAT_ARGB8888, |
Maxime Ripard | 47d7fbb | 2016-10-18 10:46:14 +0200 | [diff] [blame] | 131 | DRM_FORMAT_ARGB4444, |
| 132 | DRM_FORMAT_ARGB1555, |
| 133 | DRM_FORMAT_RGBA5551, |
| 134 | DRM_FORMAT_RGBA4444, |
Maxime Ripard | c222f39 | 2016-09-19 22:17:50 +0200 | [diff] [blame] | 135 | DRM_FORMAT_RGB888, |
Maxime Ripard | 47d7fbb | 2016-10-18 10:46:14 +0200 | [diff] [blame] | 136 | DRM_FORMAT_RGB565, |
Maxime Ripard | ddc389f | 2018-03-01 20:18:46 +0100 | [diff] [blame] | 137 | DRM_FORMAT_UYVY, |
| 138 | DRM_FORMAT_VYUY, |
Maxime Ripard | c222f39 | 2016-09-19 22:17:50 +0200 | [diff] [blame] | 139 | DRM_FORMAT_XRGB8888, |
Maxime Ripard | ddc389f | 2018-03-01 20:18:46 +0100 | [diff] [blame] | 140 | DRM_FORMAT_YUYV, |
| 141 | DRM_FORMAT_YVYU, |
Maxime Ripard | c222f39 | 2016-09-19 22:17:50 +0200 | [diff] [blame] | 142 | }; |
| 143 | |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 144 | static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm, |
Chen-Yu Tsai | a0a68fb | 2017-03-09 18:05:29 +0800 | [diff] [blame] | 145 | struct sun4i_backend *backend, |
Maxime Ripard | 70d2850 | 2018-02-16 18:39:33 +0100 | [diff] [blame] | 146 | enum drm_plane_type type) |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 147 | { |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 148 | struct sun4i_layer *layer; |
| 149 | int ret; |
| 150 | |
| 151 | layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL); |
| 152 | if (!layer) |
| 153 | return ERR_PTR(-ENOMEM); |
| 154 | |
Chen-Yu Tsai | a5154a4 | 2017-02-23 16:05:39 +0800 | [diff] [blame] | 155 | /* possible crtcs are set later */ |
| 156 | ret = drm_universal_plane_init(drm, &layer->plane, 0, |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 157 | &sun4i_backend_layer_funcs, |
Maxime Ripard | 70d2850 | 2018-02-16 18:39:33 +0100 | [diff] [blame] | 158 | sun4i_backend_layer_formats, |
| 159 | ARRAY_SIZE(sun4i_backend_layer_formats), |
| 160 | NULL, type, NULL); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 161 | if (ret) { |
| 162 | dev_err(drm->dev, "Couldn't initialize layer\n"); |
| 163 | return ERR_PTR(ret); |
| 164 | } |
| 165 | |
| 166 | drm_plane_helper_add(&layer->plane, |
| 167 | &sun4i_backend_layer_helper_funcs); |
Chen-Yu Tsai | a0a68fb | 2017-03-09 18:05:29 +0800 | [diff] [blame] | 168 | layer->backend = backend; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 169 | |
Maxime Ripard | ded4f34 | 2018-02-16 18:39:34 +0100 | [diff] [blame] | 170 | drm_plane_create_zpos_property(&layer->plane, 0, 0, |
| 171 | SUN4I_BACKEND_NUM_LAYERS - 1); |
| 172 | |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 173 | return layer; |
| 174 | } |
| 175 | |
Icenowy Zheng | 7921e14 | 2017-05-15 00:30:36 +0800 | [diff] [blame] | 176 | struct drm_plane **sun4i_layers_init(struct drm_device *drm, |
Icenowy Zheng | 8796933 | 2017-05-17 22:47:17 +0800 | [diff] [blame] | 177 | struct sunxi_engine *engine) |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 178 | { |
Icenowy Zheng | 7921e14 | 2017-05-15 00:30:36 +0800 | [diff] [blame] | 179 | struct drm_plane **planes; |
Icenowy Zheng | 8796933 | 2017-05-17 22:47:17 +0800 | [diff] [blame] | 180 | struct sun4i_backend *backend = engine_to_sun4i_backend(engine); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 181 | int i; |
| 182 | |
Maxime Ripard | 65f7fa3 | 2017-06-26 22:51:15 +0200 | [diff] [blame] | 183 | /* We need to have a sentinel at the need, hence the overallocation */ |
| 184 | planes = devm_kcalloc(drm->dev, SUN4I_BACKEND_NUM_LAYERS + 1, |
Icenowy Zheng | 7921e14 | 2017-05-15 00:30:36 +0800 | [diff] [blame] | 185 | sizeof(*planes), GFP_KERNEL); |
| 186 | if (!planes) |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 187 | return ERR_PTR(-ENOMEM); |
| 188 | |
Maxime Ripard | 70d2850 | 2018-02-16 18:39:33 +0100 | [diff] [blame] | 189 | for (i = 0; i < SUN4I_BACKEND_NUM_LAYERS; i++) { |
| 190 | enum drm_plane_type type = i ? DRM_PLANE_TYPE_OVERLAY : DRM_PLANE_TYPE_PRIMARY; |
Chen-Yu Tsai | 8a16469 | 2017-02-17 11:13:28 +0800 | [diff] [blame] | 191 | struct sun4i_layer *layer; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 192 | |
Maxime Ripard | 70d2850 | 2018-02-16 18:39:33 +0100 | [diff] [blame] | 193 | layer = sun4i_layer_init_one(drm, backend, type); |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 194 | if (IS_ERR(layer)) { |
| 195 | dev_err(drm->dev, "Couldn't initialize %s plane\n", |
| 196 | i ? "overlay" : "primary"); |
| 197 | return ERR_CAST(layer); |
| 198 | }; |
| 199 | |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 200 | layer->id = i; |
Icenowy Zheng | 7921e14 | 2017-05-15 00:30:36 +0800 | [diff] [blame] | 201 | planes[i] = &layer->plane; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 202 | }; |
| 203 | |
Icenowy Zheng | 7921e14 | 2017-05-15 00:30:36 +0800 | [diff] [blame] | 204 | return planes; |
Maxime Ripard | 9026e0d | 2015-10-29 09:36:23 +0100 | [diff] [blame] | 205 | } |