1 /**************************************************************************
3 * Copyright © 2007 David Airlie
4 * Copyright © 2009-2015 VMware, Inc., Palo Alto, CA., USA
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
22 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
25 * USE OR OTHER DEALINGS IN THE SOFTWARE.
27 **************************************************************************/
29 #include <linux/export.h>
32 #include "vmwgfx_drv.h"
33 #include "vmwgfx_kms.h"
35 #include <drm/ttm/ttm_placement.h>
37 #define VMW_DIRTY_DELAY (HZ / 30)
40 struct vmw_private
*vmw_priv
;
44 struct mutex bo_mutex
;
45 struct vmw_dma_buffer
*vmw_bo
;
47 struct drm_framebuffer
*set_fb
;
48 struct drm_display_mode
*set_mode
;
53 u32 pseudo_palette
[17];
67 struct drm_crtc
*crtc
;
68 struct drm_connector
*con
;
69 struct delayed_work local_work
;
72 static int vmw_fb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
73 unsigned blue
, unsigned transp
,
76 struct vmw_fb_par
*par
= info
->par
;
77 u32
*pal
= par
->pseudo_palette
;
80 DRM_ERROR("Bad regno %u.\n", regno
);
84 switch (par
->set_fb
->format
->depth
) {
87 pal
[regno
] = ((red
& 0xff00) << 8) |
89 ((blue
& 0xff00) >> 8);
92 DRM_ERROR("Bad depth %u, bpp %u.\n",
93 par
->set_fb
->format
->depth
,
94 par
->set_fb
->format
->cpp
[0] * 8);
101 static int vmw_fb_check_var(struct fb_var_screeninfo
*var
,
102 struct fb_info
*info
)
104 int depth
= var
->bits_per_pixel
;
105 struct vmw_fb_par
*par
= info
->par
;
106 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
108 switch (var
->bits_per_pixel
) {
110 depth
= (var
->transp
.length
> 0) ? 32 : 24;
113 DRM_ERROR("Bad bpp %u.\n", var
->bits_per_pixel
);
119 var
->red
.offset
= 16;
120 var
->green
.offset
= 8;
121 var
->blue
.offset
= 0;
123 var
->green
.length
= 8;
124 var
->blue
.length
= 8;
125 var
->transp
.length
= 0;
126 var
->transp
.offset
= 0;
129 var
->red
.offset
= 16;
130 var
->green
.offset
= 8;
131 var
->blue
.offset
= 0;
133 var
->green
.length
= 8;
134 var
->blue
.length
= 8;
135 var
->transp
.length
= 8;
136 var
->transp
.offset
= 24;
139 DRM_ERROR("Bad depth %u.\n", depth
);
143 if ((var
->xoffset
+ var
->xres
) > par
->max_width
||
144 (var
->yoffset
+ var
->yres
) > par
->max_height
) {
145 DRM_ERROR("Requested geom can not fit in framebuffer\n");
149 if (!vmw_kms_validate_mode_vram(vmw_priv
,
150 var
->xres
* var
->bits_per_pixel
/8,
151 var
->yoffset
+ var
->yres
)) {
152 DRM_ERROR("Requested geom can not fit in framebuffer\n");
159 static int vmw_fb_blank(int blank
, struct fb_info
*info
)
165 * vmw_fb_dirty_flush - flush dirty regions to the kms framebuffer
167 * @work: The struct work_struct associated with this task.
169 * This function flushes the dirty regions of the vmalloc framebuffer to the
170 * kms framebuffer, and if the kms framebuffer is visible, also updated the
171 * corresponding displays. Note that this function runs even if the kms
172 * framebuffer is not bound to a crtc and thus not visible, but it's turned
173 * off during hibernation using the par->dirty.active bool.
175 static void vmw_fb_dirty_flush(struct work_struct
*work
)
177 struct vmw_fb_par
*par
= container_of(work
, struct vmw_fb_par
,
179 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
180 struct fb_info
*info
= vmw_priv
->fb_info
;
181 unsigned long irq_flags
;
182 s32 dst_x1
, dst_x2
, dst_y1
, dst_y2
, w
= 0, h
= 0;
183 u32 cpp
, max_x
, max_y
;
184 struct drm_clip_rect clip
;
185 struct drm_framebuffer
*cur_fb
;
186 u8
*src_ptr
, *dst_ptr
;
187 struct vmw_dma_buffer
*vbo
= par
->vmw_bo
;
190 if (!READ_ONCE(par
->dirty
.active
))
193 mutex_lock(&par
->bo_mutex
);
194 cur_fb
= par
->set_fb
;
198 (void) ttm_read_lock(&vmw_priv
->reservation_sem
, false);
199 (void) ttm_bo_reserve(&vbo
->base
, false, false, NULL
);
200 virtual = vmw_dma_buffer_map_and_cache(vbo
);
204 spin_lock_irqsave(&par
->dirty
.lock
, irq_flags
);
205 if (!par
->dirty
.active
) {
206 spin_unlock_irqrestore(&par
->dirty
.lock
, irq_flags
);
211 * Handle panning when copying from vmalloc to framebuffer.
212 * Clip dirty area to framebuffer.
214 cpp
= cur_fb
->format
->cpp
[0];
215 max_x
= par
->fb_x
+ cur_fb
->width
;
216 max_y
= par
->fb_y
+ cur_fb
->height
;
218 dst_x1
= par
->dirty
.x1
- par
->fb_x
;
219 dst_y1
= par
->dirty
.y1
- par
->fb_y
;
220 dst_x1
= max_t(s32
, dst_x1
, 0);
221 dst_y1
= max_t(s32
, dst_y1
, 0);
223 dst_x2
= par
->dirty
.x2
- par
->fb_x
;
224 dst_y2
= par
->dirty
.y2
- par
->fb_y
;
225 dst_x2
= min_t(s32
, dst_x2
, max_x
);
226 dst_y2
= min_t(s32
, dst_y2
, max_y
);
229 w
= max_t(s32
, 0, w
);
230 h
= max_t(s32
, 0, h
);
232 par
->dirty
.x1
= par
->dirty
.x2
= 0;
233 par
->dirty
.y1
= par
->dirty
.y2
= 0;
234 spin_unlock_irqrestore(&par
->dirty
.lock
, irq_flags
);
237 dst_ptr
= (u8
*)virtual +
238 (dst_y1
* par
->set_fb
->pitches
[0] + dst_x1
* cpp
);
239 src_ptr
= (u8
*)par
->vmalloc
+
240 ((dst_y1
+ par
->fb_y
) * info
->fix
.line_length
+
241 (dst_x1
+ par
->fb_x
) * cpp
);
244 memcpy(dst_ptr
, src_ptr
, w
*cpp
);
245 dst_ptr
+= par
->set_fb
->pitches
[0];
246 src_ptr
+= info
->fix
.line_length
;
256 ttm_bo_unreserve(&vbo
->base
);
257 ttm_read_unlock(&vmw_priv
->reservation_sem
);
259 WARN_ON_ONCE(par
->set_fb
->funcs
->dirty(cur_fb
, NULL
, 0, 0,
261 vmw_fifo_flush(vmw_priv
, false);
264 mutex_unlock(&par
->bo_mutex
);
267 static void vmw_fb_dirty_mark(struct vmw_fb_par
*par
,
268 unsigned x1
, unsigned y1
,
269 unsigned width
, unsigned height
)
272 unsigned x2
= x1
+ width
;
273 unsigned y2
= y1
+ height
;
275 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
276 if (par
->dirty
.x1
== par
->dirty
.x2
) {
281 /* if we are active start the dirty work
282 * we share the work with the defio system */
283 if (par
->dirty
.active
)
284 schedule_delayed_work(&par
->local_work
,
287 if (x1
< par
->dirty
.x1
)
289 if (y1
< par
->dirty
.y1
)
291 if (x2
> par
->dirty
.x2
)
293 if (y2
> par
->dirty
.y2
)
296 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
299 static int vmw_fb_pan_display(struct fb_var_screeninfo
*var
,
300 struct fb_info
*info
)
302 struct vmw_fb_par
*par
= info
->par
;
304 if ((var
->xoffset
+ var
->xres
) > var
->xres_virtual
||
305 (var
->yoffset
+ var
->yres
) > var
->yres_virtual
) {
306 DRM_ERROR("Requested panning can not fit in framebuffer\n");
310 mutex_lock(&par
->bo_mutex
);
311 par
->fb_x
= var
->xoffset
;
312 par
->fb_y
= var
->yoffset
;
314 vmw_fb_dirty_mark(par
, par
->fb_x
, par
->fb_y
, par
->set_fb
->width
,
315 par
->set_fb
->height
);
316 mutex_unlock(&par
->bo_mutex
);
321 static void vmw_deferred_io(struct fb_info
*info
,
322 struct list_head
*pagelist
)
324 struct vmw_fb_par
*par
= info
->par
;
325 unsigned long start
, end
, min
, max
;
332 list_for_each_entry(page
, pagelist
, lru
) {
333 start
= page
->index
<< PAGE_SHIFT
;
334 end
= start
+ PAGE_SIZE
- 1;
335 min
= min(min
, start
);
340 y1
= min
/ info
->fix
.line_length
;
341 y2
= (max
/ info
->fix
.line_length
) + 1;
343 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
346 par
->dirty
.x2
= info
->var
.xres
;
348 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
351 * Since we've already waited on this work once, try to
354 cancel_delayed_work(&par
->local_work
);
355 schedule_delayed_work(&par
->local_work
, 0);
359 static struct fb_deferred_io vmw_defio
= {
360 .delay
= VMW_DIRTY_DELAY
,
361 .deferred_io
= vmw_deferred_io
,
368 static void vmw_fb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
370 cfb_fillrect(info
, rect
);
371 vmw_fb_dirty_mark(info
->par
, rect
->dx
, rect
->dy
,
372 rect
->width
, rect
->height
);
375 static void vmw_fb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*region
)
377 cfb_copyarea(info
, region
);
378 vmw_fb_dirty_mark(info
->par
, region
->dx
, region
->dy
,
379 region
->width
, region
->height
);
382 static void vmw_fb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
384 cfb_imageblit(info
, image
);
385 vmw_fb_dirty_mark(info
->par
, image
->dx
, image
->dy
,
386 image
->width
, image
->height
);
393 static int vmw_fb_create_bo(struct vmw_private
*vmw_priv
,
394 size_t size
, struct vmw_dma_buffer
**out
)
396 struct vmw_dma_buffer
*vmw_bo
;
399 (void) ttm_write_lock(&vmw_priv
->reservation_sem
, false);
401 vmw_bo
= kmalloc(sizeof(*vmw_bo
), GFP_KERNEL
);
407 ret
= vmw_dmabuf_init(vmw_priv
, vmw_bo
, size
,
410 &vmw_dmabuf_bo_free
);
411 if (unlikely(ret
!= 0))
412 goto err_unlock
; /* init frees the buffer on failure */
415 ttm_write_unlock(&vmw_priv
->reservation_sem
);
420 ttm_write_unlock(&vmw_priv
->reservation_sem
);
424 static int vmw_fb_compute_depth(struct fb_var_screeninfo
*var
,
427 switch (var
->bits_per_pixel
) {
429 *depth
= (var
->transp
.length
> 0) ? 32 : 24;
432 DRM_ERROR("Bad bpp %u.\n", var
->bits_per_pixel
);
439 static int vmwgfx_set_config_internal(struct drm_mode_set
*set
)
441 struct drm_crtc
*crtc
= set
->crtc
;
442 struct drm_framebuffer
*fb
;
443 struct drm_crtc
*tmp
;
444 struct drm_modeset_acquire_ctx
*ctx
;
445 struct drm_device
*dev
= set
->crtc
->dev
;
448 ctx
= dev
->mode_config
.acquire_ctx
;
452 * NOTE: ->set_config can also disable other crtcs (if we steal all
453 * connectors from it), hence we need to refcount the fbs across all
454 * crtcs. Atomic modeset will have saner semantics ...
456 drm_for_each_crtc(tmp
, dev
)
457 tmp
->primary
->old_fb
= tmp
->primary
->fb
;
461 ret
= crtc
->funcs
->set_config(set
, ctx
);
463 crtc
->primary
->crtc
= crtc
;
464 crtc
->primary
->fb
= fb
;
467 drm_for_each_crtc(tmp
, dev
) {
468 if (tmp
->primary
->fb
)
469 drm_framebuffer_get(tmp
->primary
->fb
);
470 if (tmp
->primary
->old_fb
)
471 drm_framebuffer_put(tmp
->primary
->old_fb
);
472 tmp
->primary
->old_fb
= NULL
;
475 if (ret
== -EDEADLK
) {
476 dev
->mode_config
.acquire_ctx
= NULL
;
479 drm_modeset_backoff(ctx
);
481 ret
= drm_modeset_lock_all_ctx(dev
, ctx
);
485 dev
->mode_config
.acquire_ctx
= ctx
;
493 static int vmw_fb_kms_detach(struct vmw_fb_par
*par
,
497 struct drm_framebuffer
*cur_fb
= par
->set_fb
;
500 /* Detach the KMS framebuffer from crtcs */
502 struct drm_mode_set set
;
504 set
.crtc
= par
->crtc
;
509 set
.num_connectors
= 0;
510 set
.connectors
= &par
->con
;
511 ret
= vmwgfx_set_config_internal(&set
);
513 DRM_ERROR("Could not unset a mode.\n");
516 drm_mode_destroy(par
->vmw_priv
->dev
, par
->set_mode
);
517 par
->set_mode
= NULL
;
521 drm_framebuffer_put(cur_fb
);
525 if (par
->vmw_bo
&& detach_bo
&& unref_bo
)
526 vmw_dmabuf_unreference(&par
->vmw_bo
);
531 static int vmw_fb_kms_framebuffer(struct fb_info
*info
)
533 struct drm_mode_fb_cmd2 mode_cmd
;
534 struct vmw_fb_par
*par
= info
->par
;
535 struct fb_var_screeninfo
*var
= &info
->var
;
536 struct drm_framebuffer
*cur_fb
;
537 struct vmw_framebuffer
*vfb
;
541 ret
= vmw_fb_compute_depth(var
, &depth
);
545 mode_cmd
.width
= var
->xres
;
546 mode_cmd
.height
= var
->yres
;
547 mode_cmd
.pitches
[0] = ((var
->bits_per_pixel
+ 7) / 8) * mode_cmd
.width
;
548 mode_cmd
.pixel_format
=
549 drm_mode_legacy_fb_format(var
->bits_per_pixel
, depth
);
551 cur_fb
= par
->set_fb
;
552 if (cur_fb
&& cur_fb
->width
== mode_cmd
.width
&&
553 cur_fb
->height
== mode_cmd
.height
&&
554 cur_fb
->format
->format
== mode_cmd
.pixel_format
&&
555 cur_fb
->pitches
[0] == mode_cmd
.pitches
[0])
558 /* Need new buffer object ? */
559 new_bo_size
= (size_t) mode_cmd
.pitches
[0] * (size_t) mode_cmd
.height
;
560 ret
= vmw_fb_kms_detach(par
,
561 par
->bo_size
< new_bo_size
||
562 par
->bo_size
> 2*new_bo_size
,
568 ret
= vmw_fb_create_bo(par
->vmw_priv
, new_bo_size
,
571 DRM_ERROR("Failed creating a buffer object for "
575 par
->bo_size
= new_bo_size
;
578 vfb
= vmw_kms_new_framebuffer(par
->vmw_priv
, par
->vmw_bo
, NULL
,
583 par
->set_fb
= &vfb
->base
;
588 static int vmw_fb_set_par(struct fb_info
*info
)
590 struct vmw_fb_par
*par
= info
->par
;
591 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
592 struct drm_mode_set set
;
593 struct fb_var_screeninfo
*var
= &info
->var
;
594 struct drm_display_mode new_mode
= { DRM_MODE("fb_mode",
595 DRM_MODE_TYPE_DRIVER
,
596 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
597 DRM_MODE_FLAG_NHSYNC
| DRM_MODE_FLAG_PVSYNC
)
599 struct drm_display_mode
*old_mode
;
600 struct drm_display_mode
*mode
;
603 old_mode
= par
->set_mode
;
604 mode
= drm_mode_duplicate(vmw_priv
->dev
, &new_mode
);
606 DRM_ERROR("Could not create new fb mode.\n");
610 mode
->hdisplay
= var
->xres
;
611 mode
->vdisplay
= var
->yres
;
612 vmw_guess_mode_timing(mode
);
614 if (old_mode
&& drm_mode_equal(old_mode
, mode
)) {
615 drm_mode_destroy(vmw_priv
->dev
, mode
);
618 } else if (!vmw_kms_validate_mode_vram(vmw_priv
,
620 DIV_ROUND_UP(var
->bits_per_pixel
, 8),
622 drm_mode_destroy(vmw_priv
->dev
, mode
);
626 mutex_lock(&par
->bo_mutex
);
627 drm_modeset_lock_all(vmw_priv
->dev
);
628 ret
= vmw_fb_kms_framebuffer(info
);
632 par
->fb_x
= var
->xoffset
;
633 par
->fb_y
= var
->yoffset
;
635 set
.crtc
= par
->crtc
;
639 set
.fb
= par
->set_fb
;
640 set
.num_connectors
= 1;
641 set
.connectors
= &par
->con
;
643 ret
= vmwgfx_set_config_internal(&set
);
647 vmw_fb_dirty_mark(par
, par
->fb_x
, par
->fb_y
,
648 par
->set_fb
->width
, par
->set_fb
->height
);
650 /* If there already was stuff dirty we wont
651 * schedule a new work, so lets do it now */
653 schedule_delayed_work(&par
->local_work
, 0);
657 drm_mode_destroy(vmw_priv
->dev
, old_mode
);
658 par
->set_mode
= mode
;
660 drm_modeset_unlock_all(vmw_priv
->dev
);
661 mutex_unlock(&par
->bo_mutex
);
667 static struct fb_ops vmw_fb_ops
= {
668 .owner
= THIS_MODULE
,
669 .fb_check_var
= vmw_fb_check_var
,
670 .fb_set_par
= vmw_fb_set_par
,
671 .fb_setcolreg
= vmw_fb_setcolreg
,
672 .fb_fillrect
= vmw_fb_fillrect
,
673 .fb_copyarea
= vmw_fb_copyarea
,
674 .fb_imageblit
= vmw_fb_imageblit
,
675 .fb_pan_display
= vmw_fb_pan_display
,
676 .fb_blank
= vmw_fb_blank
,
679 int vmw_fb_init(struct vmw_private
*vmw_priv
)
681 struct device
*device
= &vmw_priv
->dev
->pdev
->dev
;
682 struct vmw_fb_par
*par
;
683 struct fb_info
*info
;
684 unsigned fb_width
, fb_height
;
685 unsigned fb_bpp
, fb_depth
, fb_offset
, fb_pitch
, fb_size
;
686 struct drm_display_mode
*init_mode
;
692 /* XXX As shouldn't these be as well. */
693 fb_width
= min(vmw_priv
->fb_max_width
, (unsigned)2048);
694 fb_height
= min(vmw_priv
->fb_max_height
, (unsigned)2048);
696 fb_pitch
= fb_width
* fb_bpp
/ 8;
697 fb_size
= fb_pitch
* fb_height
;
698 fb_offset
= vmw_read(vmw_priv
, SVGA_REG_FB_OFFSET
);
700 info
= framebuffer_alloc(sizeof(*par
), device
);
707 vmw_priv
->fb_info
= info
;
709 memset(par
, 0, sizeof(*par
));
710 INIT_DELAYED_WORK(&par
->local_work
, &vmw_fb_dirty_flush
);
711 par
->vmw_priv
= vmw_priv
;
713 par
->max_width
= fb_width
;
714 par
->max_height
= fb_height
;
716 drm_modeset_lock_all(vmw_priv
->dev
);
717 ret
= vmw_kms_fbdev_init_data(vmw_priv
, 0, par
->max_width
,
718 par
->max_height
, &par
->con
,
719 &par
->crtc
, &init_mode
);
721 drm_modeset_unlock_all(vmw_priv
->dev
);
725 info
->var
.xres
= init_mode
->hdisplay
;
726 info
->var
.yres
= init_mode
->vdisplay
;
727 drm_modeset_unlock_all(vmw_priv
->dev
);
730 * Create buffers and alloc memory
732 par
->vmalloc
= vzalloc(fb_size
);
733 if (unlikely(par
->vmalloc
== NULL
)) {
741 strcpy(info
->fix
.id
, "svgadrmfb");
742 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
743 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
744 info
->fix
.type_aux
= 0;
745 info
->fix
.xpanstep
= 1; /* doing it in hw */
746 info
->fix
.ypanstep
= 1; /* doing it in hw */
747 info
->fix
.ywrapstep
= 0;
748 info
->fix
.accel
= FB_ACCEL_NONE
;
749 info
->fix
.line_length
= fb_pitch
;
751 info
->fix
.smem_start
= 0;
752 info
->fix
.smem_len
= fb_size
;
754 info
->pseudo_palette
= par
->pseudo_palette
;
755 info
->screen_base
= (char __iomem
*)par
->vmalloc
;
756 info
->screen_size
= fb_size
;
758 info
->fbops
= &vmw_fb_ops
;
760 /* 24 depth per default */
761 info
->var
.red
.offset
= 16;
762 info
->var
.green
.offset
= 8;
763 info
->var
.blue
.offset
= 0;
764 info
->var
.red
.length
= 8;
765 info
->var
.green
.length
= 8;
766 info
->var
.blue
.length
= 8;
767 info
->var
.transp
.offset
= 0;
768 info
->var
.transp
.length
= 0;
770 info
->var
.xres_virtual
= fb_width
;
771 info
->var
.yres_virtual
= fb_height
;
772 info
->var
.bits_per_pixel
= fb_bpp
;
773 info
->var
.xoffset
= 0;
774 info
->var
.yoffset
= 0;
775 info
->var
.activate
= FB_ACTIVATE_NOW
;
776 info
->var
.height
= -1;
777 info
->var
.width
= -1;
779 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
780 info
->apertures
= alloc_apertures(1);
781 if (!info
->apertures
) {
785 info
->apertures
->ranges
[0].base
= vmw_priv
->vram_start
;
786 info
->apertures
->ranges
[0].size
= vmw_priv
->vram_size
;
789 * Dirty & Deferred IO
791 par
->dirty
.x1
= par
->dirty
.x2
= 0;
792 par
->dirty
.y1
= par
->dirty
.y2
= 0;
793 par
->dirty
.active
= true;
794 spin_lock_init(&par
->dirty
.lock
);
795 mutex_init(&par
->bo_mutex
);
796 info
->fbdefio
= &vmw_defio
;
797 fb_deferred_io_init(info
);
799 ret
= register_framebuffer(info
);
800 if (unlikely(ret
!= 0))
803 vmw_fb_set_par(info
);
808 fb_deferred_io_cleanup(info
);
813 framebuffer_release(info
);
814 vmw_priv
->fb_info
= NULL
;
819 int vmw_fb_close(struct vmw_private
*vmw_priv
)
821 struct fb_info
*info
;
822 struct vmw_fb_par
*par
;
824 if (!vmw_priv
->fb_info
)
827 info
= vmw_priv
->fb_info
;
831 fb_deferred_io_cleanup(info
);
832 cancel_delayed_work_sync(&par
->local_work
);
833 unregister_framebuffer(info
);
835 (void) vmw_fb_kms_detach(par
, true, true);
838 framebuffer_release(info
);
843 int vmw_fb_off(struct vmw_private
*vmw_priv
)
845 struct fb_info
*info
;
846 struct vmw_fb_par
*par
;
849 if (!vmw_priv
->fb_info
)
852 info
= vmw_priv
->fb_info
;
855 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
856 par
->dirty
.active
= false;
857 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
859 flush_delayed_work(&info
->deferred_work
);
860 flush_delayed_work(&par
->local_work
);
865 int vmw_fb_on(struct vmw_private
*vmw_priv
)
867 struct fb_info
*info
;
868 struct vmw_fb_par
*par
;
871 if (!vmw_priv
->fb_info
)
874 info
= vmw_priv
->fb_info
;
877 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
878 par
->dirty
.active
= true;
879 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
885 * vmw_fb_refresh - Refresh fb display
887 * @vmw_priv: Pointer to device private
889 * Call into kms to show the fbdev display(s).
891 void vmw_fb_refresh(struct vmw_private
*vmw_priv
)
893 if (!vmw_priv
->fb_info
)
896 vmw_fb_set_par(vmw_priv
->fb_info
);