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>
43 #include "drm_crtc_helper.h"
44 #include "drm_fb_helper.h"
45 #include "nouveau_drv.h"
46 #include "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_sync(struct fb_info
*info
)
55 struct nouveau_fbdev
*nfbdev
= info
->par
;
56 struct drm_device
*dev
= nfbdev
->dev
;
57 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
58 struct nouveau_channel
*chan
= dev_priv
->channel
;
61 if (!chan
|| !chan
->accel_done
||
62 info
->state
!= FBINFO_STATE_RUNNING
||
63 info
->flags
& FBINFO_HWACCEL_DISABLED
)
66 if (RING_SPACE(chan
, 4)) {
67 nouveau_fbcon_gpu_lockup(info
);
71 BEGIN_RING(chan
, 0, 0x0104, 1);
73 BEGIN_RING(chan
, 0, 0x0100, 1);
75 nouveau_bo_wr32(chan
->notifier_bo
, chan
->m2mf_ntfy
+ 3, 0xffffffff);
79 for (i
= 0; i
< 100000; i
++) {
80 if (!nouveau_bo_rd32(chan
->notifier_bo
, chan
->m2mf_ntfy
+ 3)) {
88 nouveau_fbcon_gpu_lockup(info
);
92 chan
->accel_done
= false;
96 static struct fb_ops nouveau_fbcon_ops
= {
98 .fb_check_var
= drm_fb_helper_check_var
,
99 .fb_set_par
= drm_fb_helper_set_par
,
100 .fb_fillrect
= cfb_fillrect
,
101 .fb_copyarea
= cfb_copyarea
,
102 .fb_imageblit
= cfb_imageblit
,
103 .fb_sync
= nouveau_fbcon_sync
,
104 .fb_pan_display
= drm_fb_helper_pan_display
,
105 .fb_blank
= drm_fb_helper_blank
,
106 .fb_setcmap
= drm_fb_helper_setcmap
,
109 static struct fb_ops nv04_fbcon_ops
= {
110 .owner
= THIS_MODULE
,
111 .fb_check_var
= drm_fb_helper_check_var
,
112 .fb_set_par
= drm_fb_helper_set_par
,
113 .fb_fillrect
= nv04_fbcon_fillrect
,
114 .fb_copyarea
= nv04_fbcon_copyarea
,
115 .fb_imageblit
= nv04_fbcon_imageblit
,
116 .fb_sync
= nouveau_fbcon_sync
,
117 .fb_pan_display
= drm_fb_helper_pan_display
,
118 .fb_blank
= drm_fb_helper_blank
,
119 .fb_setcmap
= drm_fb_helper_setcmap
,
122 static struct fb_ops nv50_fbcon_ops
= {
123 .owner
= THIS_MODULE
,
124 .fb_check_var
= drm_fb_helper_check_var
,
125 .fb_set_par
= drm_fb_helper_set_par
,
126 .fb_fillrect
= nv50_fbcon_fillrect
,
127 .fb_copyarea
= nv50_fbcon_copyarea
,
128 .fb_imageblit
= nv50_fbcon_imageblit
,
129 .fb_sync
= nouveau_fbcon_sync
,
130 .fb_pan_display
= drm_fb_helper_pan_display
,
131 .fb_blank
= drm_fb_helper_blank
,
132 .fb_setcmap
= drm_fb_helper_setcmap
,
135 static void nouveau_fbcon_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
138 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
140 nv_crtc
->lut
.r
[regno
] = red
;
141 nv_crtc
->lut
.g
[regno
] = green
;
142 nv_crtc
->lut
.b
[regno
] = blue
;
145 static void nouveau_fbcon_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
146 u16
*blue
, int regno
)
148 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
150 *red
= nv_crtc
->lut
.r
[regno
];
151 *green
= nv_crtc
->lut
.g
[regno
];
152 *blue
= nv_crtc
->lut
.b
[regno
];
156 nouveau_fbcon_zfill(struct drm_device
*dev
, struct nouveau_fbdev
*nfbdev
)
158 struct fb_info
*info
= nfbdev
->helper
.fbdev
;
159 struct fb_fillrect rect
;
161 /* Clear the entire fbcon. The drm will program every connector
162 * with it's preferred mode. If the sizes differ, one display will
163 * quite likely have garbage around the console.
165 rect
.dx
= rect
.dy
= 0;
166 rect
.width
= info
->var
.xres_virtual
;
167 rect
.height
= info
->var
.yres_virtual
;
170 info
->fbops
->fb_fillrect(info
, &rect
);
174 nouveau_fbcon_create(struct nouveau_fbdev
*nfbdev
,
175 struct drm_fb_helper_surface_size
*sizes
)
177 struct drm_device
*dev
= nfbdev
->dev
;
178 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
179 struct fb_info
*info
;
180 struct drm_framebuffer
*fb
;
181 struct nouveau_framebuffer
*nouveau_fb
;
182 struct nouveau_bo
*nvbo
;
183 struct drm_mode_fb_cmd mode_cmd
;
184 struct pci_dev
*pdev
= dev
->pdev
;
185 struct device
*device
= &pdev
->dev
;
188 mode_cmd
.width
= sizes
->surface_width
;
189 mode_cmd
.height
= sizes
->surface_height
;
191 mode_cmd
.bpp
= sizes
->surface_bpp
;
192 mode_cmd
.pitch
= mode_cmd
.width
* (mode_cmd
.bpp
>> 3);
193 mode_cmd
.pitch
= roundup(mode_cmd
.pitch
, 256);
194 mode_cmd
.depth
= sizes
->surface_depth
;
196 size
= mode_cmd
.pitch
* mode_cmd
.height
;
197 size
= roundup(size
, PAGE_SIZE
);
199 ret
= nouveau_gem_new(dev
, dev_priv
->channel
, size
, 0, TTM_PL_FLAG_VRAM
,
200 0, 0x0000, false, true, &nvbo
);
202 NV_ERROR(dev
, "failed to allocate framebuffer\n");
206 ret
= nouveau_bo_pin(nvbo
, TTM_PL_FLAG_VRAM
);
208 NV_ERROR(dev
, "failed to pin fb: %d\n", ret
);
209 nouveau_bo_ref(NULL
, &nvbo
);
213 ret
= nouveau_bo_map(nvbo
);
215 NV_ERROR(dev
, "failed to map fb: %d\n", ret
);
216 nouveau_bo_unpin(nvbo
);
217 nouveau_bo_ref(NULL
, &nvbo
);
221 mutex_lock(&dev
->struct_mutex
);
223 info
= framebuffer_alloc(0, device
);
229 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
237 nouveau_framebuffer_init(dev
, &nfbdev
->nouveau_fb
, &mode_cmd
, nvbo
);
239 nouveau_fb
= &nfbdev
->nouveau_fb
;
240 fb
= &nouveau_fb
->base
;
243 nfbdev
->helper
.fb
= fb
;
244 nfbdev
->helper
.fbdev
= info
;
246 strcpy(info
->fix
.id
, "nouveaufb");
247 if (nouveau_nofbaccel
)
248 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_DISABLED
;
250 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_COPYAREA
|
251 FBINFO_HWACCEL_FILLRECT
|
252 FBINFO_HWACCEL_IMAGEBLIT
;
253 info
->flags
|= FBINFO_CAN_FORCE_OUTPUT
;
254 info
->fbops
= &nouveau_fbcon_ops
;
255 info
->fix
.smem_start
= dev
->mode_config
.fb_base
+ nvbo
->bo
.offset
-
256 dev_priv
->vm_vram_base
;
257 info
->fix
.smem_len
= size
;
259 info
->screen_base
= nvbo_kmap_obj_iovirtual(nouveau_fb
->nvbo
);
260 info
->screen_size
= size
;
262 drm_fb_helper_fill_fix(info
, fb
->pitch
, fb
->depth
);
263 drm_fb_helper_fill_var(info
, &nfbdev
->helper
, sizes
->fb_width
, sizes
->fb_height
);
265 /* FIXME: we really shouldn't expose mmio space at all */
266 info
->fix
.mmio_start
= pci_resource_start(pdev
, 1);
267 info
->fix
.mmio_len
= pci_resource_len(pdev
, 1);
269 /* Set aperture base/size for vesafb takeover */
270 info
->apertures
= dev_priv
->apertures
;
271 if (!info
->apertures
) {
276 info
->pixmap
.size
= 64*1024;
277 info
->pixmap
.buf_align
= 8;
278 info
->pixmap
.access_align
= 32;
279 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
280 info
->pixmap
.scan_align
= 1;
282 if (dev_priv
->channel
&& !nouveau_nofbaccel
) {
283 switch (dev_priv
->card_type
) {
287 nv50_fbcon_accel_init(info
);
288 info
->fbops
= &nv50_fbcon_ops
;
291 nv04_fbcon_accel_init(info
);
292 info
->fbops
= &nv04_fbcon_ops
;
297 nouveau_fbcon_zfill(dev
, nfbdev
);
299 /* To allow resizeing without swapping buffers */
300 NV_INFO(dev
, "allocated %dx%d fb: 0x%lx, bo %p\n",
301 nouveau_fb
->base
.width
,
302 nouveau_fb
->base
.height
,
303 nvbo
->bo
.offset
, nvbo
);
305 mutex_unlock(&dev
->struct_mutex
);
306 vga_switcheroo_client_fb_set(dev
->pdev
, info
);
310 mutex_unlock(&dev
->struct_mutex
);
316 nouveau_fbcon_find_or_create_single(struct drm_fb_helper
*helper
,
317 struct drm_fb_helper_surface_size
*sizes
)
319 struct nouveau_fbdev
*nfbdev
= (struct nouveau_fbdev
*)helper
;
324 ret
= nouveau_fbcon_create(nfbdev
, sizes
);
333 nouveau_fbcon_output_poll_changed(struct drm_device
*dev
)
335 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
336 drm_fb_helper_hotplug_event(&dev_priv
->nfbdev
->helper
);
340 nouveau_fbcon_destroy(struct drm_device
*dev
, struct nouveau_fbdev
*nfbdev
)
342 struct nouveau_framebuffer
*nouveau_fb
= &nfbdev
->nouveau_fb
;
343 struct fb_info
*info
;
345 if (nfbdev
->helper
.fbdev
) {
346 info
= nfbdev
->helper
.fbdev
;
347 unregister_framebuffer(info
);
349 fb_dealloc_cmap(&info
->cmap
);
350 framebuffer_release(info
);
353 if (nouveau_fb
->nvbo
) {
354 nouveau_bo_unmap(nouveau_fb
->nvbo
);
355 drm_gem_object_unreference_unlocked(nouveau_fb
->nvbo
->gem
);
356 nouveau_fb
->nvbo
= NULL
;
358 drm_fb_helper_fini(&nfbdev
->helper
);
359 drm_framebuffer_cleanup(&nouveau_fb
->base
);
363 void nouveau_fbcon_gpu_lockup(struct fb_info
*info
)
365 struct nouveau_fbdev
*nfbdev
= info
->par
;
366 struct drm_device
*dev
= nfbdev
->dev
;
368 NV_ERROR(dev
, "GPU lockup - switching to software fbcon\n");
369 info
->flags
|= FBINFO_HWACCEL_DISABLED
;
372 static struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs
= {
373 .gamma_set
= nouveau_fbcon_gamma_set
,
374 .gamma_get
= nouveau_fbcon_gamma_get
,
375 .fb_probe
= nouveau_fbcon_find_or_create_single
,
379 int nouveau_fbcon_init(struct drm_device
*dev
)
381 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
382 struct nouveau_fbdev
*nfbdev
;
385 nfbdev
= kzalloc(sizeof(struct nouveau_fbdev
), GFP_KERNEL
);
390 dev_priv
->nfbdev
= nfbdev
;
391 nfbdev
->helper
.funcs
= &nouveau_fbcon_helper_funcs
;
393 ret
= drm_fb_helper_init(dev
, &nfbdev
->helper
,
394 nv_two_heads(dev
) ? 2 : 1, 4);
400 drm_fb_helper_single_add_all_connectors(&nfbdev
->helper
);
401 drm_fb_helper_initial_config(&nfbdev
->helper
, 32);
405 void nouveau_fbcon_fini(struct drm_device
*dev
)
407 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
409 if (!dev_priv
->nfbdev
)
412 nouveau_fbcon_destroy(dev
, dev_priv
->nfbdev
);
413 kfree(dev_priv
->nfbdev
);
414 dev_priv
->nfbdev
= NULL
;
417 void nouveau_fbcon_save_disable_accel(struct drm_device
*dev
)
419 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
421 dev_priv
->nfbdev
->saved_flags
= dev_priv
->nfbdev
->helper
.fbdev
->flags
;
422 dev_priv
->nfbdev
->helper
.fbdev
->flags
|= FBINFO_HWACCEL_DISABLED
;
425 void nouveau_fbcon_restore_accel(struct drm_device
*dev
)
427 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
428 dev_priv
->nfbdev
->helper
.fbdev
->flags
= dev_priv
->nfbdev
->saved_flags
;
431 void nouveau_fbcon_set_suspend(struct drm_device
*dev
, int state
)
433 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
434 fb_set_suspend(dev_priv
->nfbdev
->helper
.fbdev
, state
);
437 void nouveau_fbcon_zfill_all(struct drm_device
*dev
)
439 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
440 nouveau_fbcon_zfill(dev
, dev_priv
->nfbdev
);