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");
150 static int vmw_fb_set_par(struct fb_info
*info
)
152 struct vmw_fb_par
*par
= info
->par
;
153 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
155 vmw_kms_write_svga(vmw_priv
, info
->var
.xres
, info
->var
.yres
,
156 info
->fix
.line_length
,
157 par
->bpp
, par
->depth
);
158 if (vmw_priv
->capabilities
& SVGA_CAP_DISPLAY_TOPOLOGY
) {
159 /* TODO check if pitch and offset changes */
160 vmw_write(vmw_priv
, SVGA_REG_NUM_GUEST_DISPLAYS
, 1);
161 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_ID
, 0);
162 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_IS_PRIMARY
, true);
163 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_POSITION_X
, info
->var
.xoffset
);
164 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_POSITION_Y
, info
->var
.yoffset
);
165 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_WIDTH
, info
->var
.xres
);
166 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_HEIGHT
, info
->var
.yres
);
167 vmw_write(vmw_priv
, SVGA_REG_DISPLAY_ID
, SVGA_ID_INVALID
);
170 /* This is really helpful since if this fails the user
171 * can probably not see anything on the screen.
173 WARN_ON(vmw_read(vmw_priv
, SVGA_REG_FB_OFFSET
) != 0);
178 static int vmw_fb_pan_display(struct fb_var_screeninfo
*var
,
179 struct fb_info
*info
)
184 static int vmw_fb_blank(int blank
, struct fb_info
*info
)
193 static void vmw_fb_dirty_flush(struct vmw_fb_par
*par
)
195 struct vmw_private
*vmw_priv
= par
->vmw_priv
;
196 struct fb_info
*info
= vmw_priv
->fb_info
;
197 int stride
= (info
->fix
.line_length
/ 4);
198 int *src
= (int *)info
->screen_base
;
199 __le32 __iomem
*vram_mem
= par
->bo_ptr
;
205 SVGAFifoCmdUpdate body
;
208 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
209 if (!par
->dirty
.active
) {
210 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
215 w
= min(par
->dirty
.x2
, info
->var
.xres
) - x
;
216 h
= min(par
->dirty
.y2
, info
->var
.yres
) - y
;
217 par
->dirty
.x1
= par
->dirty
.x2
= 0;
218 par
->dirty
.y1
= par
->dirty
.y2
= 0;
219 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
221 for (i
= y
* stride
; i
< info
->fix
.smem_len
/ 4; i
+= stride
) {
222 for (k
= i
+x
; k
< i
+x
+w
&& k
< info
->fix
.smem_len
/ 4; k
++)
223 iowrite32(src
[k
], vram_mem
+ k
);
227 DRM_INFO("%s, (%u, %u) (%ux%u)\n", __func__
, x
, y
, w
, h
);
230 cmd
= vmw_fifo_reserve(vmw_priv
, sizeof(*cmd
));
231 if (unlikely(cmd
== NULL
)) {
232 DRM_ERROR("Fifo reserve failed.\n");
236 cmd
->header
= cpu_to_le32(SVGA_CMD_UPDATE
);
237 cmd
->body
.x
= cpu_to_le32(x
);
238 cmd
->body
.y
= cpu_to_le32(y
);
239 cmd
->body
.width
= cpu_to_le32(w
);
240 cmd
->body
.height
= cpu_to_le32(h
);
241 vmw_fifo_commit(vmw_priv
, sizeof(*cmd
));
244 static void vmw_fb_dirty_mark(struct vmw_fb_par
*par
,
245 unsigned x1
, unsigned y1
,
246 unsigned width
, unsigned height
)
248 struct fb_info
*info
= par
->vmw_priv
->fb_info
;
250 unsigned x2
= x1
+ width
;
251 unsigned y2
= y1
+ height
;
253 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
254 if (par
->dirty
.x1
== par
->dirty
.x2
) {
259 /* if we are active start the dirty work
260 * we share the work with the defio system */
261 if (par
->dirty
.active
)
262 schedule_delayed_work(&info
->deferred_work
, VMW_DIRTY_DELAY
);
264 if (x1
< par
->dirty
.x1
)
266 if (y1
< par
->dirty
.y1
)
268 if (x2
> par
->dirty
.x2
)
270 if (y2
> par
->dirty
.y2
)
273 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
276 static void vmw_deferred_io(struct fb_info
*info
,
277 struct list_head
*pagelist
)
279 struct vmw_fb_par
*par
= info
->par
;
280 unsigned long start
, end
, min
, max
;
287 list_for_each_entry(page
, pagelist
, lru
) {
288 start
= page
->index
<< PAGE_SHIFT
;
289 end
= start
+ PAGE_SIZE
- 1;
290 min
= min(min
, start
);
295 y1
= min
/ info
->fix
.line_length
;
296 y2
= (max
/ info
->fix
.line_length
) + 1;
298 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
301 par
->dirty
.x2
= info
->var
.xres
;
303 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
306 vmw_fb_dirty_flush(par
);
309 struct fb_deferred_io vmw_defio
= {
310 .delay
= VMW_DIRTY_DELAY
,
311 .deferred_io
= vmw_deferred_io
,
318 static void vmw_fb_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
320 cfb_fillrect(info
, rect
);
321 vmw_fb_dirty_mark(info
->par
, rect
->dx
, rect
->dy
,
322 rect
->width
, rect
->height
);
325 static void vmw_fb_copyarea(struct fb_info
*info
, const struct fb_copyarea
*region
)
327 cfb_copyarea(info
, region
);
328 vmw_fb_dirty_mark(info
->par
, region
->dx
, region
->dy
,
329 region
->width
, region
->height
);
332 static void vmw_fb_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
334 cfb_imageblit(info
, image
);
335 vmw_fb_dirty_mark(info
->par
, image
->dx
, image
->dy
,
336 image
->width
, image
->height
);
343 static struct fb_ops vmw_fb_ops
= {
344 .owner
= THIS_MODULE
,
345 .fb_check_var
= vmw_fb_check_var
,
346 .fb_set_par
= vmw_fb_set_par
,
347 .fb_setcolreg
= vmw_fb_setcolreg
,
348 .fb_fillrect
= vmw_fb_fillrect
,
349 .fb_copyarea
= vmw_fb_copyarea
,
350 .fb_imageblit
= vmw_fb_imageblit
,
351 .fb_pan_display
= vmw_fb_pan_display
,
352 .fb_blank
= vmw_fb_blank
,
355 static int vmw_fb_create_bo(struct vmw_private
*vmw_priv
,
356 size_t size
, struct vmw_dma_buffer
**out
)
358 struct vmw_dma_buffer
*vmw_bo
;
359 struct ttm_placement ne_placement
= vmw_vram_ne_placement
;
362 ne_placement
.lpfn
= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
365 ret
= ttm_write_lock(&vmw_priv
->fbdev_master
.lock
, false);
366 if (unlikely(ret
!= 0))
369 vmw_bo
= kmalloc(sizeof(*vmw_bo
), GFP_KERNEL
);
373 ret
= vmw_dmabuf_init(vmw_priv
, vmw_bo
, size
,
376 &vmw_dmabuf_bo_free
);
377 if (unlikely(ret
!= 0))
378 goto err_unlock
; /* init frees the buffer on failure */
382 ttm_write_unlock(&vmw_priv
->fbdev_master
.lock
);
387 ttm_write_unlock(&vmw_priv
->fbdev_master
.lock
);
391 int vmw_fb_init(struct vmw_private
*vmw_priv
)
393 struct device
*device
= &vmw_priv
->dev
->pdev
->dev
;
394 struct vmw_fb_par
*par
;
395 struct fb_info
*info
;
396 unsigned initial_width
, initial_height
;
397 unsigned fb_width
, fb_height
;
398 unsigned fb_bbp
, fb_depth
, fb_offset
, fb_pitch
, fb_size
;
401 /* XXX These shouldn't be hardcoded. */
403 initial_height
= 600;
408 /* XXX As shouldn't these be as well. */
409 fb_width
= min(vmw_priv
->fb_max_width
, (unsigned)2048);
410 fb_height
= min(vmw_priv
->fb_max_height
, (unsigned)2048);
412 initial_width
= min(fb_width
, initial_width
);
413 initial_height
= min(fb_height
, initial_height
);
415 fb_pitch
= fb_width
* fb_bbp
/ 8;
416 fb_size
= fb_pitch
* fb_height
;
417 fb_offset
= vmw_read(vmw_priv
, SVGA_REG_FB_OFFSET
);
419 info
= framebuffer_alloc(sizeof(*par
), device
);
426 vmw_priv
->fb_info
= info
;
428 par
->vmw_priv
= vmw_priv
;
429 par
->depth
= fb_depth
;
432 par
->max_width
= fb_width
;
433 par
->max_height
= fb_height
;
436 * Create buffers and alloc memory
438 par
->vmalloc
= vmalloc(fb_size
);
439 if (unlikely(par
->vmalloc
== NULL
)) {
444 ret
= vmw_fb_create_bo(vmw_priv
, fb_size
, &par
->vmw_bo
);
445 if (unlikely(ret
!= 0))
448 ret
= ttm_bo_kmap(&par
->vmw_bo
->base
,
450 par
->vmw_bo
->base
.num_pages
,
452 if (unlikely(ret
!= 0))
454 par
->bo_ptr
= ttm_kmap_obj_virtual(&par
->map
, &par
->bo_iowrite
);
455 par
->bo_size
= fb_size
;
460 strcpy(info
->fix
.id
, "svgadrmfb");
461 info
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
462 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
463 info
->fix
.type_aux
= 0;
464 info
->fix
.xpanstep
= 1; /* doing it in hw */
465 info
->fix
.ypanstep
= 1; /* doing it in hw */
466 info
->fix
.ywrapstep
= 0;
467 info
->fix
.accel
= FB_ACCEL_NONE
;
468 info
->fix
.line_length
= fb_pitch
;
470 info
->fix
.smem_start
= 0;
471 info
->fix
.smem_len
= fb_size
;
473 info
->fix
.mmio_start
= 0;
474 info
->fix
.mmio_len
= 0;
476 info
->pseudo_palette
= par
->pseudo_palette
;
477 info
->screen_base
= par
->vmalloc
;
478 info
->screen_size
= fb_size
;
480 info
->flags
= FBINFO_DEFAULT
;
481 info
->fbops
= &vmw_fb_ops
;
483 /* 24 depth per default */
484 info
->var
.red
.offset
= 16;
485 info
->var
.green
.offset
= 8;
486 info
->var
.blue
.offset
= 0;
487 info
->var
.red
.length
= 8;
488 info
->var
.green
.length
= 8;
489 info
->var
.blue
.length
= 8;
490 info
->var
.transp
.offset
= 0;
491 info
->var
.transp
.length
= 0;
493 info
->var
.xres_virtual
= fb_width
;
494 info
->var
.yres_virtual
= fb_height
;
495 info
->var
.bits_per_pixel
= par
->bpp
;
496 info
->var
.xoffset
= 0;
497 info
->var
.yoffset
= 0;
498 info
->var
.activate
= FB_ACTIVATE_NOW
;
499 info
->var
.height
= -1;
500 info
->var
.width
= -1;
502 info
->var
.xres
= initial_width
;
503 info
->var
.yres
= initial_height
;
506 info
->pixmap
.size
= 64*1024;
507 info
->pixmap
.buf_align
= 8;
508 info
->pixmap
.access_align
= 32;
509 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
510 info
->pixmap
.scan_align
= 1;
512 info
->pixmap
.size
= 0;
513 info
->pixmap
.buf_align
= 8;
514 info
->pixmap
.access_align
= 32;
515 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
516 info
->pixmap
.scan_align
= 1;
519 info
->apertures
= alloc_apertures(1);
520 if (!info
->apertures
) {
524 info
->apertures
->ranges
[0].base
= vmw_priv
->vram_start
;
525 info
->apertures
->ranges
[0].size
= vmw_priv
->vram_size
;
528 * Dirty & Deferred IO
530 par
->dirty
.x1
= par
->dirty
.x2
= 0;
531 par
->dirty
.y1
= par
->dirty
.y2
= 0;
532 par
->dirty
.active
= true;
533 spin_lock_init(&par
->dirty
.lock
);
534 info
->fbdefio
= &vmw_defio
;
535 fb_deferred_io_init(info
);
537 ret
= register_framebuffer(info
);
538 if (unlikely(ret
!= 0))
544 fb_deferred_io_cleanup(info
);
546 ttm_bo_kunmap(&par
->map
);
548 ttm_bo_unref((struct ttm_buffer_object
**)&par
->vmw_bo
);
551 framebuffer_release(info
);
552 vmw_priv
->fb_info
= NULL
;
557 int vmw_fb_close(struct vmw_private
*vmw_priv
)
559 struct fb_info
*info
;
560 struct vmw_fb_par
*par
;
561 struct ttm_buffer_object
*bo
;
563 if (!vmw_priv
->fb_info
)
566 info
= vmw_priv
->fb_info
;
568 bo
= &par
->vmw_bo
->base
;
572 fb_deferred_io_cleanup(info
);
573 unregister_framebuffer(info
);
575 ttm_bo_kunmap(&par
->map
);
579 framebuffer_release(info
);
584 int vmw_dmabuf_from_vram(struct vmw_private
*vmw_priv
,
585 struct vmw_dma_buffer
*vmw_bo
)
587 struct ttm_buffer_object
*bo
= &vmw_bo
->base
;
590 ret
= ttm_bo_reserve(bo
, false, false, false, 0);
591 if (unlikely(ret
!= 0))
594 ret
= ttm_bo_validate(bo
, &vmw_sys_placement
, false, false, false);
595 ttm_bo_unreserve(bo
);
600 int vmw_dmabuf_to_start_of_vram(struct vmw_private
*vmw_priv
,
601 struct vmw_dma_buffer
*vmw_bo
)
603 struct ttm_buffer_object
*bo
= &vmw_bo
->base
;
604 struct ttm_placement ne_placement
= vmw_vram_ne_placement
;
607 ne_placement
.lpfn
= bo
->num_pages
;
610 ret
= ttm_write_lock(&vmw_priv
->active_master
->lock
, false);
611 if (unlikely(ret
!= 0))
614 ret
= ttm_bo_reserve(bo
, false, false, false, 0);
615 if (unlikely(ret
!= 0))
618 if (bo
->mem
.mem_type
== TTM_PL_VRAM
&&
619 bo
->mem
.mm_node
->start
< bo
->num_pages
)
620 (void) ttm_bo_validate(bo
, &vmw_sys_placement
, false,
623 ret
= ttm_bo_validate(bo
, &ne_placement
, false, false, false);
625 /* Could probably bug on */
626 WARN_ON(bo
->offset
!= 0);
628 ttm_bo_unreserve(bo
);
630 ttm_write_unlock(&vmw_priv
->active_master
->lock
);
635 int vmw_fb_off(struct vmw_private
*vmw_priv
)
637 struct fb_info
*info
;
638 struct vmw_fb_par
*par
;
641 if (!vmw_priv
->fb_info
)
644 info
= vmw_priv
->fb_info
;
647 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
648 par
->dirty
.active
= false;
649 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
651 flush_scheduled_work();
654 ttm_bo_kunmap(&par
->map
);
656 vmw_dmabuf_from_vram(vmw_priv
, par
->vmw_bo
);
661 int vmw_fb_on(struct vmw_private
*vmw_priv
)
663 struct fb_info
*info
;
664 struct vmw_fb_par
*par
;
669 if (!vmw_priv
->fb_info
)
672 info
= vmw_priv
->fb_info
;
675 /* we are already active */
676 if (par
->bo_ptr
!= NULL
)
679 /* Make sure that all overlays are stoped when we take over */
680 vmw_overlay_stop_all(vmw_priv
);
682 ret
= vmw_dmabuf_to_start_of_vram(vmw_priv
, par
->vmw_bo
);
683 if (unlikely(ret
!= 0)) {
684 DRM_ERROR("could not move buffer to start of VRAM\n");
688 ret
= ttm_bo_kmap(&par
->vmw_bo
->base
,
690 par
->vmw_bo
->base
.num_pages
,
693 par
->bo_ptr
= ttm_kmap_obj_virtual(&par
->map
, &dummy
);
695 spin_lock_irqsave(&par
->dirty
.lock
, flags
);
696 par
->dirty
.active
= true;
697 spin_unlock_irqrestore(&par
->dirty
.lock
, flags
);
700 vmw_fb_set_par(info
);
702 vmw_fb_dirty_mark(par
, 0, 0, info
->var
.xres
, info
->var
.yres
);
704 /* If there already was stuff dirty we wont
705 * schedule a new work, so lets do it now */
706 schedule_delayed_work(&info
->deferred_work
, 0);