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/slab.h>
34 #include <linux/sysrq.h>
35 #include <linux/delay.h>
37 #include <linux/init.h>
38 #include <linux/screen_info.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_fbcon_par
*par
= info
->par
;
56 struct drm_device
*dev
= par
->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_setcolreg
= drm_fb_helper_setcolreg
,
101 .fb_fillrect
= cfb_fillrect
,
102 .fb_copyarea
= cfb_copyarea
,
103 .fb_imageblit
= cfb_imageblit
,
104 .fb_sync
= nouveau_fbcon_sync
,
105 .fb_pan_display
= drm_fb_helper_pan_display
,
106 .fb_blank
= drm_fb_helper_blank
,
107 .fb_setcmap
= drm_fb_helper_setcmap
,
110 static void nouveau_fbcon_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
113 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
115 nv_crtc
->lut
.r
[regno
] = red
;
116 nv_crtc
->lut
.g
[regno
] = green
;
117 nv_crtc
->lut
.b
[regno
] = blue
;
120 static void nouveau_fbcon_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
121 u16
*blue
, int regno
)
123 struct nouveau_crtc
*nv_crtc
= nouveau_crtc(crtc
);
125 *red
= nv_crtc
->lut
.r
[regno
];
126 *green
= nv_crtc
->lut
.g
[regno
];
127 *blue
= nv_crtc
->lut
.b
[regno
];
130 static struct drm_fb_helper_funcs nouveau_fbcon_helper_funcs
= {
131 .gamma_set
= nouveau_fbcon_gamma_set
,
132 .gamma_get
= nouveau_fbcon_gamma_get
135 #if defined(__i386__) || defined(__x86_64__)
137 nouveau_fbcon_has_vesafb_or_efifb(struct drm_device
*dev
)
139 struct pci_dev
*pdev
= dev
->pdev
;
142 if (screen_info
.orig_video_isVGA
!= VIDEO_TYPE_VLFB
&&
143 screen_info
.orig_video_isVGA
!= VIDEO_TYPE_EFI
)
146 if (screen_info
.lfb_base
< pci_resource_start(pdev
, 1))
149 if (screen_info
.lfb_base
+ screen_info
.lfb_size
>=
150 pci_resource_start(pdev
, 1) + pci_resource_len(pdev
, 1))
156 if (pci_resource_len(pdev
, ramin
) == 0) {
158 if (pci_resource_len(pdev
, ramin
) == 0)
162 if (screen_info
.lfb_base
< pci_resource_start(pdev
, ramin
))
165 if (screen_info
.lfb_base
+ screen_info
.lfb_size
>=
166 pci_resource_start(pdev
, ramin
) + pci_resource_len(pdev
, ramin
))
174 nouveau_fbcon_zfill(struct drm_device
*dev
)
176 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
177 struct fb_info
*info
= dev_priv
->fbdev_info
;
178 struct fb_fillrect rect
;
180 /* Clear the entire fbcon. The drm will program every connector
181 * with it's preferred mode. If the sizes differ, one display will
182 * quite likely have garbage around the console.
184 rect
.dx
= rect
.dy
= 0;
185 rect
.width
= info
->var
.xres_virtual
;
186 rect
.height
= info
->var
.yres_virtual
;
189 info
->fbops
->fb_fillrect(info
, &rect
);
193 nouveau_fbcon_create(struct drm_device
*dev
, uint32_t fb_width
,
194 uint32_t fb_height
, uint32_t surface_width
,
195 uint32_t surface_height
, uint32_t surface_depth
,
196 uint32_t surface_bpp
, struct drm_framebuffer
**pfb
)
198 struct drm_nouveau_private
*dev_priv
= dev
->dev_private
;
199 struct fb_info
*info
;
200 struct nouveau_fbcon_par
*par
;
201 struct drm_framebuffer
*fb
;
202 struct nouveau_framebuffer
*nouveau_fb
;
203 struct nouveau_bo
*nvbo
;
204 struct drm_mode_fb_cmd mode_cmd
;
205 struct device
*device
= &dev
->pdev
->dev
;
208 mode_cmd
.width
= surface_width
;
209 mode_cmd
.height
= surface_height
;
211 mode_cmd
.bpp
= surface_bpp
;
212 mode_cmd
.pitch
= mode_cmd
.width
* (mode_cmd
.bpp
>> 3);
213 mode_cmd
.pitch
= roundup(mode_cmd
.pitch
, 256);
214 mode_cmd
.depth
= surface_depth
;
216 size
= mode_cmd
.pitch
* mode_cmd
.height
;
217 size
= roundup(size
, PAGE_SIZE
);
219 ret
= nouveau_gem_new(dev
, dev_priv
->channel
, size
, 0, TTM_PL_FLAG_VRAM
,
220 0, 0x0000, false, true, &nvbo
);
222 NV_ERROR(dev
, "failed to allocate framebuffer\n");
226 ret
= nouveau_bo_pin(nvbo
, TTM_PL_FLAG_VRAM
);
228 NV_ERROR(dev
, "failed to pin fb: %d\n", ret
);
229 nouveau_bo_ref(NULL
, &nvbo
);
233 ret
= nouveau_bo_map(nvbo
);
235 NV_ERROR(dev
, "failed to map fb: %d\n", ret
);
236 nouveau_bo_unpin(nvbo
);
237 nouveau_bo_ref(NULL
, &nvbo
);
241 mutex_lock(&dev
->struct_mutex
);
243 fb
= nouveau_framebuffer_create(dev
, nvbo
, &mode_cmd
);
246 NV_ERROR(dev
, "failed to allocate fb.\n");
250 list_add(&fb
->filp_head
, &dev
->mode_config
.fb_kernel_list
);
252 nouveau_fb
= nouveau_framebuffer(fb
);
255 info
= framebuffer_alloc(sizeof(struct nouveau_fbcon_par
), device
);
262 par
->helper
.funcs
= &nouveau_fbcon_helper_funcs
;
263 par
->helper
.dev
= dev
;
264 ret
= drm_fb_helper_init_crtc_count(&par
->helper
, 2, 4);
267 dev_priv
->fbdev_info
= info
;
269 strcpy(info
->fix
.id
, "nouveaufb");
270 info
->flags
= FBINFO_DEFAULT
| FBINFO_HWACCEL_COPYAREA
|
271 FBINFO_HWACCEL_FILLRECT
| FBINFO_HWACCEL_IMAGEBLIT
;
272 info
->fbops
= &nouveau_fbcon_ops
;
273 info
->fix
.smem_start
= dev
->mode_config
.fb_base
+ nvbo
->bo
.offset
-
274 dev_priv
->vm_vram_base
;
275 info
->fix
.smem_len
= size
;
277 info
->screen_base
= nvbo_kmap_obj_iovirtual(nouveau_fb
->nvbo
);
278 info
->screen_size
= size
;
280 drm_fb_helper_fill_fix(info
, fb
->pitch
, fb
->depth
);
281 drm_fb_helper_fill_var(info
, fb
, fb_width
, fb_height
);
283 /* FIXME: we really shouldn't expose mmio space at all */
284 info
->fix
.mmio_start
= pci_resource_start(dev
->pdev
, 1);
285 info
->fix
.mmio_len
= pci_resource_len(dev
->pdev
, 1);
287 /* Set aperture base/size for vesafb takeover */
288 #if defined(__i386__) || defined(__x86_64__)
289 if (nouveau_fbcon_has_vesafb_or_efifb(dev
)) {
290 /* Some NVIDIA VBIOS' are stupid and decide to put the
291 * framebuffer in the middle of the PRAMIN BAR for
292 * whatever reason. We need to know the exact lfb_base
293 * to get vesafb kicked off, and the only reliable way
294 * we have left is to find out lfb_base the same way
297 info
->aperture_base
= screen_info
.lfb_base
;
298 info
->aperture_size
= screen_info
.lfb_size
;
299 if (screen_info
.orig_video_isVGA
== VIDEO_TYPE_VLFB
)
300 info
->aperture_size
*= 65536;
304 info
->aperture_base
= info
->fix
.mmio_start
;
305 info
->aperture_size
= info
->fix
.mmio_len
;
308 info
->pixmap
.size
= 64*1024;
309 info
->pixmap
.buf_align
= 8;
310 info
->pixmap
.access_align
= 32;
311 info
->pixmap
.flags
= FB_PIXMAP_SYSTEM
;
312 info
->pixmap
.scan_align
= 1;
316 par
->nouveau_fb
= nouveau_fb
;
319 if (dev_priv
->channel
) {
320 switch (dev_priv
->card_type
) {
322 nv50_fbcon_accel_init(info
);
325 nv04_fbcon_accel_init(info
);
330 nouveau_fbcon_zfill(dev
);
332 /* To allow resizeing without swapping buffers */
333 NV_INFO(dev
, "allocated %dx%d fb: 0x%lx, bo %p\n",
334 nouveau_fb
->base
.width
,
335 nouveau_fb
->base
.height
,
336 nvbo
->bo
.offset
, nvbo
);
338 mutex_unlock(&dev
->struct_mutex
);
342 mutex_unlock(&dev
->struct_mutex
);
348 nouveau_fbcon_probe(struct drm_device
*dev
)
350 NV_DEBUG_KMS(dev
, "\n");
352 return drm_fb_helper_single_fb_probe(dev
, 32, nouveau_fbcon_create
);
356 nouveau_fbcon_remove(struct drm_device
*dev
, struct drm_framebuffer
*fb
)
358 struct nouveau_framebuffer
*nouveau_fb
= nouveau_framebuffer(fb
);
359 struct fb_info
*info
;
366 struct nouveau_fbcon_par
*par
= info
->par
;
368 unregister_framebuffer(info
);
369 nouveau_bo_unmap(nouveau_fb
->nvbo
);
370 mutex_lock(&dev
->struct_mutex
);
371 drm_gem_object_unreference(nouveau_fb
->nvbo
->gem
);
372 nouveau_fb
->nvbo
= NULL
;
373 mutex_unlock(&dev
->struct_mutex
);
375 drm_fb_helper_free(&par
->helper
);
376 framebuffer_release(info
);
382 void nouveau_fbcon_gpu_lockup(struct fb_info
*info
)
384 struct nouveau_fbcon_par
*par
= info
->par
;
385 struct drm_device
*dev
= par
->dev
;
387 NV_ERROR(dev
, "GPU lockup - switching to software fbcon\n");
388 info
->flags
|= FBINFO_HWACCEL_DISABLED
;