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>
46 #include "nouveau_drm.h"
47 #include "nouveau_gem.h"
48 #include "nouveau_bo.h"
49 #include "nouveau_fbcon.h"
50 #include "nouveau_chan.h"
52 #include "nouveau_crtc.h"
54 MODULE_PARM_DESC(nofbaccel
, "Disable fbcon acceleration");
55 int nouveau_nofbaccel
= 0;
56 module_param_named(nofbaccel
, nouveau_nofbaccel
, int, 0400);
59 nouveau_fbcon_fillrect(struct fb_info
*info
, const struct fb_fillrect
*rect
)
61 struct nouveau_fbdev
*fbcon
= info
->par
;
62 struct nouveau_drm
*drm
= nouveau_drm(fbcon
->dev
);
63 struct nvif_device
*device
= &drm
->device
;
66 if (info
->state
!= FBINFO_STATE_RUNNING
)
70 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
71 mutex_trylock(&drm
->client
.mutex
)) {
72 if (device
->info
.family
< NV_DEVICE_INFO_V0_TESLA
)
73 ret
= nv04_fbcon_fillrect(info
, rect
);
75 if (device
->info
.family
< NV_DEVICE_INFO_V0_FERMI
)
76 ret
= nv50_fbcon_fillrect(info
, rect
);
78 ret
= nvc0_fbcon_fillrect(info
, rect
);
79 mutex_unlock(&drm
->client
.mutex
);
86 nouveau_fbcon_gpu_lockup(info
);
87 cfb_fillrect(info
, rect
);
91 nouveau_fbcon_copyarea(struct fb_info
*info
, const struct fb_copyarea
*image
)
93 struct nouveau_fbdev
*fbcon
= info
->par
;
94 struct nouveau_drm
*drm
= nouveau_drm(fbcon
->dev
);
95 struct nvif_device
*device
= &drm
->device
;
98 if (info
->state
!= FBINFO_STATE_RUNNING
)
102 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
103 mutex_trylock(&drm
->client
.mutex
)) {
104 if (device
->info
.family
< NV_DEVICE_INFO_V0_TESLA
)
105 ret
= nv04_fbcon_copyarea(info
, image
);
107 if (device
->info
.family
< NV_DEVICE_INFO_V0_FERMI
)
108 ret
= nv50_fbcon_copyarea(info
, image
);
110 ret
= nvc0_fbcon_copyarea(info
, image
);
111 mutex_unlock(&drm
->client
.mutex
);
118 nouveau_fbcon_gpu_lockup(info
);
119 cfb_copyarea(info
, image
);
123 nouveau_fbcon_imageblit(struct fb_info
*info
, const struct fb_image
*image
)
125 struct nouveau_fbdev
*fbcon
= info
->par
;
126 struct nouveau_drm
*drm
= nouveau_drm(fbcon
->dev
);
127 struct nvif_device
*device
= &drm
->device
;
130 if (info
->state
!= FBINFO_STATE_RUNNING
)
134 if (!in_interrupt() && !(info
->flags
& FBINFO_HWACCEL_DISABLED
) &&
135 mutex_trylock(&drm
->client
.mutex
)) {
136 if (device
->info
.family
< NV_DEVICE_INFO_V0_TESLA
)
137 ret
= nv04_fbcon_imageblit(info
, image
);
139 if (device
->info
.family
< NV_DEVICE_INFO_V0_FERMI
)
140 ret
= nv50_fbcon_imageblit(info
, image
);
142 ret
= nvc0_fbcon_imageblit(info
, image
);
143 mutex_unlock(&drm
->client
.mutex
);
150 nouveau_fbcon_gpu_lockup(info
);
151 cfb_imageblit(info
, image
);
155 nouveau_fbcon_sync(struct fb_info
*info
)
157 struct nouveau_fbdev
*fbcon
= info
->par
;
158 struct nouveau_drm
*drm
= nouveau_drm(fbcon
->dev
);
159 struct nouveau_channel
*chan
= drm
->channel
;
162 if (!chan
|| !chan
->accel_done
|| in_interrupt() ||
163 info
->state
!= FBINFO_STATE_RUNNING
||
164 info
->flags
& FBINFO_HWACCEL_DISABLED
)
167 if (!mutex_trylock(&drm
->client
.mutex
))
170 ret
= nouveau_channel_idle(chan
);
171 mutex_unlock(&drm
->client
.mutex
);
173 nouveau_fbcon_gpu_lockup(info
);
177 chan
->accel_done
= false;
181 static struct fb_ops nouveau_fbcon_ops
= {
182 .owner
= THIS_MODULE
,
183 .fb_check_var
= drm_fb_helper_check_var
,
184 .fb_set_par
= drm_fb_helper_set_par
,
185 .fb_fillrect
= nouveau_fbcon_fillrect
,
186 .fb_copyarea
= nouveau_fbcon_copyarea
,
187 .fb_imageblit
= nouveau_fbcon_imageblit
,
188 .fb_sync
= nouveau_fbcon_sync
,
189 .fb_pan_display
= drm_fb_helper_pan_display
,
190 .fb_blank
= drm_fb_helper_blank
,
191 .fb_setcmap
= drm_fb_helper_setcmap
,
192 .fb_debug_enter
= drm_fb_helper_debug_enter
,
193 .fb_debug_leave
= drm_fb_helper_debug_leave
,
196 static struct fb_ops nouveau_fbcon_sw_ops
= {
197 .owner
= THIS_MODULE
,
198 .fb_check_var
= drm_fb_helper_check_var
,
199 .fb_set_par
= drm_fb_helper_set_par
,
200 .fb_fillrect
= cfb_fillrect
,
201 .fb_copyarea
= cfb_copyarea
,
202 .fb_imageblit
= cfb_imageblit
,
203 .fb_pan_display
= drm_fb_helper_pan_display
,
204 .fb_blank
= drm_fb_helper_blank
,
205 .fb_setcmap
= drm_fb_helper_setcmap
,
206 .fb_debug_enter
= drm_fb_helper_debug_enter
,
207 .fb_debug_leave
= drm_fb_helper_debug_leave
,
211 nouveau_fbcon_accel_save_disable(struct drm_device
*dev
)
213 struct nouveau_drm
*drm
= nouveau_drm(dev
);
215 drm
->fbcon
->saved_flags
= drm
->fbcon
->helper
.fbdev
->flags
;
216 drm
->fbcon
->helper
.fbdev
->flags
|= FBINFO_HWACCEL_DISABLED
;
221 nouveau_fbcon_accel_restore(struct drm_device
*dev
)
223 struct nouveau_drm
*drm
= nouveau_drm(dev
);
225 drm
->fbcon
->helper
.fbdev
->flags
= drm
->fbcon
->saved_flags
;
230 nouveau_fbcon_accel_fini(struct drm_device
*dev
)
232 struct nouveau_drm
*drm
= nouveau_drm(dev
);
233 struct nouveau_fbdev
*fbcon
= drm
->fbcon
;
234 if (fbcon
&& drm
->channel
) {
236 fbcon
->helper
.fbdev
->flags
|= FBINFO_HWACCEL_DISABLED
;
238 nouveau_channel_idle(drm
->channel
);
239 nvif_object_fini(&fbcon
->twod
);
240 nvif_object_fini(&fbcon
->blit
);
241 nvif_object_fini(&fbcon
->gdi
);
242 nvif_object_fini(&fbcon
->patt
);
243 nvif_object_fini(&fbcon
->rop
);
244 nvif_object_fini(&fbcon
->clip
);
245 nvif_object_fini(&fbcon
->surf2d
);
250 nouveau_fbcon_accel_init(struct drm_device
*dev
)
252 struct nouveau_drm
*drm
= nouveau_drm(dev
);
253 struct nouveau_fbdev
*fbcon
= drm
->fbcon
;
254 struct fb_info
*info
= fbcon
->helper
.fbdev
;
257 if (drm
->device
.info
.family
< NV_DEVICE_INFO_V0_TESLA
)
258 ret
= nv04_fbcon_accel_init(info
);
260 if (drm
->device
.info
.family
< NV_DEVICE_INFO_V0_FERMI
)
261 ret
= nv50_fbcon_accel_init(info
);
263 ret
= nvc0_fbcon_accel_init(info
);
266 info
->fbops
= &nouveau_fbcon_ops
;
269 static void nouveau_fbcon_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
272 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
274 nv_crtc
->lut
.r
[regno
] = red
;
275 nv_crtc
->lut
.g
[regno
] = green
;
276 nv_crtc
->lut
.b
[regno
] = blue
;
279 static void nouveau_fbcon_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
280 u16
*blue
, int regno
)
282 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
284 *red
= nv_crtc
->lut
.r
[regno
];
285 *green
= nv_crtc
->lut
.g
[regno
];
286 *blue
= nv_crtc
->lut
.b
[regno
];
290 nouveau_fbcon_zfill(struct drm_device
*dev
, struct nouveau_fbdev
*fbcon
)
292 struct fb_info
*info
= fbcon
->helper
.fbdev
;
293 struct fb_fillrect rect
;
295 /* Clear the entire fbcon. The drm will program every connector
296 * with it's preferred mode. If the sizes differ, one display will
297 * quite likely have garbage around the console.
299 rect
.dx
= rect
.dy
= 0;
300 rect
.width
= info
->var
.xres_virtual
;
301 rect
.height
= info
->var
.yres_virtual
;
304 info
->fbops
->fb_fillrect(info
, &rect
);
308 nouveau_fbcon_create(struct drm_fb_helper
*helper
,
309 struct drm_fb_helper_surface_size
*sizes
)
311 struct nouveau_fbdev
*fbcon
= (struct nouveau_fbdev
*)helper
;
312 struct drm_device
*dev
= fbcon
->dev
;
313 struct nouveau_drm
*drm
= nouveau_drm(dev
);
314 struct nvif_device
*device
= &drm
->device
;
315 struct fb_info
*info
;
316 struct drm_framebuffer
*fb
;
317 struct nouveau_framebuffer
*nouveau_fb
;
318 struct nouveau_channel
*chan
;
319 struct nouveau_bo
*nvbo
;
320 struct drm_mode_fb_cmd2 mode_cmd
;
321 struct pci_dev
*pdev
= dev
->pdev
;
324 mode_cmd
.width
= sizes
->surface_width
;
325 mode_cmd
.height
= sizes
->surface_height
;
327 mode_cmd
.pitches
[0] = mode_cmd
.width
* (sizes
->surface_bpp
>> 3);
328 mode_cmd
.pitches
[0] = roundup(mode_cmd
.pitches
[0], 256);
330 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(sizes
->surface_bpp
,
331 sizes
->surface_depth
);
333 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
334 size
= roundup(size
, PAGE_SIZE
);
336 ret
= nouveau_gem_new(dev
, size
, 0, NOUVEAU_GEM_DOMAIN_VRAM
,
339 NV_ERROR(drm
, "failed to allocate framebuffer\n");
343 ret
= nouveau_bo_pin(nvbo
, TTM_PL_FLAG_VRAM
);
345 NV_ERROR(drm
, "failed to pin fb: %d\n", ret
);
349 ret
= nouveau_bo_map(nvbo
);
351 NV_ERROR(drm
, "failed to map fb: %d\n", ret
);
355 chan
= nouveau_nofbaccel
? NULL
: drm
->channel
;
356 if (chan
&& device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
357 ret
= nouveau_bo_vma_add(nvbo
, drm
->client
.vm
,
358 &fbcon
->nouveau_fb
.vma
);
360 NV_ERROR(drm
, "failed to map fb into chan: %d\n", ret
);
365 mutex_lock(&dev
->struct_mutex
);
367 info
= framebuffer_alloc(0, &pdev
->dev
);
373 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
376 framebuffer_release(info
);
382 nouveau_framebuffer_init(dev
, &fbcon
->nouveau_fb
, &mode_cmd
, nvbo
);
384 nouveau_fb
= &fbcon
->nouveau_fb
;
385 fb
= &nouveau_fb
->base
;
388 fbcon
->helper
.fb
= fb
;
389 fbcon
->helper
.fbdev
= info
;
391 strcpy(info
->fix
.id
, "nouveaufb");
393 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_DISABLED
;
395 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_COPYAREA
|
396 FBINFO_HWACCEL_FILLRECT
|
397 FBINFO_HWACCEL_IMAGEBLIT
;
398 info
->flags
|= FBINFO_CAN_FORCE_OUTPUT
;
399 info
->fbops
= &nouveau_fbcon_sw_ops
;
400 info
->fix
.smem_start
= nvbo
->bo
.mem
.bus
.base
+
401 nvbo
->bo
.mem
.bus
.offset
;
402 info
->fix
.smem_len
= size
;
404 info
->screen_base
= nvbo_kmap_obj_iovirtual(nouveau_fb
->nvbo
);
405 info
->screen_size
= size
;
407 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
408 drm_fb_helper_fill_var(info
, &fbcon
->helper
, sizes
->fb_width
, sizes
->fb_height
);
410 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
412 mutex_unlock(&dev
->struct_mutex
);
415 nouveau_fbcon_accel_init(dev
);
416 nouveau_fbcon_zfill(dev
, fbcon
);
418 /* To allow resizeing without swapping buffers */
419 NV_INFO(drm
, "allocated %dx%d fb: 0x%lx, bo %p\n",
420 nouveau_fb
->base
.width
, nouveau_fb
->base
.height
,
421 nvbo
->bo
.offset
, nvbo
);
423 vga_switcheroo_client_fb_set(dev
->pdev
, info
);
427 mutex_unlock(&dev
->struct_mutex
);
429 nouveau_bo_vma_del(nvbo
, &fbcon
->nouveau_fb
.vma
);
430 nouveau_bo_unmap(nvbo
);
432 nouveau_bo_unpin(nvbo
);
434 nouveau_bo_ref(NULL
, &nvbo
);
440 nouveau_fbcon_output_poll_changed(struct drm_device
*dev
)
442 struct nouveau_drm
*drm
= nouveau_drm(dev
);
444 drm_fb_helper_hotplug_event(&drm
->fbcon
->helper
);
448 nouveau_fbcon_destroy(struct drm_device
*dev
, struct nouveau_fbdev
*fbcon
)
450 struct nouveau_framebuffer
*nouveau_fb
= &fbcon
->nouveau_fb
;
451 struct fb_info
*info
;
453 if (fbcon
->helper
.fbdev
) {
454 info
= fbcon
->helper
.fbdev
;
455 unregister_framebuffer(info
);
457 fb_dealloc_cmap(&info
->cmap
);
458 framebuffer_release(info
);
461 if (nouveau_fb
->nvbo
) {
462 nouveau_bo_unmap(nouveau_fb
->nvbo
);
463 nouveau_bo_vma_del(nouveau_fb
->nvbo
, &nouveau_fb
->vma
);
464 nouveau_bo_unpin(nouveau_fb
->nvbo
);
465 drm_gem_object_unreference_unlocked(&nouveau_fb
->nvbo
->gem
);
466 nouveau_fb
->nvbo
= NULL
;
468 drm_fb_helper_fini(&fbcon
->helper
);
469 drm_framebuffer_unregister_private(&nouveau_fb
->base
);
470 drm_framebuffer_cleanup(&nouveau_fb
->base
);
474 void nouveau_fbcon_gpu_lockup(struct fb_info
*info
)
476 struct nouveau_fbdev
*fbcon
= info
->par
;
477 struct nouveau_drm
*drm
= nouveau_drm(fbcon
->dev
);
479 NV_ERROR(drm
, "GPU lockup - switching to software fbcon\n");
480 info
->flags
|= FBINFO_HWACCEL_DISABLED
;
483 static const struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs
= {
484 .gamma_set
= nouveau_fbcon_gamma_set
,
485 .gamma_get
= nouveau_fbcon_gamma_get
,
486 .fb_probe
= nouveau_fbcon_create
,
491 nouveau_fbcon_init(struct drm_device
*dev
)
493 struct nouveau_drm
*drm
= nouveau_drm(dev
);
494 struct nouveau_fbdev
*fbcon
;
498 if (!dev
->mode_config
.num_crtc
||
499 (dev
->pdev
->class >> 8) != PCI_CLASS_DISPLAY_VGA
)
502 fbcon
= kzalloc(sizeof(struct nouveau_fbdev
), GFP_KERNEL
);
509 drm_fb_helper_prepare(dev
, &fbcon
->helper
, &nouveau_fbcon_helper_funcs
);
511 ret
= drm_fb_helper_init(dev
, &fbcon
->helper
,
512 dev
->mode_config
.num_crtc
, 4);
518 drm_fb_helper_single_add_all_connectors(&fbcon
->helper
);
520 if (drm
->device
.info
.ram_size
<= 32 * 1024 * 1024)
523 if (drm
->device
.info
.ram_size
<= 64 * 1024 * 1024)
528 /* disable all the possible outputs/crtcs before entering KMS mode */
529 drm_helper_disable_unused_functions(dev
);
531 drm_fb_helper_initial_config(&fbcon
->helper
, preferred_bpp
);
536 nouveau_fbcon_fini(struct drm_device
*dev
)
538 struct nouveau_drm
*drm
= nouveau_drm(dev
);
543 nouveau_fbcon_accel_fini(dev
);
544 nouveau_fbcon_destroy(dev
, drm
->fbcon
);
550 nouveau_fbcon_set_suspend(struct drm_device
*dev
, int state
)
552 struct nouveau_drm
*drm
= nouveau_drm(dev
);
556 nouveau_fbcon_accel_restore(dev
);
557 nouveau_fbcon_zfill(dev
, drm
->fbcon
);
559 fb_set_suspend(drm
->fbcon
->helper
.fbdev
, state
);
561 nouveau_fbcon_accel_save_disable(dev
);