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.
28 #include <linux/async.h>
29 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
32 #include <linux/string.h>
34 #include <linux/delay.h>
38 #include <drm/drm_crtc.h>
39 #include <drm/drm_fb_helper.h>
40 #include "intel_drv.h"
41 #include <drm/i915_drm.h>
44 static int intel_fbdev_set_par(struct fb_info
*info
)
46 struct drm_fb_helper
*fb_helper
= info
->par
;
47 struct intel_fbdev
*ifbdev
=
48 container_of(fb_helper
, struct intel_fbdev
, helper
);
51 ret
= drm_fb_helper_set_par(info
);
54 mutex_lock(&fb_helper
->dev
->struct_mutex
);
55 intel_fb_obj_invalidate(ifbdev
->fb
->obj
, ORIGIN_GTT
);
56 mutex_unlock(&fb_helper
->dev
->struct_mutex
);
62 static int intel_fbdev_blank(int blank
, struct fb_info
*info
)
64 struct drm_fb_helper
*fb_helper
= info
->par
;
65 struct intel_fbdev
*ifbdev
=
66 container_of(fb_helper
, struct intel_fbdev
, helper
);
69 ret
= drm_fb_helper_blank(blank
, info
);
72 mutex_lock(&fb_helper
->dev
->struct_mutex
);
73 intel_fb_obj_invalidate(ifbdev
->fb
->obj
, ORIGIN_GTT
);
74 mutex_unlock(&fb_helper
->dev
->struct_mutex
);
81 static int intel_fbdev_pan_display(struct fb_var_screeninfo
*var
,
84 struct drm_fb_helper
*fb_helper
= info
->par
;
85 struct intel_fbdev
*ifbdev
=
86 container_of(fb_helper
, struct intel_fbdev
, helper
);
89 ret
= drm_fb_helper_pan_display(var
, info
);
92 mutex_lock(&fb_helper
->dev
->struct_mutex
);
93 intel_fb_obj_invalidate(ifbdev
->fb
->obj
, ORIGIN_GTT
);
94 mutex_unlock(&fb_helper
->dev
->struct_mutex
);
101 static struct fb_ops intelfb_ops
= {
103 .owner
= THIS_MODULE
,
104 .fb_check_var
= drm_fb_helper_check_var
,
106 .fb_set_par
= intel_fbdev_set_par
,
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
,
113 .fb_blank
= intel_fbdev_blank
,
115 .fb_setcmap
= drm_fb_helper_setcmap
,
117 .fb_debug_enter
= drm_fb_helper_debug_enter
,
119 .fb_debug_leave
= drm_fb_helper_debug_leave
,
123 static int intelfb_alloc(struct drm_fb_helper
*helper
,
124 struct drm_fb_helper_surface_size
*sizes
)
126 struct intel_fbdev
*ifbdev
=
127 container_of(helper
, struct intel_fbdev
, helper
);
128 struct drm_framebuffer
*fb
;
129 struct drm_device
*dev
= helper
->dev
;
130 struct drm_i915_private
*dev_priv
= to_i915(dev
);
131 struct drm_mode_fb_cmd2 mode_cmd
= {};
132 struct drm_i915_gem_object
*obj
= NULL
;
135 /* we don't do packed 24bpp */
136 if (sizes
->surface_bpp
== 24)
137 sizes
->surface_bpp
= 32;
139 mode_cmd
.width
= sizes
->surface_width
;
140 mode_cmd
.height
= sizes
->surface_height
;
142 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.width
*
143 DIV_ROUND_UP(sizes
->surface_bpp
, 8), 64);
144 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(sizes
->surface_bpp
,
145 sizes
->surface_depth
);
147 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
148 size
= PAGE_ALIGN(size
);
150 /* If the FB is too big, just don't use it since fbdev is not very
151 * important and we should probably use that space with FBC or other
153 if (size
* 2 < dev_priv
->gtt
.stolen_usable_size
)
154 obj
= i915_gem_object_create_stolen(dev
, size
);
156 obj
= i915_gem_alloc_object(dev
, size
);
158 DRM_ERROR("failed to allocate framebuffer\n");
163 fb
= __intel_framebuffer_create(dev
, &mode_cmd
, obj
);
169 /* Flush everything out, we'll be doing GTT only from now on */
170 ret
= intel_pin_and_fence_fb_obj(NULL
, fb
, NULL
, NULL
, NULL
);
172 DRM_ERROR("failed to pin obj: %d\n", ret
);
176 ifbdev
->fb
= to_intel_framebuffer(fb
);
181 drm_framebuffer_remove(fb
);
183 drm_gem_object_unreference(&obj
->base
);
188 static int intelfb_create(struct drm_fb_helper
*helper
,
189 struct drm_fb_helper_surface_size
*sizes
)
191 struct intel_fbdev
*ifbdev
=
192 container_of(helper
, struct intel_fbdev
, helper
);
193 struct intel_framebuffer
*intel_fb
= ifbdev
->fb
;
194 struct drm_device
*dev
= helper
->dev
;
195 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
196 struct fb_info
*info
;
197 struct drm_framebuffer
*fb
;
198 struct drm_i915_gem_object
*obj
;
201 bool prealloc
= false;
203 mutex_lock(&dev
->struct_mutex
);
206 (sizes
->fb_width
> intel_fb
->base
.width
||
207 sizes
->fb_height
> intel_fb
->base
.height
)) {
208 DRM_DEBUG_KMS("BIOS fb too small (%dx%d), we require (%dx%d),"
210 intel_fb
->base
.width
, intel_fb
->base
.height
,
211 sizes
->fb_width
, sizes
->fb_height
);
212 drm_framebuffer_unreference(&intel_fb
->base
);
213 intel_fb
= ifbdev
->fb
= NULL
;
215 if (!intel_fb
|| WARN_ON(!intel_fb
->obj
)) {
216 DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
217 ret
= intelfb_alloc(helper
, sizes
);
220 intel_fb
= ifbdev
->fb
;
222 DRM_DEBUG_KMS("re-using BIOS fb\n");
224 sizes
->fb_width
= intel_fb
->base
.width
;
225 sizes
->fb_height
= intel_fb
->base
.height
;
229 size
= obj
->base
.size
;
231 info
= drm_fb_helper_alloc_fbi(helper
);
239 fb
= &ifbdev
->fb
->base
;
241 ifbdev
->helper
.fb
= fb
;
244 vga_dev
= device_get_parent(dev
->dev
->bsddev
);
245 info
->width
= sizes
->fb_width
;
246 info
->height
= sizes
->fb_height
;
247 info
->stride
= fb
->pitches
[0];
248 info
->depth
= sizes
->surface_bpp
;
249 info
->paddr
= dev_priv
->gtt
.mappable_base
+ i915_gem_obj_ggtt_offset(obj
);
250 info
->is_vga_boot_display
= vga_pci_is_boot_display(vga_dev
);
251 info
->vaddr
= (vm_offset_t
)pmap_mapdev_attr(info
->paddr
, size
,
252 VM_MEMATTR_WRITE_COMBINING
);
253 info
->fbops
= intelfb_ops
;
255 strcpy(info
->fix
.id
, "inteldrmfb");
257 info
->flags
= FBINFO_DEFAULT
| FBINFO_CAN_FORCE_OUTPUT
;
258 info
->fbops
= &intelfb_ops
;
260 /* setup aperture base/size for vesafb takeover */
261 info
->apertures
->ranges
[0].base
= dev
->mode_config
.fb_base
;
262 info
->apertures
->ranges
[0].size
= dev_priv
->gtt
.mappable_end
;
264 info
->fix
.smem_start
= dev
->mode_config
.fb_base
+ i915_gem_obj_ggtt_offset(obj
);
265 info
->fix
.smem_len
= size
;
268 ioremap_wc(dev_priv
->gtt
.mappable_base
+ i915_gem_obj_ggtt_offset(obj
),
270 if (!info
->screen_base
) {
272 goto out_destroy_fbi
;
274 info
->screen_size
= size
;
276 /* This driver doesn't need a VT switch to restore the mode on resume */
277 info
->skip_vt_switch
= true;
279 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
280 drm_fb_helper_fill_var(info
, &ifbdev
->helper
, sizes
->fb_width
, sizes
->fb_height
);
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.
286 if (ifbdev
->fb
->obj
->stolen
&& !prealloc
)
287 memset_io(info
->screen_base
, 0, info
->screen_size
);
289 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
292 DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08lx, bo %p\n",
293 fb
->width
, fb
->height
,
294 i915_gem_obj_ggtt_offset(obj
), obj
);
296 mutex_unlock(&dev
->struct_mutex
);
298 vga_switcheroo_client_fb_set(dev
->pdev
, info
);
304 drm_fb_helper_release_fbi(helper
);
307 i915_gem_object_ggtt_unpin(obj
);
308 drm_gem_object_unreference(&obj
->base
);
310 mutex_unlock(&dev
->struct_mutex
);
314 /** Sets the color ramps on behalf of RandR */
315 static void intel_crtc_fb_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
318 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
320 intel_crtc
->lut_r
[regno
] = red
>> 8;
321 intel_crtc
->lut_g
[regno
] = green
>> 8;
322 intel_crtc
->lut_b
[regno
] = blue
>> 8;
325 static void intel_crtc_fb_gamma_get(struct drm_crtc
*crtc
, u16
*red
, u16
*green
,
326 u16
*blue
, int regno
)
328 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
330 *red
= intel_crtc
->lut_r
[regno
] << 8;
331 *green
= intel_crtc
->lut_g
[regno
] << 8;
332 *blue
= intel_crtc
->lut_b
[regno
] << 8;
335 static struct drm_fb_helper_crtc
*
336 intel_fb_helper_crtc(struct drm_fb_helper
*fb_helper
, struct drm_crtc
*crtc
)
340 for (i
= 0; i
< fb_helper
->crtc_count
; i
++)
341 if (fb_helper
->crtc_info
[i
].mode_set
.crtc
== crtc
)
342 return &fb_helper
->crtc_info
[i
];
348 * Try to read the BIOS display configuration and use it for the initial
351 * The BIOS or boot loader will generally create an initial display
352 * configuration for us that includes some set of active pipes and displays.
353 * This routine tries to figure out which pipes and connectors are active
354 * and stuffs them into the crtcs and modes array given to us by the
355 * drm_fb_helper code.
357 * The overall sequence is:
358 * intel_fbdev_init - from driver load
359 * intel_fbdev_init_bios - initialize the intel_fbdev using BIOS data
360 * drm_fb_helper_init - build fb helper structs
361 * drm_fb_helper_single_add_all_connectors - more fb helper structs
362 * intel_fbdev_initial_config - apply the config
363 * drm_fb_helper_initial_config - call ->probe then register_framebuffer()
364 * drm_setup_crtcs - build crtc config for fbdev
365 * intel_fb_initial_config - find active connectors etc
366 * drm_fb_helper_single_fb_probe - set up fbdev
367 * intelfb_create - re-use or alloc fb, build out fbdev structs
369 * Note that we don't make special consideration whether we could actually
370 * switch to the selected modes without a full modeset. E.g. when the display
371 * is in VGA mode we need to recalculate watermarks and set a new high-res
372 * framebuffer anyway.
374 static bool intel_fb_initial_config(struct drm_fb_helper
*fb_helper
,
375 struct drm_fb_helper_crtc
**crtcs
,
376 struct drm_display_mode
**modes
,
377 struct drm_fb_offset
*offsets
,
378 bool *enabled
, int width
, int height
)
380 struct drm_device
*dev
= fb_helper
->dev
;
383 bool fallback
= true;
384 int num_connectors_enabled
= 0;
385 int num_connectors_detected
= 0;
386 uint64_t conn_configured
= 0, mask
;
389 save_enabled
= kcalloc(dev
->mode_config
.num_connector
, sizeof(bool),
394 memcpy(save_enabled
, enabled
, dev
->mode_config
.num_connector
);
395 mask
= (1 << fb_helper
->connector_count
) - 1;
397 for (i
= 0; i
< fb_helper
->connector_count
; i
++) {
398 struct drm_fb_helper_connector
*fb_conn
;
399 struct drm_connector
*connector
;
400 struct drm_encoder
*encoder
;
401 struct drm_fb_helper_crtc
*new_crtc
;
403 fb_conn
= fb_helper
->connector_info
[i
];
404 connector
= fb_conn
->connector
;
406 if (conn_configured
& (1 << i
))
409 if (pass
== 0 && !connector
->has_tile
)
412 if (connector
->status
== connector_status_connected
)
413 num_connectors_detected
++;
416 DRM_DEBUG_KMS("connector %s not enabled, skipping\n",
418 conn_configured
|= (1 << i
);
422 if (connector
->force
== DRM_FORCE_OFF
) {
423 DRM_DEBUG_KMS("connector %s is disabled by user, skipping\n",
429 encoder
= connector
->encoder
;
430 if (!encoder
|| WARN_ON(!encoder
->crtc
)) {
431 if (connector
->force
> DRM_FORCE_OFF
)
434 DRM_DEBUG_KMS("connector %s has no encoder or crtc, skipping\n",
437 conn_configured
|= (1 << i
);
441 num_connectors_enabled
++;
443 new_crtc
= intel_fb_helper_crtc(fb_helper
, encoder
->crtc
);
446 * Make sure we're not trying to drive multiple connectors
447 * with a single CRTC, since our cloning support may not
450 for (j
= 0; j
< fb_helper
->connector_count
; j
++) {
451 if (crtcs
[j
] == new_crtc
) {
452 DRM_DEBUG_KMS("fallback: cloned configuration\n");
457 DRM_DEBUG_KMS("looking for cmdline mode on connector %s\n",
460 /* go for command line mode first */
461 modes
[i
] = drm_pick_cmdline_mode(fb_conn
, width
, height
);
463 /* try for preferred next */
465 DRM_DEBUG_KMS("looking for preferred mode on connector %s %d\n",
466 connector
->name
, connector
->has_tile
);
467 modes
[i
] = drm_has_preferred_mode(fb_conn
, width
,
471 /* No preferred mode marked by the EDID? Are there any modes? */
472 if (!modes
[i
] && !list_empty(&connector
->modes
)) {
473 DRM_DEBUG_KMS("using first mode listed on connector %s\n",
475 modes
[i
] = list_first_entry(&connector
->modes
,
476 struct drm_display_mode
,
480 /* last resort: use current mode */
483 * IMPORTANT: We want to use the adjusted mode (i.e.
484 * after the panel fitter upscaling) as the initial
485 * config, not the input mode, which is what crtc->mode
486 * usually contains. But since our current
487 * code puts a mode derived from the post-pfit timings
488 * into crtc->mode this works out correctly.
490 DRM_DEBUG_KMS("looking for current mode on connector %s\n",
492 modes
[i
] = &encoder
->crtc
->mode
;
496 DRM_DEBUG_KMS("connector %s on pipe %c [CRTC:%d]: %dx%d%s\n",
498 pipe_name(to_intel_crtc(encoder
->crtc
)->pipe
),
499 encoder
->crtc
->base
.id
,
500 modes
[i
]->hdisplay
, modes
[i
]->vdisplay
,
501 modes
[i
]->flags
& DRM_MODE_FLAG_INTERLACE
? "i" :"");
504 conn_configured
|= (1 << i
);
507 if ((conn_configured
& mask
) != mask
) {
513 * If the BIOS didn't enable everything it could, fall back to have the
514 * same user experiencing of lighting up as much as possible like the
515 * fbdev helper library.
517 if (num_connectors_enabled
!= num_connectors_detected
&&
518 num_connectors_enabled
< INTEL_INFO(dev
)->num_pipes
) {
519 DRM_DEBUG_KMS("fallback: Not all outputs enabled\n");
520 DRM_DEBUG_KMS("Enabled: %i, detected: %i\n", num_connectors_enabled
,
521 num_connectors_detected
);
527 DRM_DEBUG_KMS("Not using firmware configuration\n");
528 memcpy(enabled
, save_enabled
, dev
->mode_config
.num_connector
);
537 static const struct drm_fb_helper_funcs intel_fb_helper_funcs
= {
538 .initial_config
= intel_fb_initial_config
,
539 .gamma_set
= intel_crtc_fb_gamma_set
,
540 .gamma_get
= intel_crtc_fb_gamma_get
,
541 .fb_probe
= intelfb_create
,
544 static void intel_fbdev_destroy(struct drm_device
*dev
,
545 struct intel_fbdev
*ifbdev
)
547 drm_fb_helper_unregister_fbi(&ifbdev
->helper
);
548 drm_fb_helper_release_fbi(&ifbdev
->helper
);
550 drm_fb_helper_fini(&ifbdev
->helper
);
552 drm_framebuffer_unregister_private(&ifbdev
->fb
->base
);
553 drm_framebuffer_remove(&ifbdev
->fb
->base
);
557 * Build an intel_fbdev struct using a BIOS allocated framebuffer, if possible.
558 * The core display code will have read out the current plane configuration,
559 * so we use that to figure out if there's an object for us to use as the
560 * fb, and if so, we re-use it for the fbdev configuration.
562 * Note we only support a single fb shared across pipes for boot (mostly for
563 * fbcon), so we just find the biggest and use that.
565 static bool intel_fbdev_init_bios(struct drm_device
*dev
,
566 struct intel_fbdev
*ifbdev
)
568 struct intel_framebuffer
*fb
= NULL
;
569 struct drm_crtc
*crtc
;
570 struct intel_crtc
*intel_crtc
;
571 unsigned int max_size
= 0;
573 /* Find the largest fb */
574 for_each_crtc(dev
, crtc
) {
575 struct drm_i915_gem_object
*obj
=
576 intel_fb_obj(crtc
->primary
->state
->fb
);
577 intel_crtc
= to_intel_crtc(crtc
);
579 if (!crtc
->state
->active
|| !obj
) {
580 DRM_DEBUG_KMS("pipe %c not active or no fb, skipping\n",
581 pipe_name(intel_crtc
->pipe
));
585 if (obj
->base
.size
> max_size
) {
586 DRM_DEBUG_KMS("found possible fb from plane %c\n",
587 pipe_name(intel_crtc
->pipe
));
588 fb
= to_intel_framebuffer(crtc
->primary
->state
->fb
);
589 max_size
= obj
->base
.size
;
594 DRM_DEBUG_KMS("no active fbs found, not using BIOS config\n");
598 /* Now make sure all the pipes will fit into it */
599 for_each_crtc(dev
, crtc
) {
600 unsigned int cur_size
;
602 intel_crtc
= to_intel_crtc(crtc
);
604 if (!crtc
->state
->active
) {
605 DRM_DEBUG_KMS("pipe %c not active, skipping\n",
606 pipe_name(intel_crtc
->pipe
));
610 DRM_DEBUG_KMS("checking plane %c for BIOS fb\n",
611 pipe_name(intel_crtc
->pipe
));
614 * See if the plane fb we found above will fit on this
615 * pipe. Note we need to use the selected fb's pitch and bpp
616 * rather than the current pipe's, since they differ.
618 cur_size
= intel_crtc
->config
->base
.adjusted_mode
.crtc_hdisplay
;
619 cur_size
= cur_size
* fb
->base
.bits_per_pixel
/ 8;
620 if (fb
->base
.pitches
[0] < cur_size
) {
621 DRM_DEBUG_KMS("fb not wide enough for plane %c (%d vs %d)\n",
622 pipe_name(intel_crtc
->pipe
),
623 cur_size
, fb
->base
.pitches
[0]);
628 cur_size
= intel_crtc
->config
->base
.adjusted_mode
.crtc_vdisplay
;
629 cur_size
= intel_fb_align_height(dev
, cur_size
,
630 fb
->base
.pixel_format
,
631 fb
->base
.modifier
[0]);
632 cur_size
*= fb
->base
.pitches
[0];
633 DRM_DEBUG_KMS("pipe %c area: %dx%d, bpp: %d, size: %d\n",
634 pipe_name(intel_crtc
->pipe
),
635 intel_crtc
->config
->base
.adjusted_mode
.crtc_hdisplay
,
636 intel_crtc
->config
->base
.adjusted_mode
.crtc_vdisplay
,
637 fb
->base
.bits_per_pixel
,
640 if (cur_size
> max_size
) {
641 DRM_DEBUG_KMS("fb not big enough for plane %c (%d vs %d)\n",
642 pipe_name(intel_crtc
->pipe
),
648 DRM_DEBUG_KMS("fb big enough for plane %c (%d >= %d)\n",
649 pipe_name(intel_crtc
->pipe
),
654 DRM_DEBUG_KMS("BIOS fb not suitable for all pipes, not using\n");
658 ifbdev
->preferred_bpp
= fb
->base
.bits_per_pixel
;
661 drm_framebuffer_reference(&ifbdev
->fb
->base
);
663 /* Final pass to check if any active pipes don't have fbs */
664 for_each_crtc(dev
, crtc
) {
665 intel_crtc
= to_intel_crtc(crtc
);
667 if (!crtc
->state
->active
)
670 WARN(!crtc
->primary
->fb
,
671 "re-used BIOS config but lost an fb on crtc %d\n",
676 DRM_DEBUG_KMS("using BIOS fb for initial console\n");
684 static void intel_fbdev_suspend_worker(struct work_struct
*work
)
686 intel_fbdev_set_suspend(container_of(work
,
687 struct drm_i915_private
,
688 fbdev_suspend_work
)->dev
,
689 FBINFO_STATE_RUNNING
,
693 int intel_fbdev_init(struct drm_device
*dev
)
695 struct intel_fbdev
*ifbdev
;
696 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
699 if (WARN_ON(INTEL_INFO(dev
)->num_pipes
== 0))
702 ifbdev
= kzalloc(sizeof(struct intel_fbdev
), GFP_KERNEL
);
706 drm_fb_helper_prepare(dev
, &ifbdev
->helper
, &intel_fb_helper_funcs
);
708 if (!intel_fbdev_init_bios(dev
, ifbdev
))
709 ifbdev
->preferred_bpp
= 32;
711 ret
= drm_fb_helper_init(dev
, &ifbdev
->helper
,
712 INTEL_INFO(dev
)->num_pipes
, 4);
718 ifbdev
->helper
.atomic
= true;
720 dev_priv
->fbdev
= ifbdev
;
721 INIT_WORK(&dev_priv
->fbdev_suspend_work
, intel_fbdev_suspend_worker
);
723 drm_fb_helper_single_add_all_connectors(&ifbdev
->helper
);
728 void intel_fbdev_initial_config(void *data
, async_cookie_t cookie
)
730 struct drm_i915_private
*dev_priv
= data
;
731 struct intel_fbdev
*ifbdev
= dev_priv
->fbdev
;
733 /* Due to peculiar init order wrt to hpd handling this is separate. */
734 drm_fb_helper_initial_config(&ifbdev
->helper
, ifbdev
->preferred_bpp
);
737 void intel_fbdev_fini(struct drm_device
*dev
)
739 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
740 if (!dev_priv
->fbdev
)
744 flush_work(&dev_priv
->fbdev_suspend_work
);
747 async_synchronize_full();
748 intel_fbdev_destroy(dev
, dev_priv
->fbdev
);
749 kfree(dev_priv
->fbdev
);
750 dev_priv
->fbdev
= NULL
;
753 void intel_fbdev_set_suspend(struct drm_device
*dev
, int state
, bool synchronous
)
756 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
757 struct intel_fbdev
*ifbdev
= dev_priv
->fbdev
;
758 struct fb_info
*info
;
763 info
= ifbdev
->helper
.fbdev
;
766 /* Flush any pending work to turn the console on, and then
767 * wait to turn it off. It must be synchronous as we are
768 * about to suspend or unload the driver.
770 * Note that from within the work-handler, we cannot flush
771 * ourselves, so only flush outstanding work upon suspend!
773 if (state
!= FBINFO_STATE_RUNNING
)
774 flush_work(&dev_priv
->fbdev_suspend_work
);
778 * The console lock can be pretty contented on resume due
779 * to all the printk activity. Try to keep it out of the hot
780 * path of resume if possible.
782 WARN_ON(state
!= FBINFO_STATE_RUNNING
);
783 if (!console_trylock()) {
784 /* Don't block our own workqueue as this can
785 * be run in parallel with other i915.ko tasks.
787 schedule_work(&dev_priv
->fbdev_suspend_work
);
792 /* On resume from hibernation: If the object is shmemfs backed, it has
793 * been restored from swap. If the object is stolen however, it will be
794 * full of whatever garbage was left in there.
796 if (state
== FBINFO_STATE_RUNNING
&& ifbdev
->fb
->obj
->stolen
)
797 memset_io(info
->screen_base
, 0, info
->screen_size
);
799 drm_fb_helper_set_suspend(&ifbdev
->helper
, state
);
804 void intel_fbdev_output_poll_changed(struct drm_device
*dev
)
806 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
808 drm_fb_helper_hotplug_event(&dev_priv
->fbdev
->helper
);
811 void intel_fbdev_restore_mode(struct drm_device
*dev
)
814 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
815 struct intel_fbdev
*ifbdev
= dev_priv
->fbdev
;
816 struct drm_fb_helper
*fb_helper
;
821 fb_helper
= &ifbdev
->helper
;
823 /* XXX: avoid dead-locking the Xorg on exit */
824 if (mutex_is_locked(&dev
->mode_config
.mutex
)) {
825 DRM_ERROR("fubar while trying to restore kms_console\n");
826 return; /* drm_modeset_unlock_all(dev) ? */
829 ret
= drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper
);
831 DRM_DEBUG("failed to restore crtc mode\n");
833 mutex_lock(&fb_helper
->dev
->struct_mutex
);
834 intel_fb_obj_invalidate(ifbdev
->fb
->obj
, ORIGIN_GTT
);
835 mutex_unlock(&fb_helper
->dev
->struct_mutex
);