2 * Copyright (C) 2012 Red Hat
4 * based in parts on udlfb.c:
5 * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
6 * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
7 * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
9 * This file is subject to the terms and conditions of the GNU General Public
10 * License v2. See the file COPYING in the main directory of this archive for
13 #include <linux/module.h>
14 #include <linux/slab.h>
16 #include <linux/dma-buf.h>
19 #include <drm/drm_crtc.h>
20 #include <drm/drm_crtc_helper.h>
23 #include <drm/drm_fb_helper.h>
25 #define DL_DEFIO_WRITE_DELAY (HZ/20) /* fb_deferred_io.delay in jiffies */
27 static int fb_defio = 0; /* Optionally enable experimental fb_defio mmap support */
28 static int fb_bpp = 16;
30 module_param(fb_bpp, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
31 module_param(fb_defio, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
34 struct drm_fb_helper helper;
35 struct udl_framebuffer ufb;
39 #define DL_ALIGN_UP(x, a) ALIGN(x, a)
40 #define DL_ALIGN_DOWN(x, a) ALIGN(x-(a-1), a)
42 /** Read the red component (0..255) of a 32 bpp colour. */
43 #define DLO_RGB_GETRED(col) (uint8_t)((col) & 0xFF)
45 /** Read the green component (0..255) of a 32 bpp colour. */
46 #define DLO_RGB_GETGRN(col) (uint8_t)(((col) >> 8) & 0xFF)
48 /** Read the blue component (0..255) of a 32 bpp colour. */
49 #define DLO_RGB_GETBLU(col) (uint8_t)(((col) >> 16) & 0xFF)
51 /** Return red/green component of a 16 bpp colour number. */
52 #define DLO_RG16(red, grn) (uint8_t)((((red) & 0xF8) | ((grn) >> 5)) & 0xFF)
54 /** Return green/blue component of a 16 bpp colour number. */
55 #define DLO_GB16(grn, blu) (uint8_t)(((((grn) & 0x1C) << 3) | ((blu) >> 3)) & 0xFF)
57 /** Return 8 bpp colour number from red, green and blue components. */
58 #define DLO_RGB8(red, grn, blu) ((((red) << 5) | (((grn) & 3) << 3) | ((blu) & 7)) & 0xFF)
61 static uint8_t rgb8(uint32_t col)
63 uint8_t red = DLO_RGB_GETRED(col);
64 uint8_t grn = DLO_RGB_GETGRN(col);
65 uint8_t blu = DLO_RGB_GETBLU(col);
67 return DLO_RGB8(red, grn, blu);
70 static uint16_t rgb16(uint32_t col)
72 uint8_t red = DLO_RGB_GETRED(col);
73 uint8_t grn = DLO_RGB_GETGRN(col);
74 uint8_t blu = DLO_RGB_GETBLU(col);
76 return (DLO_RG16(red, grn) << 8) + DLO_GB16(grn, blu);
80 int udl_handle_damage(struct udl_framebuffer *fb, int x, int y,
81 int width, int height)
83 struct drm_device *dev = fb->base.dev;
84 struct udl_device *udl = dev->dev_private;
87 cycles_t start_cycles, end_cycles;
89 int bytes_identical = 0;
92 int bpp = (fb->base.bits_per_pixel / 8);
97 if (!fb->obj->vmapping) {
98 ret = udl_gem_vmap(fb->obj);
100 DRM_ERROR("failed to vmap fb\n");
103 if (!fb->obj->vmapping) {
104 DRM_ERROR("failed to vmapping\n");
109 aligned_x = DL_ALIGN_DOWN(x, sizeof(unsigned long));
110 width = DL_ALIGN_UP(width + (x-aligned_x), sizeof(unsigned long));
114 (x + width > fb->base.width) ||
115 (y + height > fb->base.height))
118 start_cycles = get_cycles();
120 urb = udl_get_urb(dev);
123 cmd = urb->transfer_buffer;
125 for (i = y; i < y + height ; i++) {
126 const int line_offset = fb->base.pitches[0] * i;
127 const int byte_offset = line_offset + (x * bpp);
128 const int dev_byte_offset = (fb->base.width * bpp * i) + (x * bpp);
129 if (udl_render_hline(dev, bpp, &urb,
130 (char *) fb->obj->vmapping,
131 &cmd, byte_offset, dev_byte_offset,
133 &bytes_identical, &bytes_sent))
137 if (cmd > (char *) urb->transfer_buffer) {
138 /* Send partial buffer remaining before exiting */
140 if (cmd < (char *) urb->transfer_buffer + urb->transfer_buffer_length)
142 len = cmd - (char *) urb->transfer_buffer;
143 ret = udl_submit_urb(dev, urb, len);
146 udl_urb_completion(urb);
149 atomic_add(bytes_sent, &udl->bytes_sent);
150 atomic_add(bytes_identical, &udl->bytes_identical);
151 atomic_add(width*height*bpp, &udl->bytes_rendered);
152 end_cycles = get_cycles();
153 atomic_add(((unsigned int) ((end_cycles - start_cycles)
154 >> 10)), /* Kcycles */
155 &udl->cpu_kcycles_used);
160 static int udl_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
162 unsigned long start = vma->vm_start;
163 unsigned long size = vma->vm_end - vma->vm_start;
164 unsigned long offset;
165 unsigned long page, pos;
167 if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
170 offset = vma->vm_pgoff << PAGE_SHIFT;
172 if (offset > info->fix.smem_len || size > info->fix.smem_len - offset)
175 pos = (unsigned long)info->fix.smem_start + offset;
177 pr_notice("mmap() framebuffer addr:%lu size:%lu\n",
181 page = vmalloc_to_pfn((void *)pos);
182 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
187 if (size > PAGE_SIZE)
193 /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
198 * It's common for several clients to have framebuffer open simultaneously.
199 * e.g. both fbcon and X. Makes things interesting.
200 * Assumes caller is holding info->lock (for open and release at least)
202 static int udl_fb_open(struct fb_info *info, int user)
204 struct udl_fbdev *ufbdev = info->par;
205 struct drm_device *dev = ufbdev->ufb.base.dev;
206 struct udl_device *udl = dev->dev_private;
208 /* If the USB device is gone, we don't accept new opens */
209 if (drm_device_is_unplugged(udl->ddev))
214 #ifdef CONFIG_DRM_FBDEV_EMULATION
215 if (fb_defio && (info->fbdefio == NULL)) {
216 /* enable defio at last moment if not disabled by client */
218 struct fb_deferred_io *fbdefio;
220 fbdefio = kzalloc(sizeof(struct fb_deferred_io), GFP_KERNEL);
223 fbdefio->delay = DL_DEFIO_WRITE_DELAY;
224 fbdefio->deferred_io = drm_fb_helper_deferred_io;
227 info->fbdefio = fbdefio;
228 fb_deferred_io_init(info);
232 pr_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",
233 info->node, user, info, ufbdev->fb_count);
240 * Assumes caller is holding info->lock mutex (for open and release at least)
242 static int udl_fb_release(struct fb_info *info, int user)
244 struct udl_fbdev *ufbdev = info->par;
248 #ifdef CONFIG_DRM_FBDEV_EMULATION
249 if ((ufbdev->fb_count == 0) && (info->fbdefio)) {
250 fb_deferred_io_cleanup(info);
251 kfree(info->fbdefio);
252 info->fbdefio = NULL;
253 info->fbops->fb_mmap = udl_fb_mmap;
257 pr_warn("released /dev/fb%d user=%d count=%d\n",
258 info->node, user, ufbdev->fb_count);
263 static struct fb_ops udlfb_ops = {
264 .owner = THIS_MODULE,
265 .fb_check_var = drm_fb_helper_check_var,
266 .fb_set_par = drm_fb_helper_set_par,
267 .fb_fillrect = drm_fb_helper_sys_fillrect,
268 .fb_copyarea = drm_fb_helper_sys_copyarea,
269 .fb_imageblit = drm_fb_helper_sys_imageblit,
270 .fb_pan_display = drm_fb_helper_pan_display,
271 .fb_blank = drm_fb_helper_blank,
272 .fb_setcmap = drm_fb_helper_setcmap,
273 .fb_debug_enter = drm_fb_helper_debug_enter,
274 .fb_debug_leave = drm_fb_helper_debug_leave,
275 .fb_mmap = udl_fb_mmap,
276 .fb_open = udl_fb_open,
277 .fb_release = udl_fb_release,
280 static int udl_user_framebuffer_dirty(struct drm_framebuffer *fb,
281 struct drm_file *file,
282 unsigned flags, unsigned color,
283 struct drm_clip_rect *clips,
286 struct udl_framebuffer *ufb = to_udl_fb(fb);
290 drm_modeset_lock_all(fb->dev);
295 if (ufb->obj->base.import_attach) {
296 ret = dma_buf_begin_cpu_access(ufb->obj->base.import_attach->dmabuf,
302 for (i = 0; i < num_clips; i++) {
303 ret = udl_handle_damage(ufb, clips[i].x1, clips[i].y1,
304 clips[i].x2 - clips[i].x1,
305 clips[i].y2 - clips[i].y1);
310 if (ufb->obj->base.import_attach) {
311 ret = dma_buf_end_cpu_access(ufb->obj->base.import_attach->dmabuf,
316 drm_modeset_unlock_all(fb->dev);
321 static void udl_user_framebuffer_destroy(struct drm_framebuffer *fb)
323 struct udl_framebuffer *ufb = to_udl_fb(fb);
326 drm_gem_object_unreference_unlocked(&ufb->obj->base);
328 drm_framebuffer_cleanup(fb);
332 static const struct drm_framebuffer_funcs udlfb_funcs = {
333 .destroy = udl_user_framebuffer_destroy,
334 .dirty = udl_user_framebuffer_dirty,
339 udl_framebuffer_init(struct drm_device *dev,
340 struct udl_framebuffer *ufb,
341 const struct drm_mode_fb_cmd2 *mode_cmd,
342 struct udl_gem_object *obj)
347 drm_helper_mode_fill_fb_struct(&ufb->base, mode_cmd);
348 ret = drm_framebuffer_init(dev, &ufb->base, &udlfb_funcs);
353 static int udlfb_create(struct drm_fb_helper *helper,
354 struct drm_fb_helper_surface_size *sizes)
356 struct udl_fbdev *ufbdev =
357 container_of(helper, struct udl_fbdev, helper);
358 struct drm_device *dev = ufbdev->helper.dev;
359 struct fb_info *info;
360 struct drm_framebuffer *fb;
361 struct drm_mode_fb_cmd2 mode_cmd;
362 struct udl_gem_object *obj;
366 if (sizes->surface_bpp == 24)
367 sizes->surface_bpp = 32;
369 mode_cmd.width = sizes->surface_width;
370 mode_cmd.height = sizes->surface_height;
371 mode_cmd.pitches[0] = mode_cmd.width * ((sizes->surface_bpp + 7) / 8);
373 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
374 sizes->surface_depth);
376 size = mode_cmd.pitches[0] * mode_cmd.height;
377 size = ALIGN(size, PAGE_SIZE);
379 obj = udl_gem_alloc_object(dev, size);
383 ret = udl_gem_vmap(obj);
385 DRM_ERROR("failed to vmap fb\n");
389 info = drm_fb_helper_alloc_fbi(helper);
396 ret = udl_framebuffer_init(dev, &ufbdev->ufb, &mode_cmd, obj);
398 goto out_destroy_fbi;
400 fb = &ufbdev->ufb.base;
402 ufbdev->helper.fb = fb;
404 strcpy(info->fix.id, "udldrmfb");
406 info->screen_base = ufbdev->ufb.obj->vmapping;
407 info->fix.smem_len = size;
408 info->fix.smem_start = (unsigned long)ufbdev->ufb.obj->vmapping;
410 info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
411 info->fbops = &udlfb_ops;
412 drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
413 drm_fb_helper_fill_var(info, &ufbdev->helper, sizes->fb_width, sizes->fb_height);
415 DRM_DEBUG_KMS("allocated %dx%d vmal %p\n",
416 fb->width, fb->height,
417 ufbdev->ufb.obj->vmapping);
421 drm_fb_helper_release_fbi(helper);
423 drm_gem_object_unreference_unlocked(&ufbdev->ufb.obj->base);
428 static const struct drm_fb_helper_funcs udl_fb_helper_funcs = {
429 .fb_probe = udlfb_create,
432 static void udl_fbdev_destroy(struct drm_device *dev,
433 struct udl_fbdev *ufbdev)
435 drm_fb_helper_unregister_fbi(&ufbdev->helper);
436 drm_fb_helper_release_fbi(&ufbdev->helper);
437 drm_fb_helper_fini(&ufbdev->helper);
438 drm_framebuffer_unregister_private(&ufbdev->ufb.base);
439 drm_framebuffer_cleanup(&ufbdev->ufb.base);
440 drm_gem_object_unreference_unlocked(&ufbdev->ufb.obj->base);
443 int udl_fbdev_init(struct drm_device *dev)
445 struct udl_device *udl = dev->dev_private;
446 int bpp_sel = fb_bpp;
447 struct udl_fbdev *ufbdev;
450 ufbdev = kzalloc(sizeof(struct udl_fbdev), GFP_KERNEL);
456 drm_fb_helper_prepare(dev, &ufbdev->helper, &udl_fb_helper_funcs);
458 ret = drm_fb_helper_init(dev, &ufbdev->helper,
463 ret = drm_fb_helper_single_add_all_connectors(&ufbdev->helper);
467 /* disable all the possible outputs/crtcs before entering KMS mode */
468 drm_helper_disable_unused_functions(dev);
470 ret = drm_fb_helper_initial_config(&ufbdev->helper, bpp_sel);
477 drm_fb_helper_fini(&ufbdev->helper);
483 void udl_fbdev_cleanup(struct drm_device *dev)
485 struct udl_device *udl = dev->dev_private;
489 udl_fbdev_destroy(dev, udl->fbdev);
494 void udl_fbdev_unplug(struct drm_device *dev)
496 struct udl_device *udl = dev->dev_private;
497 struct udl_fbdev *ufbdev;
502 drm_fb_helper_unlink_fbi(&ufbdev->helper);
505 struct drm_framebuffer *
506 udl_fb_user_fb_create(struct drm_device *dev,
507 struct drm_file *file,
508 const struct drm_mode_fb_cmd2 *mode_cmd)
510 struct drm_gem_object *obj;
511 struct udl_framebuffer *ufb;
515 obj = drm_gem_object_lookup(file, mode_cmd->handles[0]);
517 return ERR_PTR(-ENOENT);
519 size = mode_cmd->pitches[0] * mode_cmd->height;
520 size = ALIGN(size, PAGE_SIZE);
522 if (size > obj->size) {
523 DRM_ERROR("object size not sufficient for fb %d %zu %d %d\n", size, obj->size, mode_cmd->pitches[0], mode_cmd->height);
524 return ERR_PTR(-ENOMEM);
527 ufb = kzalloc(sizeof(*ufb), GFP_KERNEL);
529 return ERR_PTR(-ENOMEM);
531 ret = udl_framebuffer_init(dev, ufb, mode_cmd, to_udl_bo(obj));
534 return ERR_PTR(-EINVAL);