1 /**************************************************************************
3 * Copyright © 2007 David Airlie
4 * Copyright © 2009 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 **************************************************************************/
30 #include "vmwgfx_drv.h"
32 #include "ttm/ttm_placement.h"
34 #define VMW_DIRTY_DELAY (HZ / 30)
37 struct vmw_private
*vmw_priv
;
41 struct vmw_dma_buffer
*vmw_bo
;
42 struct ttm_bo_kmap_obj map
;
44 u32 pseudo_palette
[17];
66 static int vmw_fb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
67 unsigned blue
, unsigned transp
,
70 struct vmw_fb_par
*par
= info
->par
;
71 u32
*pal
= par
->pseudo_palette
;
74 DRM_ERROR("Bad regno %u.\n", regno
);
81 pal
[regno
] = ((red
& 0xff00) << 8) |
83 ((blue
& 0xff00) >> 8);
86 DRM_ERROR("Bad depth %u, bpp %u.\n", par
->depth
, par
->bpp
);
93 static int vmw_fb_check_var(struct fb_var_screeninfo
*var
,
96 int depth
= var
->bits_per_pixel
;
97 struct vmw_fb_par
*par
= info
->par
;
98 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
100 switch (var
->bits_per_pixel
) {
102 depth
= (var
->transp
.length
> 0) ? 32 : 24;
105 DRM_ERROR("Bad bpp %u.\n", var
->bits_per_pixel
);
111 var
->red
.offset
= 16;
112 var
->green
.offset
= 8;
113 var
->blue
.offset
= 0;
115 var
->green
.length
= 8;
116 var
->blue
.length
= 8;
117 var
->transp
.length
= 0;
118 var
->transp
.offset
= 0;
121 var
->red
.offset
= 16;
122 var
->green
.offset
= 8;
123 var
->blue
.offset
= 0;
125 var
->green
.length
= 8;
126 var
->blue
.length
= 8;
127 var
->transp
.length
= 8;
128 var
->transp
.offset
= 24;
131 DRM_ERROR("Bad depth %u.\n", depth
);
135 if (!(vmw_priv
->capabilities
& SVGA_CAP_DISPLAY_TOPOLOGY
) &&
136 (var
->xoffset
!= 0 || var
->yoffset
!= 0)) {
137 DRM_ERROR("Can not handle panning without display topology\n");
141 if ((var
->xoffset
+ var
->xres
) > par
->max_width
||
142 (var
->yoffset
+ var
->yres
) > par
->max_height
) {
143 DRM_ERROR("Requested geom can not fit in framebuffer\n");
147 if (!vmw_kms_validate_mode_vram(vmw_priv
,
148 info
->fix
.line_length
,
149 var
->yoffset
+ var
->yres
)) {
150 DRM_ERROR("Requested geom can not fit in framebuffer\n");
157 static int vmw_fb_set_par(struct fb_info
*info
)
159 struct vmw_fb_par
*par
= info
->par
;
160 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
163 ret
= vmw_kms_write_svga(vmw_priv
, info
->var
.xres
, info
->var
.yres
,
164 info
->fix
.line_length
,
165 par
->bpp
, par
->depth
);
169 if (vmw_priv
->capabilities
& SVGA_CAP_DISPLAY_TOPOLOGY
) {
170 /* TODO check if pitch and offset changes */
171 vmw_write(vmw_priv
, SVGA_REG_NUM_GUEST_DISPLAYS
, 1);
172 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_ID
, 0);
173 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_IS_PRIMARY
, true);
174 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_POSITION_X
, info
->var
.xoffset
);
175 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_POSITION_Y
, info
->var
.yoffset
);
176 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_WIDTH
, info
->var
.xres
);
177 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_HEIGHT
, info
->var
.yres
);
178 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_ID
, SVGA_ID_INVALID
);
181 /* This is really helpful since if this fails the user
182 * can probably not see anything on the screen.
184 WARN_ON(vmw_read(vmw_priv
, SVGA_REG_FB_OFFSET
) != 0);
189 static int vmw_fb_pan_display(struct fb_var_screeninfo
*var
,
190 struct fb_info
*info
)
195 static int vmw_fb_blank(int blank
, struct fb_info
*info
)
204 static void vmw_fb_dirty_flush(struct vmw_fb_par
*par
)
206 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
207 struct fb_info
*info
= vmw_priv
->fb_info
;
208 int stride
= (info
->fix
.line_length
/ 4);
209 int *src
= (int *)info
->screen_base
;
210 __le32 __iomem
*vram_mem
= par
->bo_ptr
;
216 SVGAFifoCmdUpdate body
;
219 if (vmw_priv
->suspended
)
222 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
223 if (!par
->dirty
.active
) {
224 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
229 w
= min(par
->dirty
.x2
, info
->var
.xres
) - x
;
230 h
= min(par
->dirty
.y2
, info
->var
.yres
) - y
;
231 par
->dirty
.x1
= par
->dirty
.x2
= 0;
232 par
->dirty
.y1
= par
->dirty
.y2
= 0;
233 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
235 for (i
= y
* stride
; i
< info
->fix
.smem_len
/ 4; i
+= stride
) {
236 for (k
= i
+x
; k
< i
+x
+w
&& k
< info
->fix
.smem_len
/ 4; k
++)
237 iowrite32(src
[k
], vram_mem
+ k
);
241 DRM_INFO("%s, (%u, %u) (%ux%u)\n", __func__
, x
, y
, w
, h
);
244 cmd
= vmw_fifo_reserve(vmw_priv
, sizeof(*cmd
));
245 if (unlikely(cmd
== NULL
)) {
246 DRM_ERROR("Fifo reserve failed.\n");
250 cmd
->header
= cpu_to_le32(SVGA_CMD_UPDATE
);
251 cmd
->body
.x
= cpu_to_le32(x
);
252 cmd
->body
.y
= cpu_to_le32(y
);
253 cmd
->body
.width
= cpu_to_le32(w
);
254 cmd
->body
.height
= cpu_to_le32(h
);
255 vmw_fifo_commit(vmw_priv
, sizeof(*cmd
));
258 static void vmw_fb_dirty_mark(struct vmw_fb_par
*par
,
259 unsigned x1
, unsigned y1
,
260 unsigned width
, unsigned height
)
262 struct fb_info
*info
= par
->vmw_priv
->fb_info
;
264 unsigned x2
= x1
+ width
;
265 unsigned y2
= y1
+ height
;
267 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
268 if (par
->dirty
.x1
== par
->dirty
.x2
) {
273 /* if we are active start the dirty work
274 * we share the work with the defio system */
275 if (par
->dirty
.active
)
276 schedule_delayed_work(&info
->deferred_work
, VMW_DIRTY_DELAY
);
278 if (x1
< par
->dirty
.x1
)
280 if (y1
< par
->dirty
.y1
)
282 if (x2
> par
->dirty
.x2
)
284 if (y2
> par
->dirty
.y2
)
287 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
290 static void vmw_deferred_io(struct fb_info
*info
,
291 struct list_head
*pagelist
)
293 struct vmw_fb_par
*par
= info
->par
;
294 unsigned long start
, end
, min
, max
;
301 list_for_each_entry(page
, pagelist
, lru
) {
302 start
= page
->index
<< PAGE_SHIFT
;
303 end
= start
+ PAGE_SIZE
- 1;
304 min
= min(min
, start
);
309 y1
= min
/ info
->fix
.line_length
;
310 y2
= (max
/ info
->fix
.line_length
) + 1;
312 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
315 par
->dirty
.x2
= info
->var
.xres
;
317 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
320 vmw_fb_dirty_flush(par
);
323 struct fb_deferred_io vmw_defio
= {
324 .delay
= VMW_DIRTY_DELAY
,
325 .deferred_io
= vmw_deferred_io
,
332 static void vmw_fb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
334 cfb_fillrect(info
, rect
);
335 vmw_fb_dirty_mark(info
->par
, rect
->dx
, rect
->dy
,
336 rect
->width
, rect
->height
);
339 static void vmw_fb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*region
)
341 cfb_copyarea(info
, region
);
342 vmw_fb_dirty_mark(info
->par
, region
->dx
, region
->dy
,
343 region
->width
, region
->height
);
346 static void vmw_fb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
348 cfb_imageblit(info
, image
);
349 vmw_fb_dirty_mark(info
->par
, image
->dx
, image
->dy
,
350 image
->width
, image
->height
);
357 static struct fb_ops vmw_fb_ops
= {
358 .owner
= THIS_MODULE
,
359 .fb_check_var
= vmw_fb_check_var
,
360 .fb_set_par
= vmw_fb_set_par
,
361 .fb_setcolreg
= vmw_fb_setcolreg
,
362 .fb_fillrect
= vmw_fb_fillrect
,
363 .fb_copyarea
= vmw_fb_copyarea
,
364 .fb_imageblit
= vmw_fb_imageblit
,
365 .fb_pan_display
= vmw_fb_pan_display
,
366 .fb_blank
= vmw_fb_blank
,
369 static int vmw_fb_create_bo(struct vmw_private
*vmw_priv
,
370 size_t size
, struct vmw_dma_buffer
**out
)
372 struct vmw_dma_buffer
*vmw_bo
;
373 struct ttm_placement ne_placement
= vmw_vram_ne_placement
;
376 ne_placement
.lpfn
= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
379 ret
= ttm_write_lock(&vmw_priv
->fbdev_master
.lock
, false);
380 if (unlikely(ret
!= 0))
383 vmw_bo
= kmalloc(sizeof(*vmw_bo
), GFP_KERNEL
);
387 ret
= vmw_dmabuf_init(vmw_priv
, vmw_bo
, size
,
390 &vmw_dmabuf_bo_free
);
391 if (unlikely(ret
!= 0))
392 goto err_unlock
; /* init frees the buffer on failure */
396 ttm_write_unlock(&vmw_priv
->fbdev_master
.lock
);
401 ttm_write_unlock(&vmw_priv
->fbdev_master
.lock
);
405 int vmw_fb_init(struct vmw_private
*vmw_priv
)
407 struct device
*device
= &vmw_priv
->dev
->pdev
->dev
;
408 struct vmw_fb_par
*par
;
409 struct fb_info
*info
;
410 unsigned initial_width
, initial_height
;
411 unsigned fb_width
, fb_height
;
412 unsigned fb_bpp
, fb_depth
, fb_offset
, fb_pitch
, fb_size
;
415 /* XXX These shouldn't be hardcoded. */
417 initial_height
= 600;
422 /* XXX As shouldn't these be as well. */
423 fb_width
= min(vmw_priv
->fb_max_width
, (unsigned)2048);
424 fb_height
= min(vmw_priv
->fb_max_height
, (unsigned)2048);
426 initial_width
= min(fb_width
, initial_width
);
427 initial_height
= min(fb_height
, initial_height
);
429 fb_pitch
= fb_width
* fb_bpp
/ 8;
430 fb_size
= fb_pitch
* fb_height
;
431 fb_offset
= vmw_read(vmw_priv
, SVGA_REG_FB_OFFSET
);
433 info
= framebuffer_alloc(sizeof(*par
), device
);
440 vmw_priv
->fb_info
= info
;
442 par
->vmw_priv
= vmw_priv
;
443 par
->depth
= fb_depth
;
446 par
->max_width
= fb_width
;
447 par
->max_height
= fb_height
;
450 * Create buffers and alloc memory
452 par
->vmalloc
= vmalloc(fb_size
);
453 if (unlikely(par
->vmalloc
== NULL
)) {
458 ret
= vmw_fb_create_bo(vmw_priv
, fb_size
, &par
->vmw_bo
);
459 if (unlikely(ret
!= 0))
462 ret
= ttm_bo_kmap(&par
->vmw_bo
->base
,
464 par
->vmw_bo
->base
.num_pages
,
466 if (unlikely(ret
!= 0))
468 par
->bo_ptr
= ttm_kmap_obj_virtual(&par
->map
, &par
->bo_iowrite
);
469 par
->bo_size
= fb_size
;
474 strcpy(info
->fix
.id
, "svgadrmfb");
475 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
476 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
477 info
->fix
.type_aux
= 0;
478 info
->fix
.xpanstep
= 1; /* doing it in hw */
479 info
->fix
.ypanstep
= 1; /* doing it in hw */
480 info
->fix
.ywrapstep
= 0;
481 info
->fix
.accel
= FB_ACCEL_NONE
;
482 info
->fix
.line_length
= fb_pitch
;
484 info
->fix
.smem_start
= 0;
485 info
->fix
.smem_len
= fb_size
;
487 info
->pseudo_palette
= par
->pseudo_palette
;
488 info
->screen_base
= par
->vmalloc
;
489 info
->screen_size
= fb_size
;
491 info
->flags
= FBINFO_DEFAULT
;
492 info
->fbops
= &vmw_fb_ops
;
494 /* 24 depth per default */
495 info
->var
.red
.offset
= 16;
496 info
->var
.green
.offset
= 8;
497 info
->var
.blue
.offset
= 0;
498 info
->var
.red
.length
= 8;
499 info
->var
.green
.length
= 8;
500 info
->var
.blue
.length
= 8;
501 info
->var
.transp
.offset
= 0;
502 info
->var
.transp
.length
= 0;
504 info
->var
.xres_virtual
= fb_width
;
505 info
->var
.yres_virtual
= fb_height
;
506 info
->var
.bits_per_pixel
= par
->bpp
;
507 info
->var
.xoffset
= 0;
508 info
->var
.yoffset
= 0;
509 info
->var
.activate
= FB_ACTIVATE_NOW
;
510 info
->var
.height
= -1;
511 info
->var
.width
= -1;
513 info
->var
.xres
= initial_width
;
514 info
->var
.yres
= initial_height
;
517 info
->pixmap
.size
= 64*1024;
518 info
->pixmap
.buf_align
= 8;
519 info
->pixmap
.access_align
= 32;
520 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
521 info
->pixmap
.scan_align
= 1;
523 info
->pixmap
.size
= 0;
524 info
->pixmap
.buf_align
= 8;
525 info
->pixmap
.access_align
= 32;
526 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
527 info
->pixmap
.scan_align
= 1;
530 info
->apertures
= alloc_apertures(1);
531 if (!info
->apertures
) {
535 info
->apertures
->ranges
[0].base
= vmw_priv
->vram_start
;
536 info
->apertures
->ranges
[0].size
= vmw_priv
->vram_size
;
539 * Dirty & Deferred IO
541 par
->dirty
.x1
= par
->dirty
.x2
= 0;
542 par
->dirty
.y1
= par
->dirty
.y2
= 0;
543 par
->dirty
.active
= true;
544 spin_lock_init(&par
->dirty
.lock
);
545 info
->fbdefio
= &vmw_defio
;
546 fb_deferred_io_init(info
);
548 ret
= register_framebuffer(info
);
549 if (unlikely(ret
!= 0))
555 fb_deferred_io_cleanup(info
);
557 ttm_bo_kunmap(&par
->map
);
559 ttm_bo_unref((struct ttm_buffer_object
**)&par
->vmw_bo
);
562 framebuffer_release(info
);
563 vmw_priv
->fb_info
= NULL
;
568 int vmw_fb_close(struct vmw_private
*vmw_priv
)
570 struct fb_info
*info
;
571 struct vmw_fb_par
*par
;
572 struct ttm_buffer_object
*bo
;
574 if (!vmw_priv
->fb_info
)
577 info
= vmw_priv
->fb_info
;
579 bo
= &par
->vmw_bo
->base
;
583 fb_deferred_io_cleanup(info
);
584 unregister_framebuffer(info
);
586 ttm_bo_kunmap(&par
->map
);
590 framebuffer_release(info
);
595 int vmw_fb_off(struct vmw_private
*vmw_priv
)
597 struct fb_info
*info
;
598 struct vmw_fb_par
*par
;
601 if (!vmw_priv
->fb_info
)
604 info
= vmw_priv
->fb_info
;
607 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
608 par
->dirty
.active
= false;
609 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
611 flush_delayed_work_sync(&info
->deferred_work
);
614 ttm_bo_kunmap(&par
->map
);
616 vmw_dmabuf_unpin(vmw_priv
, par
->vmw_bo
, false);
621 int vmw_fb_on(struct vmw_private
*vmw_priv
)
623 struct fb_info
*info
;
624 struct vmw_fb_par
*par
;
629 if (!vmw_priv
->fb_info
)
632 info
= vmw_priv
->fb_info
;
635 /* we are already active */
636 if (par
->bo_ptr
!= NULL
)
639 /* Make sure that all overlays are stoped when we take over */
640 vmw_overlay_stop_all(vmw_priv
);
642 ret
= vmw_dmabuf_to_start_of_vram(vmw_priv
, par
->vmw_bo
, true, false);
643 if (unlikely(ret
!= 0)) {
644 DRM_ERROR("could not move buffer to start of VRAM\n");
648 ret
= ttm_bo_kmap(&par
->vmw_bo
->base
,
650 par
->vmw_bo
->base
.num_pages
,
653 par
->bo_ptr
= ttm_kmap_obj_virtual(&par
->map
, &dummy
);
655 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
656 par
->dirty
.active
= true;
657 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
660 vmw_fb_set_par(info
);
662 vmw_fb_dirty_mark(par
, 0, 0, info
->var
.xres
, info
->var
.yres
);
664 /* If there already was stuff dirty we wont
665 * schedule a new work, so lets do it now */
666 schedule_delayed_work(&info
->deferred_work
, 0);