Loading...
Note: File does not exist in v3.1.
1/*
2 * Copyright © 2007 David Airlie
3 *
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:
10 *
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
13 * Software.
14 *
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.
22 *
23 * Authors:
24 * David Airlie
25 */
26
27#include <linux/async.h>
28#include <linux/module.h>
29#include <linux/kernel.h>
30#include <linux/console.h>
31#include <linux/errno.h>
32#include <linux/string.h>
33#include <linux/mm.h>
34#include <linux/tty.h>
35#include <linux/sysrq.h>
36#include <linux/delay.h>
37#include <linux/init.h>
38#include <linux/vga_switcheroo.h>
39
40#include <drm/drmP.h>
41#include <drm/drm_crtc.h>
42#include <drm/drm_fb_helper.h>
43#include "intel_drv.h"
44#include "intel_frontbuffer.h"
45#include <drm/i915_drm.h>
46#include "i915_drv.h"
47
48static int intel_fbdev_set_par(struct fb_info *info)
49{
50 struct drm_fb_helper *fb_helper = info->par;
51 struct intel_fbdev *ifbdev =
52 container_of(fb_helper, struct intel_fbdev, helper);
53 int ret;
54
55 ret = drm_fb_helper_set_par(info);
56
57 if (ret == 0) {
58 mutex_lock(&fb_helper->dev->struct_mutex);
59 intel_fb_obj_invalidate(ifbdev->fb->obj, ORIGIN_GTT);
60 mutex_unlock(&fb_helper->dev->struct_mutex);
61 }
62
63 return ret;
64}
65
66static int intel_fbdev_blank(int blank, struct fb_info *info)
67{
68 struct drm_fb_helper *fb_helper = info->par;
69 struct intel_fbdev *ifbdev =
70 container_of(fb_helper, struct intel_fbdev, helper);
71 int ret;
72
73 ret = drm_fb_helper_blank(blank, info);
74
75 if (ret == 0) {
76 mutex_lock(&fb_helper->dev->struct_mutex);
77 intel_fb_obj_invalidate(ifbdev->fb->obj, ORIGIN_GTT);
78 mutex_unlock(&fb_helper->dev->struct_mutex);
79 }
80
81 return ret;
82}
83
84static int intel_fbdev_pan_display(struct fb_var_screeninfo *var,
85 struct fb_info *info)
86{
87 struct drm_fb_helper *fb_helper = info->par;
88 struct intel_fbdev *ifbdev =
89 container_of(fb_helper, struct intel_fbdev, helper);
90
91 int ret;
92 ret = drm_fb_helper_pan_display(var, info);
93
94 if (ret == 0) {
95 mutex_lock(&fb_helper->dev->struct_mutex);
96 intel_fb_obj_invalidate(ifbdev->fb->obj, ORIGIN_GTT);
97 mutex_unlock(&fb_helper->dev->struct_mutex);
98 }
99
100 return ret;
101}
102
103static struct fb_ops intelfb_ops = {
104 .owner = THIS_MODULE,
105 DRM_FB_HELPER_DEFAULT_OPS,
106 .fb_set_par = intel_fbdev_set_par,
107 .fb_fillrect = drm_fb_helper_cfb_fillrect,
108 .fb_copyarea = drm_fb_helper_cfb_copyarea,
109 .fb_imageblit = drm_fb_helper_cfb_imageblit,
110 .fb_pan_display = intel_fbdev_pan_display,
111 .fb_blank = intel_fbdev_blank,
112};
113
114static int intelfb_alloc(struct drm_fb_helper *helper,
115 struct drm_fb_helper_surface_size *sizes)
116{
117 struct intel_fbdev *ifbdev =
118 container_of(helper, struct intel_fbdev, helper);
119 struct drm_framebuffer *fb;
120 struct drm_device *dev = helper->dev;
121 struct drm_i915_private *dev_priv = to_i915(dev);
122 struct i915_ggtt *ggtt = &dev_priv->ggtt;
123 struct drm_mode_fb_cmd2 mode_cmd = {};
124 struct drm_i915_gem_object *obj = NULL;
125 int size, ret;
126
127 /* we don't do packed 24bpp */
128 if (sizes->surface_bpp == 24)
129 sizes->surface_bpp = 32;
130
131 mode_cmd.width = sizes->surface_width;
132 mode_cmd.height = sizes->surface_height;
133
134 mode_cmd.pitches[0] = ALIGN(mode_cmd.width *
135 DIV_ROUND_UP(sizes->surface_bpp, 8), 64);
136 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
137 sizes->surface_depth);
138
139 mutex_lock(&dev->struct_mutex);
140
141 size = mode_cmd.pitches[0] * mode_cmd.height;
142 size = PAGE_ALIGN(size);
143
144 /* If the FB is too big, just don't use it since fbdev is not very
145 * important and we should probably use that space with FBC or other
146 * features. */
147 if (size * 2 < ggtt->stolen_usable_size)
148 obj = i915_gem_object_create_stolen(dev, size);
149 if (obj == NULL)
150 obj = i915_gem_object_create(dev, size);
151 if (IS_ERR(obj)) {
152 DRM_ERROR("failed to allocate framebuffer\n");
153 ret = PTR_ERR(obj);
154 goto out;
155 }
156
157 fb = __intel_framebuffer_create(dev, &mode_cmd, obj);
158 if (IS_ERR(fb)) {
159 i915_gem_object_put(obj);
160 ret = PTR_ERR(fb);
161 goto out;
162 }
163
164 mutex_unlock(&dev->struct_mutex);
165
166 ifbdev->fb = to_intel_framebuffer(fb);
167
168 return 0;
169
170out:
171 mutex_unlock(&dev->struct_mutex);
172 return ret;
173}
174
175static int intelfb_create(struct drm_fb_helper *helper,
176 struct drm_fb_helper_surface_size *sizes)
177{
178 struct intel_fbdev *ifbdev =
179 container_of(helper, struct intel_fbdev, helper);
180 struct intel_framebuffer *intel_fb = ifbdev->fb;
181 struct drm_device *dev = helper->dev;
182 struct drm_i915_private *dev_priv = to_i915(dev);
183 struct pci_dev *pdev = dev_priv->drm.pdev;
184 struct i915_ggtt *ggtt = &dev_priv->ggtt;
185 struct fb_info *info;
186 struct drm_framebuffer *fb;
187 struct i915_vma *vma;
188 bool prealloc = false;
189 void __iomem *vaddr;
190 int ret;
191
192 if (intel_fb &&
193 (sizes->fb_width > intel_fb->base.width ||
194 sizes->fb_height > intel_fb->base.height)) {
195 DRM_DEBUG_KMS("BIOS fb too small (%dx%d), we require (%dx%d),"
196 " releasing it\n",
197 intel_fb->base.width, intel_fb->base.height,
198 sizes->fb_width, sizes->fb_height);
199 drm_framebuffer_unreference(&intel_fb->base);
200 intel_fb = ifbdev->fb = NULL;
201 }
202 if (!intel_fb || WARN_ON(!intel_fb->obj)) {
203 DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
204 ret = intelfb_alloc(helper, sizes);
205 if (ret)
206 return ret;
207 intel_fb = ifbdev->fb;
208 } else {
209 DRM_DEBUG_KMS("re-using BIOS fb\n");
210 prealloc = true;
211 sizes->fb_width = intel_fb->base.width;
212 sizes->fb_height = intel_fb->base.height;
213 }
214
215 mutex_lock(&dev->struct_mutex);
216
217 /* Pin the GGTT vma for our access via info->screen_base.
218 * This also validates that any existing fb inherited from the
219 * BIOS is suitable for own access.
220 */
221 vma = intel_pin_and_fence_fb_obj(&ifbdev->fb->base, DRM_ROTATE_0);
222 if (IS_ERR(vma)) {
223 ret = PTR_ERR(vma);
224 goto out_unlock;
225 }
226
227 info = drm_fb_helper_alloc_fbi(helper);
228 if (IS_ERR(info)) {
229 DRM_ERROR("Failed to allocate fb_info\n");
230 ret = PTR_ERR(info);
231 goto out_unpin;
232 }
233
234 info->par = helper;
235
236 fb = &ifbdev->fb->base;
237
238 ifbdev->helper.fb = fb;
239
240 strcpy(info->fix.id, "inteldrmfb");
241
242 info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
243 info->fbops = &intelfb_ops;
244
245 /* setup aperture base/size for vesafb takeover */
246 info->apertures->ranges[0].base = dev->mode_config.fb_base;
247 info->apertures->ranges[0].size = ggtt->mappable_end;
248
249 info->fix.smem_start = dev->mode_config.fb_base + i915_ggtt_offset(vma);
250 info->fix.smem_len = vma->node.size;
251
252 vaddr = i915_vma_pin_iomap(vma);
253 if (IS_ERR(vaddr)) {
254 DRM_ERROR("Failed to remap framebuffer into virtual memory\n");
255 ret = PTR_ERR(vaddr);
256 goto out_destroy_fbi;
257 }
258 info->screen_base = vaddr;
259 info->screen_size = vma->node.size;
260
261 /* This driver doesn't need a VT switch to restore the mode on resume */
262 info->skip_vt_switch = true;
263
264 drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
265 drm_fb_helper_fill_var(info, &ifbdev->helper, sizes->fb_width, sizes->fb_height);
266
267 /* If the object is shmemfs backed, it will have given us zeroed pages.
268 * If the object is stolen however, it will be full of whatever
269 * garbage was left in there.
270 */
271 if (intel_fb->obj->stolen && !prealloc)
272 memset_io(info->screen_base, 0, info->screen_size);
273
274 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
275
276 DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08x\n",
277 fb->width, fb->height, i915_ggtt_offset(vma));
278 ifbdev->vma = vma;
279
280 mutex_unlock(&dev->struct_mutex);
281 vga_switcheroo_client_fb_set(pdev, info);
282 return 0;
283
284out_destroy_fbi:
285 drm_fb_helper_release_fbi(helper);
286out_unpin:
287 intel_unpin_fb_vma(vma);
288out_unlock:
289 mutex_unlock(&dev->struct_mutex);
290 return ret;
291}
292
293/** Sets the color ramps on behalf of RandR */
294static void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
295 u16 blue, int regno)
296{
297 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
298
299 intel_crtc->lut_r[regno] = red >> 8;
300 intel_crtc->lut_g[regno] = green >> 8;
301 intel_crtc->lut_b[regno] = blue >> 8;
302}
303
304static void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
305 u16 *blue, int regno)
306{
307 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
308
309 *red = intel_crtc->lut_r[regno] << 8;
310 *green = intel_crtc->lut_g[regno] << 8;
311 *blue = intel_crtc->lut_b[regno] << 8;
312}
313
314static struct drm_fb_helper_crtc *
315intel_fb_helper_crtc(struct drm_fb_helper *fb_helper, struct drm_crtc *crtc)
316{
317 int i;
318
319 for (i = 0; i < fb_helper->crtc_count; i++)
320 if (fb_helper->crtc_info[i].mode_set.crtc == crtc)
321 return &fb_helper->crtc_info[i];
322
323 return NULL;
324}
325
326/*
327 * Try to read the BIOS display configuration and use it for the initial
328 * fb configuration.
329 *
330 * The BIOS or boot loader will generally create an initial display
331 * configuration for us that includes some set of active pipes and displays.
332 * This routine tries to figure out which pipes and connectors are active
333 * and stuffs them into the crtcs and modes array given to us by the
334 * drm_fb_helper code.
335 *
336 * The overall sequence is:
337 * intel_fbdev_init - from driver load
338 * intel_fbdev_init_bios - initialize the intel_fbdev using BIOS data
339 * drm_fb_helper_init - build fb helper structs
340 * drm_fb_helper_single_add_all_connectors - more fb helper structs
341 * intel_fbdev_initial_config - apply the config
342 * drm_fb_helper_initial_config - call ->probe then register_framebuffer()
343 * drm_setup_crtcs - build crtc config for fbdev
344 * intel_fb_initial_config - find active connectors etc
345 * drm_fb_helper_single_fb_probe - set up fbdev
346 * intelfb_create - re-use or alloc fb, build out fbdev structs
347 *
348 * Note that we don't make special consideration whether we could actually
349 * switch to the selected modes without a full modeset. E.g. when the display
350 * is in VGA mode we need to recalculate watermarks and set a new high-res
351 * framebuffer anyway.
352 */
353static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper,
354 struct drm_fb_helper_crtc **crtcs,
355 struct drm_display_mode **modes,
356 struct drm_fb_offset *offsets,
357 bool *enabled, int width, int height)
358{
359 struct drm_i915_private *dev_priv = to_i915(fb_helper->dev);
360 unsigned long conn_configured, conn_seq, mask;
361 unsigned int count = min(fb_helper->connector_count, BITS_PER_LONG);
362 int i, j;
363 bool *save_enabled;
364 bool fallback = true;
365 int num_connectors_enabled = 0;
366 int num_connectors_detected = 0;
367
368 save_enabled = kcalloc(count, sizeof(bool), GFP_KERNEL);
369 if (!save_enabled)
370 return false;
371
372 memcpy(save_enabled, enabled, count);
373 mask = BIT(count) - 1;
374 conn_configured = 0;
375retry:
376 conn_seq = conn_configured;
377 for (i = 0; i < count; i++) {
378 struct drm_fb_helper_connector *fb_conn;
379 struct drm_connector *connector;
380 struct drm_encoder *encoder;
381 struct drm_fb_helper_crtc *new_crtc;
382 struct intel_crtc *intel_crtc;
383
384 fb_conn = fb_helper->connector_info[i];
385 connector = fb_conn->connector;
386
387 if (conn_configured & BIT(i))
388 continue;
389
390 if (conn_seq == 0 && !connector->has_tile)
391 continue;
392
393 if (connector->status == connector_status_connected)
394 num_connectors_detected++;
395
396 if (!enabled[i]) {
397 DRM_DEBUG_KMS("connector %s not enabled, skipping\n",
398 connector->name);
399 conn_configured |= BIT(i);
400 continue;
401 }
402
403 if (connector->force == DRM_FORCE_OFF) {
404 DRM_DEBUG_KMS("connector %s is disabled by user, skipping\n",
405 connector->name);
406 enabled[i] = false;
407 continue;
408 }
409
410 encoder = connector->state->best_encoder;
411 if (!encoder || WARN_ON(!connector->state->crtc)) {
412 if (connector->force > DRM_FORCE_OFF)
413 goto bail;
414
415 DRM_DEBUG_KMS("connector %s has no encoder or crtc, skipping\n",
416 connector->name);
417 enabled[i] = false;
418 conn_configured |= BIT(i);
419 continue;
420 }
421
422 num_connectors_enabled++;
423
424 intel_crtc = to_intel_crtc(connector->state->crtc);
425 for (j = 0; j < 256; j++) {
426 intel_crtc->lut_r[j] = j;
427 intel_crtc->lut_g[j] = j;
428 intel_crtc->lut_b[j] = j;
429 }
430
431 new_crtc = intel_fb_helper_crtc(fb_helper,
432 connector->state->crtc);
433
434 /*
435 * Make sure we're not trying to drive multiple connectors
436 * with a single CRTC, since our cloning support may not
437 * match the BIOS.
438 */
439 for (j = 0; j < count; j++) {
440 if (crtcs[j] == new_crtc) {
441 DRM_DEBUG_KMS("fallback: cloned configuration\n");
442 goto bail;
443 }
444 }
445
446 DRM_DEBUG_KMS("looking for cmdline mode on connector %s\n",
447 connector->name);
448
449 /* go for command line mode first */
450 modes[i] = drm_pick_cmdline_mode(fb_conn, width, height);
451
452 /* try for preferred next */
453 if (!modes[i]) {
454 DRM_DEBUG_KMS("looking for preferred mode on connector %s %d\n",
455 connector->name, connector->has_tile);
456 modes[i] = drm_has_preferred_mode(fb_conn, width,
457 height);
458 }
459
460 /* No preferred mode marked by the EDID? Are there any modes? */
461 if (!modes[i] && !list_empty(&connector->modes)) {
462 DRM_DEBUG_KMS("using first mode listed on connector %s\n",
463 connector->name);
464 modes[i] = list_first_entry(&connector->modes,
465 struct drm_display_mode,
466 head);
467 }
468
469 /* last resort: use current mode */
470 if (!modes[i]) {
471 /*
472 * IMPORTANT: We want to use the adjusted mode (i.e.
473 * after the panel fitter upscaling) as the initial
474 * config, not the input mode, which is what crtc->mode
475 * usually contains. But since our current
476 * code puts a mode derived from the post-pfit timings
477 * into crtc->mode this works out correctly.
478 *
479 * This is crtc->mode and not crtc->state->mode for the
480 * fastboot check to work correctly. crtc_state->mode has
481 * I915_MODE_FLAG_INHERITED, which we clear to force check
482 * state.
483 */
484 DRM_DEBUG_KMS("looking for current mode on connector %s\n",
485 connector->name);
486 modes[i] = &connector->state->crtc->mode;
487 }
488 crtcs[i] = new_crtc;
489
490 DRM_DEBUG_KMS("connector %s on [CRTC:%d:%s]: %dx%d%s\n",
491 connector->name,
492 connector->state->crtc->base.id,
493 connector->state->crtc->name,
494 modes[i]->hdisplay, modes[i]->vdisplay,
495 modes[i]->flags & DRM_MODE_FLAG_INTERLACE ? "i" :"");
496
497 fallback = false;
498 conn_configured |= BIT(i);
499 }
500
501 if ((conn_configured & mask) != mask && conn_configured != conn_seq)
502 goto retry;
503
504 /*
505 * If the BIOS didn't enable everything it could, fall back to have the
506 * same user experiencing of lighting up as much as possible like the
507 * fbdev helper library.
508 */
509 if (num_connectors_enabled != num_connectors_detected &&
510 num_connectors_enabled < INTEL_INFO(dev_priv)->num_pipes) {
511 DRM_DEBUG_KMS("fallback: Not all outputs enabled\n");
512 DRM_DEBUG_KMS("Enabled: %i, detected: %i\n", num_connectors_enabled,
513 num_connectors_detected);
514 fallback = true;
515 }
516
517 if (fallback) {
518bail:
519 DRM_DEBUG_KMS("Not using firmware configuration\n");
520 memcpy(enabled, save_enabled, count);
521 kfree(save_enabled);
522 return false;
523 }
524
525 kfree(save_enabled);
526 return true;
527}
528
529static const struct drm_fb_helper_funcs intel_fb_helper_funcs = {
530 .initial_config = intel_fb_initial_config,
531 .gamma_set = intel_crtc_fb_gamma_set,
532 .gamma_get = intel_crtc_fb_gamma_get,
533 .fb_probe = intelfb_create,
534};
535
536static void intel_fbdev_destroy(struct intel_fbdev *ifbdev)
537{
538 /* We rely on the object-free to release the VMA pinning for
539 * the info->screen_base mmaping. Leaking the VMA is simpler than
540 * trying to rectify all the possible error paths leading here.
541 */
542
543 drm_fb_helper_unregister_fbi(&ifbdev->helper);
544 drm_fb_helper_release_fbi(&ifbdev->helper);
545
546 drm_fb_helper_fini(&ifbdev->helper);
547
548 if (ifbdev->fb) {
549 mutex_lock(&ifbdev->helper.dev->struct_mutex);
550 intel_unpin_fb_vma(ifbdev->vma);
551 mutex_unlock(&ifbdev->helper.dev->struct_mutex);
552
553 drm_framebuffer_remove(&ifbdev->fb->base);
554 }
555
556 kfree(ifbdev);
557}
558
559/*
560 * Build an intel_fbdev struct using a BIOS allocated framebuffer, if possible.
561 * The core display code will have read out the current plane configuration,
562 * so we use that to figure out if there's an object for us to use as the
563 * fb, and if so, we re-use it for the fbdev configuration.
564 *
565 * Note we only support a single fb shared across pipes for boot (mostly for
566 * fbcon), so we just find the biggest and use that.
567 */
568static bool intel_fbdev_init_bios(struct drm_device *dev,
569 struct intel_fbdev *ifbdev)
570{
571 struct intel_framebuffer *fb = NULL;
572 struct drm_crtc *crtc;
573 struct intel_crtc *intel_crtc;
574 unsigned int max_size = 0;
575
576 /* Find the largest fb */
577 for_each_crtc(dev, crtc) {
578 struct drm_i915_gem_object *obj =
579 intel_fb_obj(crtc->primary->state->fb);
580 intel_crtc = to_intel_crtc(crtc);
581
582 if (!crtc->state->active || !obj) {
583 DRM_DEBUG_KMS("pipe %c not active or no fb, skipping\n",
584 pipe_name(intel_crtc->pipe));
585 continue;
586 }
587
588 if (obj->base.size > max_size) {
589 DRM_DEBUG_KMS("found possible fb from plane %c\n",
590 pipe_name(intel_crtc->pipe));
591 fb = to_intel_framebuffer(crtc->primary->state->fb);
592 max_size = obj->base.size;
593 }
594 }
595
596 if (!fb) {
597 DRM_DEBUG_KMS("no active fbs found, not using BIOS config\n");
598 goto out;
599 }
600
601 /* Now make sure all the pipes will fit into it */
602 for_each_crtc(dev, crtc) {
603 unsigned int cur_size;
604
605 intel_crtc = to_intel_crtc(crtc);
606
607 if (!crtc->state->active) {
608 DRM_DEBUG_KMS("pipe %c not active, skipping\n",
609 pipe_name(intel_crtc->pipe));
610 continue;
611 }
612
613 DRM_DEBUG_KMS("checking plane %c for BIOS fb\n",
614 pipe_name(intel_crtc->pipe));
615
616 /*
617 * See if the plane fb we found above will fit on this
618 * pipe. Note we need to use the selected fb's pitch and bpp
619 * rather than the current pipe's, since they differ.
620 */
621 cur_size = intel_crtc->config->base.adjusted_mode.crtc_hdisplay;
622 cur_size = cur_size * fb->base.bits_per_pixel / 8;
623 if (fb->base.pitches[0] < cur_size) {
624 DRM_DEBUG_KMS("fb not wide enough for plane %c (%d vs %d)\n",
625 pipe_name(intel_crtc->pipe),
626 cur_size, fb->base.pitches[0]);
627 fb = NULL;
628 break;
629 }
630
631 cur_size = intel_crtc->config->base.adjusted_mode.crtc_vdisplay;
632 cur_size = intel_fb_align_height(dev, cur_size,
633 fb->base.pixel_format,
634 fb->base.modifier);
635 cur_size *= fb->base.pitches[0];
636 DRM_DEBUG_KMS("pipe %c area: %dx%d, bpp: %d, size: %d\n",
637 pipe_name(intel_crtc->pipe),
638 intel_crtc->config->base.adjusted_mode.crtc_hdisplay,
639 intel_crtc->config->base.adjusted_mode.crtc_vdisplay,
640 fb->base.bits_per_pixel,
641 cur_size);
642
643 if (cur_size > max_size) {
644 DRM_DEBUG_KMS("fb not big enough for plane %c (%d vs %d)\n",
645 pipe_name(intel_crtc->pipe),
646 cur_size, max_size);
647 fb = NULL;
648 break;
649 }
650
651 DRM_DEBUG_KMS("fb big enough for plane %c (%d >= %d)\n",
652 pipe_name(intel_crtc->pipe),
653 max_size, cur_size);
654 }
655
656 if (!fb) {
657 DRM_DEBUG_KMS("BIOS fb not suitable for all pipes, not using\n");
658 goto out;
659 }
660
661 ifbdev->preferred_bpp = fb->base.bits_per_pixel;
662 ifbdev->fb = fb;
663
664 drm_framebuffer_reference(&ifbdev->fb->base);
665
666 /* Final pass to check if any active pipes don't have fbs */
667 for_each_crtc(dev, crtc) {
668 intel_crtc = to_intel_crtc(crtc);
669
670 if (!crtc->state->active)
671 continue;
672
673 WARN(!crtc->primary->fb,
674 "re-used BIOS config but lost an fb on crtc %d\n",
675 crtc->base.id);
676 }
677
678
679 DRM_DEBUG_KMS("using BIOS fb for initial console\n");
680 return true;
681
682out:
683
684 return false;
685}
686
687static void intel_fbdev_suspend_worker(struct work_struct *work)
688{
689 intel_fbdev_set_suspend(&container_of(work,
690 struct drm_i915_private,
691 fbdev_suspend_work)->drm,
692 FBINFO_STATE_RUNNING,
693 true);
694}
695
696int intel_fbdev_init(struct drm_device *dev)
697{
698 struct drm_i915_private *dev_priv = to_i915(dev);
699 struct intel_fbdev *ifbdev;
700 int ret;
701
702 if (WARN_ON(INTEL_INFO(dev_priv)->num_pipes == 0))
703 return -ENODEV;
704
705 ifbdev = kzalloc(sizeof(struct intel_fbdev), GFP_KERNEL);
706 if (ifbdev == NULL)
707 return -ENOMEM;
708
709 drm_fb_helper_prepare(dev, &ifbdev->helper, &intel_fb_helper_funcs);
710
711 if (!intel_fbdev_init_bios(dev, ifbdev))
712 ifbdev->preferred_bpp = 32;
713
714 ret = drm_fb_helper_init(dev, &ifbdev->helper,
715 INTEL_INFO(dev_priv)->num_pipes, 4);
716 if (ret) {
717 kfree(ifbdev);
718 return ret;
719 }
720
721 dev_priv->fbdev = ifbdev;
722 INIT_WORK(&dev_priv->fbdev_suspend_work, intel_fbdev_suspend_worker);
723
724 drm_fb_helper_single_add_all_connectors(&ifbdev->helper);
725
726 return 0;
727}
728
729static void intel_fbdev_initial_config(void *data, async_cookie_t cookie)
730{
731 struct intel_fbdev *ifbdev = data;
732
733 /* Due to peculiar init order wrt to hpd handling this is separate. */
734 if (drm_fb_helper_initial_config(&ifbdev->helper,
735 ifbdev->preferred_bpp))
736 intel_fbdev_fini(ifbdev->helper.dev);
737}
738
739void intel_fbdev_initial_config_async(struct drm_device *dev)
740{
741 struct intel_fbdev *ifbdev = to_i915(dev)->fbdev;
742
743 if (!ifbdev)
744 return;
745
746 ifbdev->cookie = async_schedule(intel_fbdev_initial_config, ifbdev);
747}
748
749static void intel_fbdev_sync(struct intel_fbdev *ifbdev)
750{
751 if (!ifbdev->cookie)
752 return;
753
754 /* Only serialises with all preceding async calls, hence +1 */
755 async_synchronize_cookie(ifbdev->cookie + 1);
756 ifbdev->cookie = 0;
757}
758
759void intel_fbdev_fini(struct drm_device *dev)
760{
761 struct drm_i915_private *dev_priv = to_i915(dev);
762 struct intel_fbdev *ifbdev = dev_priv->fbdev;
763
764 if (!ifbdev)
765 return;
766
767 cancel_work_sync(&dev_priv->fbdev_suspend_work);
768 if (!current_is_async())
769 intel_fbdev_sync(ifbdev);
770
771 intel_fbdev_destroy(ifbdev);
772 dev_priv->fbdev = NULL;
773}
774
775void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous)
776{
777 struct drm_i915_private *dev_priv = to_i915(dev);
778 struct intel_fbdev *ifbdev = dev_priv->fbdev;
779 struct fb_info *info;
780
781 if (!ifbdev || !ifbdev->fb)
782 return;
783
784 info = ifbdev->helper.fbdev;
785
786 if (synchronous) {
787 /* Flush any pending work to turn the console on, and then
788 * wait to turn it off. It must be synchronous as we are
789 * about to suspend or unload the driver.
790 *
791 * Note that from within the work-handler, we cannot flush
792 * ourselves, so only flush outstanding work upon suspend!
793 */
794 if (state != FBINFO_STATE_RUNNING)
795 flush_work(&dev_priv->fbdev_suspend_work);
796 console_lock();
797 } else {
798 /*
799 * The console lock can be pretty contented on resume due
800 * to all the printk activity. Try to keep it out of the hot
801 * path of resume if possible.
802 */
803 WARN_ON(state != FBINFO_STATE_RUNNING);
804 if (!console_trylock()) {
805 /* Don't block our own workqueue as this can
806 * be run in parallel with other i915.ko tasks.
807 */
808 schedule_work(&dev_priv->fbdev_suspend_work);
809 return;
810 }
811 }
812
813 /* On resume from hibernation: If the object is shmemfs backed, it has
814 * been restored from swap. If the object is stolen however, it will be
815 * full of whatever garbage was left in there.
816 */
817 if (state == FBINFO_STATE_RUNNING && ifbdev->fb->obj->stolen)
818 memset_io(info->screen_base, 0, info->screen_size);
819
820 drm_fb_helper_set_suspend(&ifbdev->helper, state);
821 console_unlock();
822}
823
824void intel_fbdev_output_poll_changed(struct drm_device *dev)
825{
826 struct intel_fbdev *ifbdev = to_i915(dev)->fbdev;
827
828 if (ifbdev && ifbdev->fb)
829 drm_fb_helper_hotplug_event(&ifbdev->helper);
830}
831
832void intel_fbdev_restore_mode(struct drm_device *dev)
833{
834 struct intel_fbdev *ifbdev = to_i915(dev)->fbdev;
835
836 if (!ifbdev)
837 return;
838
839 intel_fbdev_sync(ifbdev);
840 if (!ifbdev->fb)
841 return;
842
843 if (drm_fb_helper_restore_fbdev_mode_unlocked(&ifbdev->helper)) {
844 DRM_DEBUG("failed to restore crtc mode\n");
845 } else {
846 mutex_lock(&dev->struct_mutex);
847 intel_fb_obj_invalidate(ifbdev->fb->obj, ORIGIN_GTT);
848 mutex_unlock(&dev->struct_mutex);
849 }
850}