1/*-
2 * Copyright (c) 2016 Michal Meloun
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/11/sys/arm/nvidia/drm2/tegra_fb.c 310600 2016-12-26 14:36:05Z mmel $");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/bus.h>
33#include <sys/kernel.h>
34#include <sys/malloc.h>
35
36#include <machine/bus.h>
37
38#include <dev/extres/clk/clk.h>
39#include <dev/drm2/drmP.h>
40#include <dev/drm2/drm_crtc_helper.h>
41#include <dev/drm2/drm_fb_helper.h>
42
43#include <arm/nvidia/drm2/tegra_drm.h>
44
45static void
46fb_destroy(struct drm_framebuffer *drm_fb)
47{
48	struct tegra_fb *fb;
49	struct tegra_bo *bo;
50	unsigned int i;
51
52	fb = container_of(drm_fb, struct tegra_fb, drm_fb);
53	for (i = 0; i < fb->nplanes; i++) {
54		bo = fb->planes[i];
55		if (bo != NULL)
56			drm_gem_object_unreference_unlocked(&bo->gem_obj);
57	}
58
59	drm_framebuffer_cleanup(drm_fb);
60	free(fb->planes, DRM_MEM_DRIVER);
61}
62
63static int
64fb_create_handle(struct drm_framebuffer *drm_fb, struct drm_file *file,
65 unsigned int *handle)
66{
67	struct tegra_fb *fb;
68	int rv;
69
70	fb = container_of(drm_fb, struct tegra_fb, drm_fb);
71	rv = drm_gem_handle_create(file, &fb->planes[0]->gem_obj, handle);
72	return (rv);
73}
74
75/* XXX Probably not needed */
76static int
77fb_dirty(struct drm_framebuffer *fb, struct drm_file *file_priv,
78unsigned flags, unsigned color, struct drm_clip_rect *clips, unsigned num_clips)
79{
80
81	return (0);
82}
83
84static const struct drm_framebuffer_funcs fb_funcs = {
85	.destroy = fb_destroy,
86	.create_handle = fb_create_handle,
87	.dirty = fb_dirty,
88};
89
90static int
91fb_alloc(struct drm_device *drm, struct drm_mode_fb_cmd2 *mode_cmd,
92    struct tegra_bo **planes, int num_planes, struct tegra_fb **res_fb)
93{
94	struct tegra_fb *fb;
95	int i;
96	int rv;
97
98	fb = malloc(sizeof(*fb), DRM_MEM_DRIVER, M_WAITOK | M_ZERO);
99	fb->planes = malloc(num_planes * sizeof(*fb->planes), DRM_MEM_DRIVER,
100	    M_WAITOK | M_ZERO);
101	fb->nplanes = num_planes;
102
103	drm_helper_mode_fill_fb_struct(&fb->drm_fb, mode_cmd);
104	for (i = 0; i < fb->nplanes; i++)
105		fb->planes[i] = planes[i];
106	rv = drm_framebuffer_init(drm, &fb->drm_fb, &fb_funcs);
107	if (rv < 0) {
108		device_printf(drm->dev,
109		    "Cannot initialize frame buffer %d\n", rv);
110		free(fb->planes, DRM_MEM_DRIVER);
111		return (rv);
112	}
113	*res_fb = fb;
114	return (0);
115}
116
117static int
118tegra_fb_probe(struct drm_fb_helper *helper,
119    struct drm_fb_helper_surface_size *sizes)
120{
121	u_int bpp, size;
122	struct tegra_drm *drm;
123	struct tegra_fb *fb;
124	struct fb_info *info;
125	struct tegra_bo *bo;
126	struct drm_mode_fb_cmd2 mode_cmd;
127	struct drm_device *drm_dev;
128	int rv;
129
130	if (helper->fb != NULL)
131		return (0);
132
133	DRM_DEBUG_KMS("surface: %d x %d (bpp: %d)\n", sizes->surface_width,
134	    sizes->surface_height, sizes->surface_bpp);
135
136	drm_dev = helper->dev;
137	fb = container_of(helper, struct tegra_fb, fb_helper);
138	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
139	bpp = (sizes->surface_bpp + 7) / 8;
140
141	/* Create mode_cmd */
142	memset(&mode_cmd, 0, sizeof(mode_cmd));
143	mode_cmd.width = sizes->surface_width;
144	mode_cmd.height = sizes->surface_height;
145	mode_cmd.pitches[0] = roundup(sizes->surface_width * bpp,
146	    drm->pitch_align);
147	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
148	    sizes->surface_depth);
149	size = mode_cmd.pitches[0] * mode_cmd.height;
150
151	DRM_LOCK(drm_dev);
152	rv = tegra_bo_create(drm_dev, size, &bo);
153	DRM_UNLOCK(drm_dev);
154	if (rv != 0)
155		return (rv);
156
157	info = framebuffer_alloc();
158	if (info == NULL) {
159		device_printf(drm_dev->dev,
160		    "Cannot allocate DRM framebuffer info.\n");
161		rv = -ENOMEM;
162		goto err_object;
163	}
164
165	rv = fb_alloc(drm_dev, &mode_cmd,  &bo, 1, &fb);
166	if (rv != 0) {
167		device_printf(drm_dev->dev,
168		     "Cannot allocate DRM framebuffer.\n");
169		goto err_fb;
170	}
171	helper->fb = &fb->drm_fb;
172	helper->fbdev = info;
173
174	/* Fill FB info */
175	info->fb_vbase = bo->vbase;
176	info->fb_pbase = bo->pbase;
177	info->fb_size = size;
178	info->fb_bpp = sizes->surface_bpp;
179	drm_fb_helper_fill_fix(info, fb->drm_fb.pitches[0], fb->drm_fb.depth);
180	drm_fb_helper_fill_var(info, helper, fb->drm_fb.width,
181	    fb->drm_fb.height);
182
183	DRM_DEBUG_KMS("allocated %dx%d (s %dbits) fb size: %d, bo %p\n",
184		      fb->drm_fb.width, fb->drm_fb.height, fb->drm_fb.depth,
185		      size, bo);
186	return (1);
187err_fb:
188	drm_gem_object_unreference_unlocked(&bo->gem_obj);
189	framebuffer_release(info);
190err_object:
191	drm_gem_object_release(&bo->gem_obj);
192	return (rv);
193}
194
195static struct drm_fb_helper_funcs fb_helper_funcs = {
196	.fb_probe = tegra_fb_probe,
197};
198
199/*
200 *	Exported functions
201 */
202struct fb_info *
203tegra_drm_fb_getinfo(struct drm_device *drm_dev)
204{
205	struct tegra_fb *fb;
206	struct tegra_drm *drm;
207
208	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
209	fb = drm->fb;
210	if (fb == NULL)
211		return (NULL);
212	return (fb->fb_helper.fbdev);
213}
214
215struct tegra_bo *
216tegra_fb_get_plane(struct tegra_fb *fb, int idx)
217{
218
219	if (idx >= drm_format_num_planes(fb->drm_fb.pixel_format))
220		return (NULL);
221	if (idx >= fb->nplanes)
222		return (NULL);
223	return (fb->planes[idx]);
224}
225
226int
227tegra_drm_fb_init(struct drm_device *drm_dev)
228{
229	struct tegra_fb *fb;
230	struct tegra_drm *drm;
231	int rv;
232
233	drm = drm_dev->dev_private;
234	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
235	fb = malloc(sizeof(*fb), DRM_MEM_DRIVER, M_WAITOK | M_ZERO);
236	drm->fb = fb;
237
238	fb->fb_helper.funcs = &fb_helper_funcs;
239	rv = drm_fb_helper_init(drm_dev, &fb->fb_helper,
240	    drm_dev->mode_config.num_crtc, drm_dev->mode_config.num_connector);
241	if (rv != 0) {
242		device_printf(drm_dev->dev,
243		    "Cannot initialize frame buffer %d\n", rv);
244		return (rv);
245	}
246
247	rv = drm_fb_helper_single_add_all_connectors(&fb->fb_helper);
248	if (rv != 0) {
249		device_printf(drm_dev->dev, "Cannot add all connectors: %d\n",
250		    rv);
251		goto err_fini;
252	}
253
254	rv = drm_fb_helper_initial_config(&fb->fb_helper, 32);
255	if (rv != 0) {
256		device_printf(drm_dev->dev,
257		    "Cannot set initial config: %d\n", rv);
258		goto err_fini;
259	}
260	/* XXXX Setup initial mode for FB */
261	/* drm_fb_helper_set_par(fb->fb_helper.fbdev); */
262	return 0;
263
264err_fini:
265	drm_fb_helper_fini(&fb->fb_helper);
266	return (rv);
267}
268
269int
270tegra_drm_fb_create(struct drm_device *drm, struct drm_file *file,
271    struct drm_mode_fb_cmd2 *cmd, struct drm_framebuffer **fb_res)
272{
273	int hsub, vsub, i;
274	int width, height, size, bpp;
275	struct tegra_bo *planes[4];
276	struct drm_gem_object *gem_obj;
277	struct tegra_fb *fb;
278	int rv, nplanes;
279
280	hsub = drm_format_horz_chroma_subsampling(cmd->pixel_format);
281	vsub = drm_format_vert_chroma_subsampling(cmd->pixel_format);
282
283	nplanes = drm_format_num_planes(cmd->pixel_format);
284	for (i = 0; i < nplanes; i++) {
285		width = cmd->width;
286		height = cmd->height;
287		if (i != 0) {
288			width /= hsub;
289			height /= vsub;
290		}
291		gem_obj = drm_gem_object_lookup(drm, file, cmd->handles[i]);
292		if (gem_obj == NULL) {
293			rv = -ENXIO;
294			goto fail;
295		}
296
297		bpp = drm_format_plane_cpp(cmd->pixel_format, i);
298		size = (height - 1) * cmd->pitches[i] +
299		    width * bpp + cmd->offsets[i];
300		if (gem_obj->size < size) {
301			rv = -EINVAL;
302			goto fail;
303		}
304		planes[i] = container_of(gem_obj, struct tegra_bo, gem_obj);
305	}
306
307	rv = fb_alloc(drm, cmd, planes, nplanes, &fb);
308	if (rv != 0)
309		goto fail;
310
311	*fb_res = &fb->drm_fb;
312	return (0);
313
314fail:
315	while (i--)
316		drm_gem_object_unreference_unlocked(&planes[i]->gem_obj);
317	return (rv);
318}
319
320void
321tegra_drm_fb_destroy(struct drm_device *drm_dev)
322{
323	struct fb_info *info;
324	struct tegra_fb *fb;
325	struct tegra_drm *drm;
326
327	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
328	fb = drm->fb;
329	if (fb == NULL)
330		return;
331	info = fb->fb_helper.fbdev;
332	drm_framebuffer_remove(&fb->drm_fb);
333	framebuffer_release(info);
334	drm_fb_helper_fini(&fb->fb_helper);
335	drm_framebuffer_cleanup(&fb->drm_fb);
336	free(fb, DRM_MEM_DRIVER);
337	drm->fb = NULL;
338}
339