2 * Copyright © 2007 David Airlie
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/errno.h>
30 #include <linux/string.h>
32 #include <linux/tty.h>
33 #include <linux/sysrq.h>
34 #include <linux/delay.h>
36 #include <linux/init.h>
37 #include <linux/screen_info.h>
38 #include <linux/vga_switcheroo.h>
39 #include <linux/console.h>
42 #include <drm/drm_crtc.h>
43 #include <drm/drm_crtc_helper.h>
44 #include <drm/drm_fb_helper.h>
45 #include "nouveau_drv.h"
46 #include <drm/nouveau_drm.h>
47 #include "nouveau_crtc.h"
48 #include "nouveau_fb.h"
49 #include "nouveau_fbcon.h"
50 #include "nouveau_dma.h"
53 nouveau_fbcon_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
55 struct nouveau_fbdev
*nfbdev
= info
->par
;
56 struct drm_device
*dev
= nfbdev
->dev
;
57 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
60 if (info
->state
!= FBINFO_STATE_RUNNING
)
64 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
65 mutex_trylock(&dev_priv
->channel
->mutex
)) {
66 if (dev_priv
->card_type
< NV_50
)
67 ret
= nv04_fbcon_fillrect(info
, rect
);
69 if (dev_priv
->card_type
< NV_C0
)
70 ret
= nv50_fbcon_fillrect(info
, rect
);
72 ret
= nvc0_fbcon_fillrect(info
, rect
);
73 mutex_unlock(&dev_priv
->channel
->mutex
);
80 nouveau_fbcon_gpu_lockup(info
);
81 cfb_fillrect(info
, rect
);
85 nouveau_fbcon_copyarea(struct fb_info
*info
, const struct fb_copyarea
*image
)
87 struct nouveau_fbdev
*nfbdev
= info
->par
;
88 struct drm_device
*dev
= nfbdev
->dev
;
89 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
92 if (info
->state
!= FBINFO_STATE_RUNNING
)
96 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
97 mutex_trylock(&dev_priv
->channel
->mutex
)) {
98 if (dev_priv
->card_type
< NV_50
)
99 ret
= nv04_fbcon_copyarea(info
, image
);
101 if (dev_priv
->card_type
< NV_C0
)
102 ret
= nv50_fbcon_copyarea(info
, image
);
104 ret
= nvc0_fbcon_copyarea(info
, image
);
105 mutex_unlock(&dev_priv
->channel
->mutex
);
112 nouveau_fbcon_gpu_lockup(info
);
113 cfb_copyarea(info
, image
);
117 nouveau_fbcon_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
119 struct nouveau_fbdev
*nfbdev
= info
->par
;
120 struct drm_device
*dev
= nfbdev
->dev
;
121 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
124 if (info
->state
!= FBINFO_STATE_RUNNING
)
128 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
129 mutex_trylock(&dev_priv
->channel
->mutex
)) {
130 if (dev_priv
->card_type
< NV_50
)
131 ret
= nv04_fbcon_imageblit(info
, image
);
133 if (dev_priv
->card_type
< NV_C0
)
134 ret
= nv50_fbcon_imageblit(info
, image
);
136 ret
= nvc0_fbcon_imageblit(info
, image
);
137 mutex_unlock(&dev_priv
->channel
->mutex
);
144 nouveau_fbcon_gpu_lockup(info
);
145 cfb_imageblit(info
, image
);
149 nouveau_fbcon_sync(struct fb_info
*info
)
151 struct nouveau_fbdev
*nfbdev
= info
->par
;
152 struct drm_device
*dev
= nfbdev
->dev
;
153 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
154 struct nouveau_channel
*chan
= dev_priv
->channel
;
157 if (!chan
|| !chan
->accel_done
|| in_interrupt() ||
158 info
->state
!= FBINFO_STATE_RUNNING
||
159 info
->flags
& FBINFO_HWACCEL_DISABLED
)
162 if (!mutex_trylock(&chan
->mutex
))
165 ret
= nouveau_channel_idle(chan
);
166 mutex_unlock(&chan
->mutex
);
168 nouveau_fbcon_gpu_lockup(info
);
172 chan
->accel_done
= false;
176 static struct fb_ops nouveau_fbcon_ops
= {
177 .owner
= THIS_MODULE
,
178 .fb_check_var
= drm_fb_helper_check_var
,
179 .fb_set_par
= drm_fb_helper_set_par
,
180 .fb_fillrect
= nouveau_fbcon_fillrect
,
181 .fb_copyarea
= nouveau_fbcon_copyarea
,
182 .fb_imageblit
= nouveau_fbcon_imageblit
,
183 .fb_sync
= nouveau_fbcon_sync
,
184 .fb_pan_display
= drm_fb_helper_pan_display
,
185 .fb_blank
= drm_fb_helper_blank
,
186 .fb_setcmap
= drm_fb_helper_setcmap
,
187 .fb_debug_enter
= drm_fb_helper_debug_enter
,
188 .fb_debug_leave
= drm_fb_helper_debug_leave
,
191 static struct fb_ops nouveau_fbcon_sw_ops
= {
192 .owner
= THIS_MODULE
,
193 .fb_check_var
= drm_fb_helper_check_var
,
194 .fb_set_par
= drm_fb_helper_set_par
,
195 .fb_fillrect
= cfb_fillrect
,
196 .fb_copyarea
= cfb_copyarea
,
197 .fb_imageblit
= cfb_imageblit
,
198 .fb_pan_display
= drm_fb_helper_pan_display
,
199 .fb_blank
= drm_fb_helper_blank
,
200 .fb_setcmap
= drm_fb_helper_setcmap
,
201 .fb_debug_enter
= drm_fb_helper_debug_enter
,
202 .fb_debug_leave
= drm_fb_helper_debug_leave
,
205 static void nouveau_fbcon_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
208 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
210 nv_crtc
->lut
.r
[regno
] = red
;
211 nv_crtc
->lut
.g
[regno
] = green
;
212 nv_crtc
->lut
.b
[regno
] = blue
;
215 static void nouveau_fbcon_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
216 u16
*blue
, int regno
)
218 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
220 *red
= nv_crtc
->lut
.r
[regno
];
221 *green
= nv_crtc
->lut
.g
[regno
];
222 *blue
= nv_crtc
->lut
.b
[regno
];
226 nouveau_fbcon_zfill(struct drm_device
*dev
, struct nouveau_fbdev
*nfbdev
)
228 struct fb_info
*info
= nfbdev
->helper
.fbdev
;
229 struct fb_fillrect rect
;
231 /* Clear the entire fbcon. The drm will program every connector
232 * with it's preferred mode. If the sizes differ, one display will
233 * quite likely have garbage around the console.
235 rect
.dx
= rect
.dy
= 0;
236 rect
.width
= info
->var
.xres_virtual
;
237 rect
.height
= info
->var
.yres_virtual
;
240 info
->fbops
->fb_fillrect(info
, &rect
);
244 nouveau_fbcon_create(struct nouveau_fbdev
*nfbdev
,
245 struct drm_fb_helper_surface_size
*sizes
)
247 struct drm_device
*dev
= nfbdev
->dev
;
248 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
249 struct fb_info
*info
;
250 struct drm_framebuffer
*fb
;
251 struct nouveau_framebuffer
*nouveau_fb
;
252 struct nouveau_channel
*chan
;
253 struct nouveau_bo
*nvbo
;
254 struct drm_mode_fb_cmd2 mode_cmd
;
255 struct pci_dev
*pdev
= dev
->pdev
;
256 struct device
*device
= &pdev
->dev
;
259 mode_cmd
.width
= sizes
->surface_width
;
260 mode_cmd
.height
= sizes
->surface_height
;
262 mode_cmd
.pitches
[0] = mode_cmd
.width
* (sizes
->surface_bpp
>> 3);
263 mode_cmd
.pitches
[0] = roundup(mode_cmd
.pitches
[0], 256);
265 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(sizes
->surface_bpp
,
266 sizes
->surface_depth
);
268 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
269 size
= roundup(size
, PAGE_SIZE
);
271 ret
= nouveau_gem_new(dev
, size
, 0, NOUVEAU_GEM_DOMAIN_VRAM
,
274 NV_ERROR(dev
, "failed to allocate framebuffer\n");
278 ret
= nouveau_bo_pin(nvbo
, TTM_PL_FLAG_VRAM
);
280 NV_ERROR(dev
, "failed to pin fb: %d\n", ret
);
281 nouveau_bo_ref(NULL
, &nvbo
);
285 ret
= nouveau_bo_map(nvbo
);
287 NV_ERROR(dev
, "failed to map fb: %d\n", ret
);
288 nouveau_bo_unpin(nvbo
);
289 nouveau_bo_ref(NULL
, &nvbo
);
293 chan
= nouveau_nofbaccel
? NULL
: dev_priv
->channel
;
294 if (chan
&& dev_priv
->card_type
>= NV_50
) {
295 ret
= nouveau_bo_vma_add(nvbo
, chan
->vm
, &nfbdev
->nouveau_fb
.vma
);
297 NV_ERROR(dev
, "failed to map fb into chan: %d\n", ret
);
302 mutex_lock(&dev
->struct_mutex
);
304 info
= framebuffer_alloc(0, device
);
310 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
318 nouveau_framebuffer_init(dev
, &nfbdev
->nouveau_fb
, &mode_cmd
, nvbo
);
320 nouveau_fb
= &nfbdev
->nouveau_fb
;
321 fb
= &nouveau_fb
->base
;
324 nfbdev
->helper
.fb
= fb
;
325 nfbdev
->helper
.fbdev
= info
;
327 strcpy(info
->fix
.id
, "nouveaufb");
328 if (nouveau_nofbaccel
)
329 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_DISABLED
;
331 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_COPYAREA
|
332 FBINFO_HWACCEL_FILLRECT
|
333 FBINFO_HWACCEL_IMAGEBLIT
;
334 info
->flags
|= FBINFO_CAN_FORCE_OUTPUT
;
335 info
->fbops
= &nouveau_fbcon_sw_ops
;
336 info
->fix
.smem_start
= nvbo
->bo
.mem
.bus
.base
+
337 nvbo
->bo
.mem
.bus
.offset
;
338 info
->fix
.smem_len
= size
;
340 info
->screen_base
= nvbo_kmap_obj_iovirtual(nouveau_fb
->nvbo
);
341 info
->screen_size
= size
;
343 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
344 drm_fb_helper_fill_var(info
, &nfbdev
->helper
, sizes
->fb_width
, sizes
->fb_height
);
346 /* Set aperture base/size for vesafb takeover */
347 info
->apertures
= dev_priv
->apertures
;
348 if (!info
->apertures
) {
353 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
355 mutex_unlock(&dev
->struct_mutex
);
357 if (dev_priv
->channel
&& !nouveau_nofbaccel
) {
359 if (dev_priv
->card_type
< NV_50
)
360 ret
= nv04_fbcon_accel_init(info
);
362 if (dev_priv
->card_type
< NV_C0
)
363 ret
= nv50_fbcon_accel_init(info
);
365 ret
= nvc0_fbcon_accel_init(info
);
368 info
->fbops
= &nouveau_fbcon_ops
;
371 nouveau_fbcon_zfill(dev
, nfbdev
);
373 /* To allow resizeing without swapping buffers */
374 NV_INFO(dev
, "allocated %dx%d fb: 0x%lx, bo %p\n",
375 nouveau_fb
->base
.width
,
376 nouveau_fb
->base
.height
,
377 nvbo
->bo
.offset
, nvbo
);
379 vga_switcheroo_client_fb_set(dev
->pdev
, info
);
383 mutex_unlock(&dev
->struct_mutex
);
389 nouveau_fbcon_find_or_create_single(struct drm_fb_helper
*helper
,
390 struct drm_fb_helper_surface_size
*sizes
)
392 struct nouveau_fbdev
*nfbdev
= (struct nouveau_fbdev
*)helper
;
397 ret
= nouveau_fbcon_create(nfbdev
, sizes
);
406 nouveau_fbcon_output_poll_changed(struct drm_device
*dev
)
408 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
409 drm_fb_helper_hotplug_event(&dev_priv
->nfbdev
->helper
);
413 nouveau_fbcon_destroy(struct drm_device
*dev
, struct nouveau_fbdev
*nfbdev
)
415 struct nouveau_framebuffer
*nouveau_fb
= &nfbdev
->nouveau_fb
;
416 struct fb_info
*info
;
418 if (nfbdev
->helper
.fbdev
) {
419 info
= nfbdev
->helper
.fbdev
;
420 unregister_framebuffer(info
);
422 fb_dealloc_cmap(&info
->cmap
);
423 framebuffer_release(info
);
426 if (nouveau_fb
->nvbo
) {
427 nouveau_bo_unmap(nouveau_fb
->nvbo
);
428 nouveau_bo_vma_del(nouveau_fb
->nvbo
, &nouveau_fb
->vma
);
429 drm_gem_object_unreference_unlocked(nouveau_fb
->nvbo
->gem
);
430 nouveau_fb
->nvbo
= NULL
;
432 drm_fb_helper_fini(&nfbdev
->helper
);
433 drm_framebuffer_cleanup(&nouveau_fb
->base
);
437 void nouveau_fbcon_gpu_lockup(struct fb_info
*info
)
439 struct nouveau_fbdev
*nfbdev
= info
->par
;
440 struct drm_device
*dev
= nfbdev
->dev
;
442 NV_ERROR(dev
, "GPU lockup - switching to software fbcon\n");
443 info
->flags
|= FBINFO_HWACCEL_DISABLED
;
446 static struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs
= {
447 .gamma_set
= nouveau_fbcon_gamma_set
,
448 .gamma_get
= nouveau_fbcon_gamma_get
,
449 .fb_probe
= nouveau_fbcon_find_or_create_single
,
453 int nouveau_fbcon_init(struct drm_device
*dev
)
455 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
456 struct nouveau_fbdev
*nfbdev
;
460 nfbdev
= kzalloc(sizeof(struct nouveau_fbdev
), GFP_KERNEL
);
465 dev_priv
->nfbdev
= nfbdev
;
466 nfbdev
->helper
.funcs
= &nouveau_fbcon_helper_funcs
;
468 ret
= drm_fb_helper_init(dev
, &nfbdev
->helper
,
469 dev
->mode_config
.num_crtc
, 4);
475 drm_fb_helper_single_add_all_connectors(&nfbdev
->helper
);
477 if (dev_priv
->vram_size
<= 32 * 1024 * 1024)
479 else if (dev_priv
->vram_size
<= 64 * 1024 * 1024)
484 drm_fb_helper_initial_config(&nfbdev
->helper
, preferred_bpp
);
488 void nouveau_fbcon_fini(struct drm_device
*dev
)
490 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
492 if (!dev_priv
->nfbdev
)
495 nouveau_fbcon_destroy(dev
, dev_priv
->nfbdev
);
496 kfree(dev_priv
->nfbdev
);
497 dev_priv
->nfbdev
= NULL
;
500 void nouveau_fbcon_save_disable_accel(struct drm_device
*dev
)
502 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
504 dev_priv
->nfbdev
->saved_flags
= dev_priv
->nfbdev
->helper
.fbdev
->flags
;
505 dev_priv
->nfbdev
->helper
.fbdev
->flags
|= FBINFO_HWACCEL_DISABLED
;
508 void nouveau_fbcon_restore_accel(struct drm_device
*dev
)
510 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
511 dev_priv
->nfbdev
->helper
.fbdev
->flags
= dev_priv
->nfbdev
->saved_flags
;
514 void nouveau_fbcon_set_suspend(struct drm_device
*dev
, int state
)
516 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
519 nouveau_fbcon_save_disable_accel(dev
);
520 fb_set_suspend(dev_priv
->nfbdev
->helper
.fbdev
, state
);
522 nouveau_fbcon_restore_accel(dev
);
526 void nouveau_fbcon_zfill_all(struct drm_device
*dev
)
528 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
529 nouveau_fbcon_zfill(dev
, dev_priv
->nfbdev
);