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