1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/
  4 * Author: Rob Clark <rob@ti.com>
  5 */
  6
  7#include <linux/fb.h>
  8
  9#include <drm/drm_client_setup.h>
 10#include <drm/drm_drv.h>
 11#include <drm/drm_crtc_helper.h>
 12#include <drm/drm_fb_helper.h>
 13#include <drm/drm_file.h>
 14#include <drm/drm_fourcc.h>
 15#include <drm/drm_framebuffer.h>
 16#include <drm/drm_gem_framebuffer_helper.h>
 17#include <drm/drm_managed.h>
 18#include <drm/drm_util.h>
 19
 20#include "omap_drv.h"
 21#include "omap_fbdev.h"
 22
 23MODULE_PARM_DESC(ywrap, "Enable ywrap scrolling (omap44xx and later, default 'y')");
 24static bool ywrap_enabled = true;
 25module_param_named(ywrap, ywrap_enabled, bool, 0644);
 26
 27/*
 28 * fbdev funcs, to implement legacy fbdev interface on top of drm driver
 29 */
 30
 31struct omap_fbdev {
 32	struct drm_device *dev;
 33	bool ywrap_enabled;
 34
 35	/* for deferred dmm roll when getting called in atomic ctx */
 36	struct work_struct work;
 37};
 38
 39static struct drm_fb_helper *get_fb(struct fb_info *fbi);
 40
 41static void pan_worker(struct work_struct *work)
 42{
 43	struct omap_fbdev *fbdev = container_of(work, struct omap_fbdev, work);
 44	struct drm_fb_helper *helper = fbdev->dev->fb_helper;
 45	struct fb_info *fbi = helper->info;
 46	struct drm_gem_object *bo = drm_gem_fb_get_obj(helper->fb, 0);
 47	int npages;
 48
 49	/* DMM roll shifts in 4K pages: */
 50	npages = fbi->fix.line_length >> PAGE_SHIFT;
 51	omap_gem_roll(bo, fbi->var.yoffset * npages);
 52}
 53
 54FB_GEN_DEFAULT_DEFERRED_DMAMEM_OPS(omap_fbdev,
 55				   drm_fb_helper_damage_range,
 56				   drm_fb_helper_damage_area)
 57
 58static int omap_fbdev_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
 59{
 60	struct drm_fb_helper *helper = get_fb(fbi);
 61	struct omap_drm_private *priv;
 62	struct omap_fbdev *fbdev;
 63
 64	if (!helper)
 65		goto fallback;
 66
 67	priv = helper->dev->dev_private;
 68	fbdev = priv->fbdev;
 69
 70	if (!fbdev->ywrap_enabled)
 71		goto fallback;
 72
 73	if (drm_can_sleep())
 74		pan_worker(&fbdev->work);
 75	else
 76		queue_work(priv->wq, &fbdev->work);
 77
 78	return 0;
 79
 80fallback:
 81	return drm_fb_helper_pan_display(var, fbi);
 82}
 83
 84static int omap_fbdev_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 85{
 86	vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
 87
 88	return fb_deferred_io_mmap(info, vma);
 89}
 90
 91static void omap_fbdev_fb_destroy(struct fb_info *info)
 92{
 93	struct drm_fb_helper *helper = info->par;
 94	struct drm_framebuffer *fb = helper->fb;
 95	struct drm_gem_object *bo = drm_gem_fb_get_obj(fb, 0);
 96
 97	DBG();
 98
 99	fb_deferred_io_cleanup(info);
100	drm_fb_helper_fini(helper);
101
102	omap_gem_unpin(bo);
103	drm_framebuffer_remove(fb);
104
105	drm_client_release(&helper->client);
106	drm_fb_helper_unprepare(helper);
107	kfree(helper);
108}
109
110/*
111 * For now, we cannot use FB_DEFAULT_DEFERRED_OPS and fb_deferred_io_mmap()
112 * because we use write-combine.
113 */
114static const struct fb_ops omap_fb_ops = {
115	.owner = THIS_MODULE,
116	__FB_DEFAULT_DEFERRED_OPS_RDWR(omap_fbdev),
117	.fb_check_var	= drm_fb_helper_check_var,
118	.fb_set_par	= drm_fb_helper_set_par,
119	.fb_setcmap	= drm_fb_helper_setcmap,
120	.fb_blank	= drm_fb_helper_blank,
121	.fb_pan_display = omap_fbdev_pan_display,
122	__FB_DEFAULT_DEFERRED_OPS_DRAW(omap_fbdev),
123	.fb_ioctl	= drm_fb_helper_ioctl,
124	.fb_mmap	= omap_fbdev_fb_mmap,
125	.fb_destroy	= omap_fbdev_fb_destroy,
126};
127
128static int omap_fbdev_dirty(struct drm_fb_helper *helper, struct drm_clip_rect *clip)
129{
130	if (!(clip->x1 < clip->x2 && clip->y1 < clip->y2))
131		return 0;
132
133	if (helper->fb->funcs->dirty)
134		return helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, clip, 1);
135
136	return 0;
137}
138
139static const struct drm_fb_helper_funcs omap_fbdev_helper_funcs = {
140	.fb_dirty = omap_fbdev_dirty,
141};
142
143static struct drm_fb_helper *get_fb(struct fb_info *fbi)
144{
145	if (!fbi || strcmp(fbi->fix.id, MODULE_NAME)) {
146		/* these are not the fb's you're looking for */
147		return NULL;
148	}
149	return fbi->par;
150}
151
152int omap_fbdev_driver_fbdev_probe(struct drm_fb_helper *helper,
153				  struct drm_fb_helper_surface_size *sizes)
154{
155	struct drm_device *dev = helper->dev;
156	struct omap_drm_private *priv = dev->dev_private;
157	struct omap_fbdev *fbdev = priv->fbdev;
158	struct drm_framebuffer *fb = NULL;
159	union omap_gem_size gsize;
160	struct fb_info *fbi = NULL;
161	struct drm_mode_fb_cmd2 mode_cmd = {0};
162	struct drm_gem_object *bo;
163	dma_addr_t dma_addr;
164	int ret;
165
166	sizes->surface_bpp = 32;
167	sizes->surface_depth = 24;
168
169	DBG("create fbdev: %dx%d@%d (%dx%d)", sizes->surface_width,
170			sizes->surface_height, sizes->surface_bpp,
171			sizes->fb_width, sizes->fb_height);
172
173	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
174			sizes->surface_depth);
175
176	mode_cmd.width = sizes->surface_width;
177	mode_cmd.height = sizes->surface_height;
178
179	mode_cmd.pitches[0] =
180			DIV_ROUND_UP(mode_cmd.width * sizes->surface_bpp, 8);
181
182	fbdev->ywrap_enabled = priv->has_dmm && ywrap_enabled;
183	if (fbdev->ywrap_enabled) {
184		/* need to align pitch to page size if using DMM scrolling */
185		mode_cmd.pitches[0] = PAGE_ALIGN(mode_cmd.pitches[0]);
186	}
187
188	/* allocate backing bo */
189	gsize = (union omap_gem_size){
190		.bytes = PAGE_ALIGN(mode_cmd.pitches[0] * mode_cmd.height),
191	};
192	DBG("allocating %d bytes for fb %d", gsize.bytes, dev->primary->index);
193	bo = omap_gem_new(dev, gsize, OMAP_BO_SCANOUT | OMAP_BO_WC);
194	if (!bo) {
195		dev_err(dev->dev, "failed to allocate buffer object\n");
196		ret = -ENOMEM;
197		goto fail;
198	}
199
200	fb = omap_framebuffer_init(dev, &mode_cmd, &bo);
201	if (IS_ERR(fb)) {
202		dev_err(dev->dev, "failed to allocate fb\n");
203		/* note: if fb creation failed, we can't rely on fb destroy
204		 * to unref the bo:
205		 */
206		drm_gem_object_put(bo);
207		ret = PTR_ERR(fb);
208		goto fail;
209	}
210
211	/* note: this keeps the bo pinned.. which is perhaps not ideal,
212	 * but is needed as long as we use fb_mmap() to mmap to userspace
213	 * (since this happens using fix.smem_start).  Possibly we could
214	 * implement our own mmap using GEM mmap support to avoid this
215	 * (non-tiled buffer doesn't need to be pinned for fbcon to write
216	 * to it).  Then we just need to be sure that we are able to re-
217	 * pin it in case of an opps.
218	 */
219	ret = omap_gem_pin(bo, &dma_addr);
220	if (ret) {
221		dev_err(dev->dev, "could not pin framebuffer\n");
222		ret = -ENOMEM;
223		goto fail;
224	}
225
226	fbi = drm_fb_helper_alloc_info(helper);
227	if (IS_ERR(fbi)) {
228		dev_err(dev->dev, "failed to allocate fb info\n");
229		ret = PTR_ERR(fbi);
230		goto fail;
231	}
232
233	DBG("fbi=%p, dev=%p", fbi, dev);
234
235	helper->funcs = &omap_fbdev_helper_funcs;
236	helper->fb = fb;
237
238	fbi->fbops = &omap_fb_ops;
239
240	drm_fb_helper_fill_info(fbi, helper, sizes);
241
242	fbi->flags |= FBINFO_VIRTFB;
243	fbi->screen_buffer = omap_gem_vaddr(bo);
244	fbi->screen_size = bo->size;
245	fbi->fix.smem_start = dma_addr;
246	fbi->fix.smem_len = bo->size;
247
248	/* deferred I/O */
249	helper->fbdefio.delay = HZ / 20;
250	helper->fbdefio.deferred_io = drm_fb_helper_deferred_io;
251
252	fbi->fbdefio = &helper->fbdefio;
253	ret = fb_deferred_io_init(fbi);
254	if (ret)
255		goto fail;
256
257	/* if we have DMM, then we can use it for scrolling by just
258	 * shuffling pages around in DMM rather than doing sw blit.
259	 */
260	if (fbdev->ywrap_enabled) {
261		DRM_INFO("Enabling DMM ywrap scrolling\n");
262		fbi->flags |= FBINFO_HWACCEL_YWRAP | FBINFO_READS_FAST;
263		fbi->fix.ywrapstep = 1;
264	}
265
266
267	DBG("par=%p, %dx%d", fbi->par, fbi->var.xres, fbi->var.yres);
268	DBG("allocated %dx%d fb", fb->width, fb->height);
269
270	return 0;
271
272fail:
273
274	if (ret) {
275		if (fb)
276			drm_framebuffer_remove(fb);
277	}
278
279	return ret;
280}
281
282void omap_fbdev_setup(struct drm_device *dev)
283{
284	struct omap_drm_private *priv = dev->dev_private;
285	struct omap_fbdev *fbdev;
286
287	drm_WARN(dev, !dev->registered, "Device has not been registered.\n");
288	drm_WARN(dev, dev->fb_helper, "fb_helper is already set!\n");
289
290	fbdev = drmm_kzalloc(dev, sizeof(*fbdev), GFP_KERNEL);
291	if (!fbdev)
292		return;
293	fbdev->dev = dev;
294	INIT_WORK(&fbdev->work, pan_worker);
295
296	priv->fbdev = fbdev;
297
298	drm_client_setup(dev, NULL);
299}