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 5 /* fb_deferred_io.delay in jiffies */
27 static int fb_defio
= 1; /* 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
;
36 struct list_head fbdev_list
;
40 #define DL_ALIGN_UP(x, a) ALIGN(x, a)
41 #define DL_ALIGN_DOWN(x, a) ALIGN(x-(a-1), a)
43 /** Read the red component (0..255) of a 32 bpp colour. */
44 #define DLO_RGB_GETRED(col) (uint8_t)((col) & 0xFF)
46 /** Read the green component (0..255) of a 32 bpp colour. */
47 #define DLO_RGB_GETGRN(col) (uint8_t)(((col) >> 8) & 0xFF)
49 /** Read the blue component (0..255) of a 32 bpp colour. */
50 #define DLO_RGB_GETBLU(col) (uint8_t)(((col) >> 16) & 0xFF)
52 /** Return red/green component of a 16 bpp colour number. */
53 #define DLO_RG16(red, grn) (uint8_t)((((red) & 0xF8) | ((grn) >> 5)) & 0xFF)
55 /** Return green/blue component of a 16 bpp colour number. */
56 #define DLO_GB16(grn, blu) (uint8_t)(((((grn) & 0x1C) << 3) | ((blu) >> 3)) & 0xFF)
58 /** Return 8 bpp colour number from red, green and blue components. */
59 #define DLO_RGB8(red, grn, blu) ((((red) << 5) | (((grn) & 3) << 3) | ((blu) & 7)) & 0xFF)
62 static uint8_t rgb8(uint32_t col
)
64 uint8_t red
= DLO_RGB_GETRED(col
);
65 uint8_t grn
= DLO_RGB_GETGRN(col
);
66 uint8_t blu
= DLO_RGB_GETBLU(col
);
68 return DLO_RGB8(red
, grn
, blu
);
71 static uint16_t rgb16(uint32_t col
)
73 uint8_t red
= DLO_RGB_GETRED(col
);
74 uint8_t grn
= DLO_RGB_GETGRN(col
);
75 uint8_t blu
= DLO_RGB_GETBLU(col
);
77 return (DLO_RG16(red
, grn
) << 8) + DLO_GB16(grn
, blu
);
82 * NOTE: fb_defio.c is holding info->fbdefio.mutex
83 * Touching ANY framebuffer memory that triggers a page fault
84 * in fb_defio will cause a deadlock, when it also tries to
85 * grab the same mutex.
87 static void udlfb_dpy_deferred_io(struct fb_info
*info
,
88 struct list_head
*pagelist
)
91 struct fb_deferred_io
*fbdefio
= info
->fbdefio
;
92 struct udl_fbdev
*ufbdev
= info
->par
;
93 struct drm_device
*dev
= ufbdev
->ufb
.base
.dev
;
94 struct udl_device
*udl
= dev
->dev_private
;
97 cycles_t start_cycles
, end_cycles
;
99 int bytes_identical
= 0;
100 int bytes_rendered
= 0;
105 start_cycles
= get_cycles();
107 urb
= udl_get_urb(dev
);
111 cmd
= urb
->transfer_buffer
;
113 /* walk the written page list and render each to device */
114 list_for_each_entry(cur
, &fbdefio
->pagelist
, lru
) {
116 if (udl_render_hline(dev
, (ufbdev
->ufb
.base
.bits_per_pixel
/ 8),
117 &urb
, (char *) info
->fix
.smem_start
,
118 &cmd
, cur
->index
<< PAGE_SHIFT
,
119 cur
->index
<< PAGE_SHIFT
,
120 PAGE_SIZE
, &bytes_identical
, &bytes_sent
))
122 bytes_rendered
+= PAGE_SIZE
;
125 if (cmd
> (char *) urb
->transfer_buffer
) {
126 /* Send partial buffer remaining before exiting */
127 int len
= cmd
- (char *) urb
->transfer_buffer
;
128 udl_submit_urb(dev
, urb
, len
);
131 udl_urb_completion(urb
);
134 atomic_add(bytes_sent
, &udl
->bytes_sent
);
135 atomic_add(bytes_identical
, &udl
->bytes_identical
);
136 atomic_add(bytes_rendered
, &udl
->bytes_rendered
);
137 end_cycles
= get_cycles();
138 atomic_add(((unsigned int) ((end_cycles
- start_cycles
)
139 >> 10)), /* Kcycles */
140 &udl
->cpu_kcycles_used
);
143 int udl_handle_damage(struct udl_framebuffer
*fb
, int x
, int y
,
144 int width
, int height
)
146 struct drm_device
*dev
= fb
->base
.dev
;
147 struct udl_device
*udl
= dev
->dev_private
;
150 cycles_t start_cycles
, end_cycles
;
152 int bytes_identical
= 0;
155 int bpp
= (fb
->base
.bits_per_pixel
/ 8);
160 if (!fb
->obj
->vmapping
) {
161 ret
= udl_gem_vmap(fb
->obj
);
162 if (ret
== -ENOMEM
) {
163 DRM_ERROR("failed to vmap fb\n");
166 if (!fb
->obj
->vmapping
) {
167 DRM_ERROR("failed to vmapping\n");
172 start_cycles
= get_cycles();
174 aligned_x
= DL_ALIGN_DOWN(x
, sizeof(unsigned long));
175 width
= DL_ALIGN_UP(width
+ (x
-aligned_x
), sizeof(unsigned long));
179 (x
+ width
> fb
->base
.width
) ||
180 (y
+ height
> fb
->base
.height
))
183 urb
= udl_get_urb(dev
);
186 cmd
= urb
->transfer_buffer
;
188 for (i
= y
; i
< y
+ height
; i
++) {
189 const int line_offset
= fb
->base
.pitches
[0] * i
;
190 const int byte_offset
= line_offset
+ (x
* bpp
);
191 const int dev_byte_offset
= (fb
->base
.width
* bpp
* i
) + (x
* bpp
);
192 if (udl_render_hline(dev
, bpp
, &urb
,
193 (char *) fb
->obj
->vmapping
,
194 &cmd
, byte_offset
, dev_byte_offset
,
196 &bytes_identical
, &bytes_sent
))
200 if (cmd
> (char *) urb
->transfer_buffer
) {
201 /* Send partial buffer remaining before exiting */
202 int len
= cmd
- (char *) urb
->transfer_buffer
;
203 ret
= udl_submit_urb(dev
, urb
, len
);
206 udl_urb_completion(urb
);
209 atomic_add(bytes_sent
, &udl
->bytes_sent
);
210 atomic_add(bytes_identical
, &udl
->bytes_identical
);
211 atomic_add(width
*height
*bpp
, &udl
->bytes_rendered
);
212 end_cycles
= get_cycles();
213 atomic_add(((unsigned int) ((end_cycles
- start_cycles
)
214 >> 10)), /* Kcycles */
215 &udl
->cpu_kcycles_used
);
220 static int udl_fb_mmap(struct fb_info
*info
, struct vm_area_struct
*vma
)
222 unsigned long start
= vma
->vm_start
;
223 unsigned long size
= vma
->vm_end
- vma
->vm_start
;
224 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
225 unsigned long page
, pos
;
227 if (offset
+ size
> info
->fix
.smem_len
)
230 pos
= (unsigned long)info
->fix
.smem_start
+ offset
;
232 pr_notice("mmap() framebuffer addr:%lu size:%lu\n",
236 page
= vmalloc_to_pfn((void *)pos
);
237 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
))
242 if (size
> PAGE_SIZE
)
248 /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
252 static void udl_fb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
254 struct udl_fbdev
*ufbdev
= info
->par
;
256 sys_fillrect(info
, rect
);
258 udl_handle_damage(&ufbdev
->ufb
, rect
->dx
, rect
->dy
, rect
->width
,
262 static void udl_fb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*region
)
264 struct udl_fbdev
*ufbdev
= info
->par
;
266 sys_copyarea(info
, region
);
268 udl_handle_damage(&ufbdev
->ufb
, region
->dx
, region
->dy
, region
->width
,
272 static void udl_fb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
274 struct udl_fbdev
*ufbdev
= info
->par
;
276 sys_imageblit(info
, image
);
278 udl_handle_damage(&ufbdev
->ufb
, image
->dx
, image
->dy
, image
->width
,
283 * It's common for several clients to have framebuffer open simultaneously.
284 * e.g. both fbcon and X. Makes things interesting.
285 * Assumes caller is holding info->lock (for open and release at least)
287 static int udl_fb_open(struct fb_info
*info
, int user
)
289 struct udl_fbdev
*ufbdev
= info
->par
;
290 struct drm_device
*dev
= ufbdev
->ufb
.base
.dev
;
291 struct udl_device
*udl
= dev
->dev_private
;
293 /* If the USB device is gone, we don't accept new opens */
294 if (drm_device_is_unplugged(udl
->ddev
))
299 if (fb_defio
&& (info
->fbdefio
== NULL
)) {
300 /* enable defio at last moment if not disabled by client */
302 struct fb_deferred_io
*fbdefio
;
304 fbdefio
= kmalloc(sizeof(struct fb_deferred_io
), GFP_KERNEL
);
307 fbdefio
->delay
= DL_DEFIO_WRITE_DELAY
;
308 fbdefio
->deferred_io
= udlfb_dpy_deferred_io
;
311 info
->fbdefio
= fbdefio
;
312 fb_deferred_io_init(info
);
315 pr_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",
316 info
->node
, user
, info
, ufbdev
->fb_count
);
323 * Assumes caller is holding info->lock mutex (for open and release at least)
325 static int udl_fb_release(struct fb_info
*info
, int user
)
327 struct udl_fbdev
*ufbdev
= info
->par
;
331 if ((ufbdev
->fb_count
== 0) && (info
->fbdefio
)) {
332 fb_deferred_io_cleanup(info
);
333 kfree(info
->fbdefio
);
334 info
->fbdefio
= NULL
;
335 info
->fbops
->fb_mmap
= udl_fb_mmap
;
338 pr_warn("released /dev/fb%d user=%d count=%d\n",
339 info
->node
, user
, ufbdev
->fb_count
);
344 static struct fb_ops udlfb_ops
= {
345 .owner
= THIS_MODULE
,
346 .fb_check_var
= drm_fb_helper_check_var
,
347 .fb_set_par
= drm_fb_helper_set_par
,
348 .fb_fillrect
= udl_fb_fillrect
,
349 .fb_copyarea
= udl_fb_copyarea
,
350 .fb_imageblit
= udl_fb_imageblit
,
351 .fb_pan_display
= drm_fb_helper_pan_display
,
352 .fb_blank
= drm_fb_helper_blank
,
353 .fb_setcmap
= drm_fb_helper_setcmap
,
354 .fb_debug_enter
= drm_fb_helper_debug_enter
,
355 .fb_debug_leave
= drm_fb_helper_debug_leave
,
356 .fb_mmap
= udl_fb_mmap
,
357 .fb_open
= udl_fb_open
,
358 .fb_release
= udl_fb_release
,
361 static void udl_crtc_fb_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
366 static void udl_crtc_fb_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
367 u16
*blue
, int regno
)
374 static int udl_user_framebuffer_dirty(struct drm_framebuffer
*fb
,
375 struct drm_file
*file
,
376 unsigned flags
, unsigned color
,
377 struct drm_clip_rect
*clips
,
380 struct udl_framebuffer
*ufb
= to_udl_fb(fb
);
387 if (ufb
->obj
->base
.import_attach
) {
388 ret
= dma_buf_begin_cpu_access(ufb
->obj
->base
.import_attach
->dmabuf
,
389 0, ufb
->obj
->base
.size
,
395 for (i
= 0; i
< num_clips
; i
++) {
396 ret
= udl_handle_damage(ufb
, clips
[i
].x1
, clips
[i
].y1
,
397 clips
[i
].x2
- clips
[i
].x1
,
398 clips
[i
].y2
- clips
[i
].y1
);
403 if (ufb
->obj
->base
.import_attach
) {
404 dma_buf_end_cpu_access(ufb
->obj
->base
.import_attach
->dmabuf
,
405 0, ufb
->obj
->base
.size
,
411 static void udl_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
413 struct udl_framebuffer
*ufb
= to_udl_fb(fb
);
416 drm_gem_object_unreference_unlocked(&ufb
->obj
->base
);
418 drm_framebuffer_cleanup(fb
);
422 static const struct drm_framebuffer_funcs udlfb_funcs
= {
423 .destroy
= udl_user_framebuffer_destroy
,
424 .dirty
= udl_user_framebuffer_dirty
,
425 .create_handle
= NULL
,
430 udl_framebuffer_init(struct drm_device
*dev
,
431 struct udl_framebuffer
*ufb
,
432 struct drm_mode_fb_cmd2
*mode_cmd
,
433 struct udl_gem_object
*obj
)
438 ret
= drm_framebuffer_init(dev
, &ufb
->base
, &udlfb_funcs
);
439 drm_helper_mode_fill_fb_struct(&ufb
->base
, mode_cmd
);
444 static int udlfb_create(struct udl_fbdev
*ufbdev
,
445 struct drm_fb_helper_surface_size
*sizes
)
447 struct drm_device
*dev
= ufbdev
->helper
.dev
;
448 struct fb_info
*info
;
449 struct device
*device
= &dev
->usbdev
->dev
;
450 struct drm_framebuffer
*fb
;
451 struct drm_mode_fb_cmd2 mode_cmd
;
452 struct udl_gem_object
*obj
;
456 if (sizes
->surface_bpp
== 24)
457 sizes
->surface_bpp
= 32;
459 mode_cmd
.width
= sizes
->surface_width
;
460 mode_cmd
.height
= sizes
->surface_height
;
461 mode_cmd
.pitches
[0] = mode_cmd
.width
* ((sizes
->surface_bpp
+ 7) / 8);
463 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(sizes
->surface_bpp
,
464 sizes
->surface_depth
);
466 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
467 size
= ALIGN(size
, PAGE_SIZE
);
469 obj
= udl_gem_alloc_object(dev
, size
);
473 ret
= udl_gem_vmap(obj
);
475 DRM_ERROR("failed to vmap fb\n");
479 info
= framebuffer_alloc(0, device
);
486 ret
= udl_framebuffer_init(dev
, &ufbdev
->ufb
, &mode_cmd
, obj
);
490 fb
= &ufbdev
->ufb
.base
;
492 ufbdev
->helper
.fb
= fb
;
493 ufbdev
->helper
.fbdev
= info
;
495 strcpy(info
->fix
.id
, "udldrmfb");
497 info
->screen_base
= ufbdev
->ufb
.obj
->vmapping
;
498 info
->fix
.smem_len
= size
;
499 info
->fix
.smem_start
= (unsigned long)ufbdev
->ufb
.obj
->vmapping
;
501 info
->flags
= FBINFO_DEFAULT
| FBINFO_CAN_FORCE_OUTPUT
;
502 info
->fbops
= &udlfb_ops
;
503 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
504 drm_fb_helper_fill_var(info
, &ufbdev
->helper
, sizes
->fb_width
, sizes
->fb_height
);
506 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
513 DRM_DEBUG_KMS("allocated %dx%d vmal %p\n",
514 fb
->width
, fb
->height
,
515 ufbdev
->ufb
.obj
->vmapping
);
519 drm_gem_object_unreference(&ufbdev
->ufb
.obj
->base
);
524 static int udl_fb_find_or_create_single(struct drm_fb_helper
*helper
,
525 struct drm_fb_helper_surface_size
*sizes
)
527 struct udl_fbdev
*ufbdev
= (struct udl_fbdev
*)helper
;
532 ret
= udlfb_create(ufbdev
, sizes
);
541 static struct drm_fb_helper_funcs udl_fb_helper_funcs
= {
542 .gamma_set
= udl_crtc_fb_gamma_set
,
543 .gamma_get
= udl_crtc_fb_gamma_get
,
544 .fb_probe
= udl_fb_find_or_create_single
,
547 static void udl_fbdev_destroy(struct drm_device
*dev
,
548 struct udl_fbdev
*ufbdev
)
550 struct fb_info
*info
;
551 if (ufbdev
->helper
.fbdev
) {
552 info
= ufbdev
->helper
.fbdev
;
553 unregister_framebuffer(info
);
555 fb_dealloc_cmap(&info
->cmap
);
556 framebuffer_release(info
);
558 drm_fb_helper_fini(&ufbdev
->helper
);
559 drm_framebuffer_cleanup(&ufbdev
->ufb
.base
);
560 drm_gem_object_unreference_unlocked(&ufbdev
->ufb
.obj
->base
);
563 int udl_fbdev_init(struct drm_device
*dev
)
565 struct udl_device
*udl
= dev
->dev_private
;
566 int bpp_sel
= fb_bpp
;
567 struct udl_fbdev
*ufbdev
;
570 ufbdev
= kzalloc(sizeof(struct udl_fbdev
), GFP_KERNEL
);
575 ufbdev
->helper
.funcs
= &udl_fb_helper_funcs
;
577 ret
= drm_fb_helper_init(dev
, &ufbdev
->helper
,
585 drm_fb_helper_single_add_all_connectors(&ufbdev
->helper
);
586 drm_fb_helper_initial_config(&ufbdev
->helper
, bpp_sel
);
590 void udl_fbdev_cleanup(struct drm_device
*dev
)
592 struct udl_device
*udl
= dev
->dev_private
;
596 udl_fbdev_destroy(dev
, udl
->fbdev
);
601 void udl_fbdev_unplug(struct drm_device
*dev
)
603 struct udl_device
*udl
= dev
->dev_private
;
604 struct udl_fbdev
*ufbdev
;
609 if (ufbdev
->helper
.fbdev
) {
610 struct fb_info
*info
;
611 info
= ufbdev
->helper
.fbdev
;
612 unlink_framebuffer(info
);
616 struct drm_framebuffer
*
617 udl_fb_user_fb_create(struct drm_device
*dev
,
618 struct drm_file
*file
,
619 struct drm_mode_fb_cmd2
*mode_cmd
)
621 struct drm_gem_object
*obj
;
622 struct udl_framebuffer
*ufb
;
626 obj
= drm_gem_object_lookup(dev
, file
, mode_cmd
->handles
[0]);
628 return ERR_PTR(-ENOENT
);
630 size
= mode_cmd
->pitches
[0] * mode_cmd
->height
;
631 size
= ALIGN(size
, PAGE_SIZE
);
633 if (size
> obj
->size
) {
634 DRM_ERROR("object size not sufficient for fb %d %zu %d %d\n", size
, obj
->size
, mode_cmd
->pitches
[0], mode_cmd
->height
);
635 return ERR_PTR(-ENOMEM
);
638 ufb
= kzalloc(sizeof(*ufb
), GFP_KERNEL
);
640 return ERR_PTR(-ENOMEM
);
642 ret
= udl_framebuffer_init(dev
, ufb
, mode_cmd
, to_udl_bo(obj
));
645 return ERR_PTR(-EINVAL
);