Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
4 * Author: Brian Starkey <brian.starkey@arm.com>
5 *
6 * ARM Mali DP Writeback connector implementation
7 */
8
9#include <drm/drm_atomic.h>
10#include <drm/drm_atomic_helper.h>
11#include <drm/drm_crtc.h>
12#include <drm/drm_edid.h>
13#include <drm/drm_fb_dma_helper.h>
14#include <drm/drm_fourcc.h>
15#include <drm/drm_framebuffer.h>
16#include <drm/drm_gem_dma_helper.h>
17#include <drm/drm_probe_helper.h>
18#include <drm/drm_writeback.h>
19
20#include "malidp_drv.h"
21#include "malidp_hw.h"
22#include "malidp_mw.h"
23
24#define to_mw_state(_state) (struct malidp_mw_connector_state *)(_state)
25
26struct malidp_mw_connector_state {
27 struct drm_connector_state base;
28 dma_addr_t addrs[2];
29 s32 pitches[2];
30 u8 format;
31 u8 n_planes;
32 bool rgb2yuv_initialized;
33 const s16 *rgb2yuv_coeffs;
34};
35
36static int malidp_mw_connector_get_modes(struct drm_connector *connector)
37{
38 struct drm_device *dev = connector->dev;
39
40 return drm_add_modes_noedid(connector, dev->mode_config.max_width,
41 dev->mode_config.max_height);
42}
43
44static enum drm_mode_status
45malidp_mw_connector_mode_valid(struct drm_connector *connector,
46 struct drm_display_mode *mode)
47{
48 struct drm_device *dev = connector->dev;
49 struct drm_mode_config *mode_config = &dev->mode_config;
50 int w = mode->hdisplay, h = mode->vdisplay;
51
52 if ((w < mode_config->min_width) || (w > mode_config->max_width))
53 return MODE_BAD_HVALUE;
54
55 if ((h < mode_config->min_height) || (h > mode_config->max_height))
56 return MODE_BAD_VVALUE;
57
58 return MODE_OK;
59}
60
61static const struct drm_connector_helper_funcs malidp_mw_connector_helper_funcs = {
62 .get_modes = malidp_mw_connector_get_modes,
63 .mode_valid = malidp_mw_connector_mode_valid,
64};
65
66static void malidp_mw_connector_reset(struct drm_connector *connector)
67{
68 struct malidp_mw_connector_state *mw_state =
69 kzalloc(sizeof(*mw_state), GFP_KERNEL);
70
71 if (connector->state)
72 __drm_atomic_helper_connector_destroy_state(connector->state);
73
74 kfree(connector->state);
75 connector->state = NULL;
76
77 if (mw_state)
78 __drm_atomic_helper_connector_reset(connector, &mw_state->base);
79}
80
81static enum drm_connector_status
82malidp_mw_connector_detect(struct drm_connector *connector, bool force)
83{
84 return connector_status_connected;
85}
86
87static void malidp_mw_connector_destroy(struct drm_connector *connector)
88{
89 drm_connector_cleanup(connector);
90}
91
92static struct drm_connector_state *
93malidp_mw_connector_duplicate_state(struct drm_connector *connector)
94{
95 struct malidp_mw_connector_state *mw_state, *mw_current_state;
96
97 if (WARN_ON(!connector->state))
98 return NULL;
99
100 mw_state = kzalloc(sizeof(*mw_state), GFP_KERNEL);
101 if (!mw_state)
102 return NULL;
103
104 mw_current_state = to_mw_state(connector->state);
105 mw_state->rgb2yuv_coeffs = mw_current_state->rgb2yuv_coeffs;
106 mw_state->rgb2yuv_initialized = mw_current_state->rgb2yuv_initialized;
107
108 __drm_atomic_helper_connector_duplicate_state(connector, &mw_state->base);
109
110 return &mw_state->base;
111}
112
113static const struct drm_connector_funcs malidp_mw_connector_funcs = {
114 .reset = malidp_mw_connector_reset,
115 .detect = malidp_mw_connector_detect,
116 .fill_modes = drm_helper_probe_single_connector_modes,
117 .destroy = malidp_mw_connector_destroy,
118 .atomic_duplicate_state = malidp_mw_connector_duplicate_state,
119 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
120};
121
122static const s16 rgb2yuv_coeffs_bt709_limited[MALIDP_COLORADJ_NUM_COEFFS] = {
123 47, 157, 16,
124 -26, -87, 112,
125 112, -102, -10,
126 16, 128, 128
127};
128
129static int
130malidp_mw_encoder_atomic_check(struct drm_encoder *encoder,
131 struct drm_crtc_state *crtc_state,
132 struct drm_connector_state *conn_state)
133{
134 struct malidp_mw_connector_state *mw_state = to_mw_state(conn_state);
135 struct malidp_drm *malidp = drm_to_malidp(encoder->dev);
136 struct drm_framebuffer *fb;
137 int i, n_planes;
138
139 if (!conn_state->writeback_job)
140 return 0;
141
142 fb = conn_state->writeback_job->fb;
143 if ((fb->width != crtc_state->mode.hdisplay) ||
144 (fb->height != crtc_state->mode.vdisplay)) {
145 DRM_DEBUG_KMS("Invalid framebuffer size %ux%u\n",
146 fb->width, fb->height);
147 return -EINVAL;
148 }
149
150 if (fb->modifier) {
151 DRM_DEBUG_KMS("Writeback framebuffer does not support modifiers\n");
152 return -EINVAL;
153 }
154
155 mw_state->format =
156 malidp_hw_get_format_id(&malidp->dev->hw->map, SE_MEMWRITE,
157 fb->format->format, !!fb->modifier);
158 if (mw_state->format == MALIDP_INVALID_FORMAT_ID) {
159 DRM_DEBUG_KMS("Invalid pixel format %p4cc\n",
160 &fb->format->format);
161 return -EINVAL;
162 }
163
164 n_planes = fb->format->num_planes;
165 for (i = 0; i < n_planes; i++) {
166 struct drm_gem_dma_object *obj = drm_fb_dma_get_gem_obj(fb, i);
167 /* memory write buffers are never rotated */
168 u8 alignment = malidp_hw_get_pitch_align(malidp->dev, 0);
169
170 if (fb->pitches[i] & (alignment - 1)) {
171 DRM_DEBUG_KMS("Invalid pitch %u for plane %d\n",
172 fb->pitches[i], i);
173 return -EINVAL;
174 }
175 mw_state->pitches[i] = fb->pitches[i];
176 mw_state->addrs[i] = obj->dma_addr + fb->offsets[i];
177 }
178 mw_state->n_planes = n_planes;
179
180 if (fb->format->is_yuv)
181 mw_state->rgb2yuv_coeffs = rgb2yuv_coeffs_bt709_limited;
182
183 return 0;
184}
185
186static const struct drm_encoder_helper_funcs malidp_mw_encoder_helper_funcs = {
187 .atomic_check = malidp_mw_encoder_atomic_check,
188};
189
190static u32 *get_writeback_formats(struct malidp_drm *malidp, int *n_formats)
191{
192 const struct malidp_hw_regmap *map = &malidp->dev->hw->map;
193 u32 *formats;
194 int n, i;
195
196 formats = kcalloc(map->n_pixel_formats, sizeof(*formats),
197 GFP_KERNEL);
198 if (!formats)
199 return NULL;
200
201 for (n = 0, i = 0; i < map->n_pixel_formats; i++) {
202 if (map->pixel_formats[i].layer & SE_MEMWRITE)
203 formats[n++] = map->pixel_formats[i].format;
204 }
205
206 *n_formats = n;
207
208 return formats;
209}
210
211int malidp_mw_connector_init(struct drm_device *drm)
212{
213 struct malidp_drm *malidp = drm_to_malidp(drm);
214 u32 *formats;
215 int ret, n_formats;
216
217 if (!malidp->dev->hw->enable_memwrite)
218 return 0;
219
220 drm_connector_helper_add(&malidp->mw_connector.base,
221 &malidp_mw_connector_helper_funcs);
222
223 formats = get_writeback_formats(malidp, &n_formats);
224 if (!formats)
225 return -ENOMEM;
226
227 ret = drm_writeback_connector_init(drm, &malidp->mw_connector,
228 &malidp_mw_connector_funcs,
229 &malidp_mw_encoder_helper_funcs,
230 formats, n_formats,
231 1 << drm_crtc_index(&malidp->crtc));
232 kfree(formats);
233 if (ret)
234 return ret;
235
236 return 0;
237}
238
239void malidp_mw_atomic_commit(struct drm_device *drm,
240 struct drm_atomic_state *old_state)
241{
242 struct malidp_drm *malidp = drm_to_malidp(drm);
243 struct drm_writeback_connector *mw_conn = &malidp->mw_connector;
244 struct drm_connector_state *conn_state = mw_conn->base.state;
245 struct malidp_hw_device *hwdev = malidp->dev;
246 struct malidp_mw_connector_state *mw_state;
247
248 if (!conn_state)
249 return;
250
251 mw_state = to_mw_state(conn_state);
252
253 if (conn_state->writeback_job) {
254 struct drm_framebuffer *fb = conn_state->writeback_job->fb;
255
256 DRM_DEV_DEBUG_DRIVER(drm->dev,
257 "Enable memwrite %ux%u:%d %pad fmt: %u\n",
258 fb->width, fb->height,
259 mw_state->pitches[0],
260 &mw_state->addrs[0],
261 mw_state->format);
262
263 drm_writeback_queue_job(mw_conn, conn_state);
264 hwdev->hw->enable_memwrite(hwdev, mw_state->addrs,
265 mw_state->pitches, mw_state->n_planes,
266 fb->width, fb->height, mw_state->format,
267 !mw_state->rgb2yuv_initialized ?
268 mw_state->rgb2yuv_coeffs : NULL);
269 mw_state->rgb2yuv_initialized = !!mw_state->rgb2yuv_coeffs;
270 } else {
271 DRM_DEV_DEBUG_DRIVER(drm->dev, "Disable memwrite\n");
272 hwdev->hw->disable_memwrite(hwdev);
273 }
274}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
4 * Author: Brian Starkey <brian.starkey@arm.com>
5 *
6 * ARM Mali DP Writeback connector implementation
7 */
8
9#include <drm/drm_atomic.h>
10#include <drm/drm_atomic_helper.h>
11#include <drm/drm_crtc.h>
12#include <drm/drm_fb_cma_helper.h>
13#include <drm/drm_fourcc.h>
14#include <drm/drm_gem_cma_helper.h>
15#include <drm/drm_probe_helper.h>
16#include <drm/drm_writeback.h>
17
18#include "malidp_drv.h"
19#include "malidp_hw.h"
20#include "malidp_mw.h"
21
22#define to_mw_state(_state) (struct malidp_mw_connector_state *)(_state)
23
24struct malidp_mw_connector_state {
25 struct drm_connector_state base;
26 dma_addr_t addrs[2];
27 s32 pitches[2];
28 u8 format;
29 u8 n_planes;
30 bool rgb2yuv_initialized;
31 const s16 *rgb2yuv_coeffs;
32};
33
34static int malidp_mw_connector_get_modes(struct drm_connector *connector)
35{
36 struct drm_device *dev = connector->dev;
37
38 return drm_add_modes_noedid(connector, dev->mode_config.max_width,
39 dev->mode_config.max_height);
40}
41
42static enum drm_mode_status
43malidp_mw_connector_mode_valid(struct drm_connector *connector,
44 struct drm_display_mode *mode)
45{
46 struct drm_device *dev = connector->dev;
47 struct drm_mode_config *mode_config = &dev->mode_config;
48 int w = mode->hdisplay, h = mode->vdisplay;
49
50 if ((w < mode_config->min_width) || (w > mode_config->max_width))
51 return MODE_BAD_HVALUE;
52
53 if ((h < mode_config->min_height) || (h > mode_config->max_height))
54 return MODE_BAD_VVALUE;
55
56 return MODE_OK;
57}
58
59static const struct drm_connector_helper_funcs malidp_mw_connector_helper_funcs = {
60 .get_modes = malidp_mw_connector_get_modes,
61 .mode_valid = malidp_mw_connector_mode_valid,
62};
63
64static void malidp_mw_connector_reset(struct drm_connector *connector)
65{
66 struct malidp_mw_connector_state *mw_state =
67 kzalloc(sizeof(*mw_state), GFP_KERNEL);
68
69 if (connector->state)
70 __drm_atomic_helper_connector_destroy_state(connector->state);
71
72 kfree(connector->state);
73 __drm_atomic_helper_connector_reset(connector, &mw_state->base);
74}
75
76static enum drm_connector_status
77malidp_mw_connector_detect(struct drm_connector *connector, bool force)
78{
79 return connector_status_connected;
80}
81
82static void malidp_mw_connector_destroy(struct drm_connector *connector)
83{
84 drm_connector_cleanup(connector);
85}
86
87static struct drm_connector_state *
88malidp_mw_connector_duplicate_state(struct drm_connector *connector)
89{
90 struct malidp_mw_connector_state *mw_state, *mw_current_state;
91
92 if (WARN_ON(!connector->state))
93 return NULL;
94
95 mw_state = kzalloc(sizeof(*mw_state), GFP_KERNEL);
96 if (!mw_state)
97 return NULL;
98
99 mw_current_state = to_mw_state(connector->state);
100 mw_state->rgb2yuv_coeffs = mw_current_state->rgb2yuv_coeffs;
101 mw_state->rgb2yuv_initialized = mw_current_state->rgb2yuv_initialized;
102
103 __drm_atomic_helper_connector_duplicate_state(connector, &mw_state->base);
104
105 return &mw_state->base;
106}
107
108static const struct drm_connector_funcs malidp_mw_connector_funcs = {
109 .reset = malidp_mw_connector_reset,
110 .detect = malidp_mw_connector_detect,
111 .fill_modes = drm_helper_probe_single_connector_modes,
112 .destroy = malidp_mw_connector_destroy,
113 .atomic_duplicate_state = malidp_mw_connector_duplicate_state,
114 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
115};
116
117static const s16 rgb2yuv_coeffs_bt709_limited[MALIDP_COLORADJ_NUM_COEFFS] = {
118 47, 157, 16,
119 -26, -87, 112,
120 112, -102, -10,
121 16, 128, 128
122};
123
124static int
125malidp_mw_encoder_atomic_check(struct drm_encoder *encoder,
126 struct drm_crtc_state *crtc_state,
127 struct drm_connector_state *conn_state)
128{
129 struct malidp_mw_connector_state *mw_state = to_mw_state(conn_state);
130 struct malidp_drm *malidp = encoder->dev->dev_private;
131 struct drm_framebuffer *fb;
132 int i, n_planes;
133
134 if (!conn_state->writeback_job)
135 return 0;
136
137 fb = conn_state->writeback_job->fb;
138 if ((fb->width != crtc_state->mode.hdisplay) ||
139 (fb->height != crtc_state->mode.vdisplay)) {
140 DRM_DEBUG_KMS("Invalid framebuffer size %ux%u\n",
141 fb->width, fb->height);
142 return -EINVAL;
143 }
144
145 if (fb->modifier) {
146 DRM_DEBUG_KMS("Writeback framebuffer does not support modifiers\n");
147 return -EINVAL;
148 }
149
150 mw_state->format =
151 malidp_hw_get_format_id(&malidp->dev->hw->map, SE_MEMWRITE,
152 fb->format->format, !!fb->modifier);
153 if (mw_state->format == MALIDP_INVALID_FORMAT_ID) {
154 struct drm_format_name_buf format_name;
155
156 DRM_DEBUG_KMS("Invalid pixel format %s\n",
157 drm_get_format_name(fb->format->format,
158 &format_name));
159 return -EINVAL;
160 }
161
162 n_planes = fb->format->num_planes;
163 for (i = 0; i < n_planes; i++) {
164 struct drm_gem_cma_object *obj = drm_fb_cma_get_gem_obj(fb, i);
165 /* memory write buffers are never rotated */
166 u8 alignment = malidp_hw_get_pitch_align(malidp->dev, 0);
167
168 if (fb->pitches[i] & (alignment - 1)) {
169 DRM_DEBUG_KMS("Invalid pitch %u for plane %d\n",
170 fb->pitches[i], i);
171 return -EINVAL;
172 }
173 mw_state->pitches[i] = fb->pitches[i];
174 mw_state->addrs[i] = obj->paddr + fb->offsets[i];
175 }
176 mw_state->n_planes = n_planes;
177
178 if (fb->format->is_yuv)
179 mw_state->rgb2yuv_coeffs = rgb2yuv_coeffs_bt709_limited;
180
181 return 0;
182}
183
184static const struct drm_encoder_helper_funcs malidp_mw_encoder_helper_funcs = {
185 .atomic_check = malidp_mw_encoder_atomic_check,
186};
187
188static u32 *get_writeback_formats(struct malidp_drm *malidp, int *n_formats)
189{
190 const struct malidp_hw_regmap *map = &malidp->dev->hw->map;
191 u32 *formats;
192 int n, i;
193
194 formats = kcalloc(map->n_pixel_formats, sizeof(*formats),
195 GFP_KERNEL);
196 if (!formats)
197 return NULL;
198
199 for (n = 0, i = 0; i < map->n_pixel_formats; i++) {
200 if (map->pixel_formats[i].layer & SE_MEMWRITE)
201 formats[n++] = map->pixel_formats[i].format;
202 }
203
204 *n_formats = n;
205
206 return formats;
207}
208
209int malidp_mw_connector_init(struct drm_device *drm)
210{
211 struct malidp_drm *malidp = drm->dev_private;
212 u32 *formats;
213 int ret, n_formats;
214
215 if (!malidp->dev->hw->enable_memwrite)
216 return 0;
217
218 malidp->mw_connector.encoder.possible_crtcs = 1 << drm_crtc_index(&malidp->crtc);
219 drm_connector_helper_add(&malidp->mw_connector.base,
220 &malidp_mw_connector_helper_funcs);
221
222 formats = get_writeback_formats(malidp, &n_formats);
223 if (!formats)
224 return -ENOMEM;
225
226 ret = drm_writeback_connector_init(drm, &malidp->mw_connector,
227 &malidp_mw_connector_funcs,
228 &malidp_mw_encoder_helper_funcs,
229 formats, n_formats);
230 kfree(formats);
231 if (ret)
232 return ret;
233
234 return 0;
235}
236
237void malidp_mw_atomic_commit(struct drm_device *drm,
238 struct drm_atomic_state *old_state)
239{
240 struct malidp_drm *malidp = drm->dev_private;
241 struct drm_writeback_connector *mw_conn = &malidp->mw_connector;
242 struct drm_connector_state *conn_state = mw_conn->base.state;
243 struct malidp_hw_device *hwdev = malidp->dev;
244 struct malidp_mw_connector_state *mw_state;
245
246 if (!conn_state)
247 return;
248
249 mw_state = to_mw_state(conn_state);
250
251 if (conn_state->writeback_job) {
252 struct drm_framebuffer *fb = conn_state->writeback_job->fb;
253
254 DRM_DEV_DEBUG_DRIVER(drm->dev,
255 "Enable memwrite %ux%u:%d %pad fmt: %u\n",
256 fb->width, fb->height,
257 mw_state->pitches[0],
258 &mw_state->addrs[0],
259 mw_state->format);
260
261 drm_writeback_queue_job(mw_conn, conn_state);
262 hwdev->hw->enable_memwrite(hwdev, mw_state->addrs,
263 mw_state->pitches, mw_state->n_planes,
264 fb->width, fb->height, mw_state->format,
265 !mw_state->rgb2yuv_initialized ?
266 mw_state->rgb2yuv_coeffs : NULL);
267 mw_state->rgb2yuv_initialized = !!mw_state->rgb2yuv_coeffs;
268 } else {
269 DRM_DEV_DEBUG_DRIVER(drm->dev, "Disable memwrite\n");
270 hwdev->hw->disable_memwrite(hwdev);
271 }
272}