[deliverable/linux.git] / drivers / gpu / drm / i915 / intel_fbdev.c

/*
 * Copyright © 2007 David Airlie
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *     David Airlie
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/tty.h>
#include <linux/sysrq.h>
#include <linux/delay.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/vga_switcheroo.h>

#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fb_helper.h>
#include "intel_drv.h"
#include <drm/i915_drm.h>
#include "i915_drv.h"

static struct fb_ops intelfb_ops = {
	.owner = THIS_MODULE,
	.fb_check_var = drm_fb_helper_check_var,
	.fb_set_par = drm_fb_helper_set_par,
	.fb_fillrect = cfb_fillrect,
	.fb_copyarea = cfb_copyarea,
	.fb_imageblit = cfb_imageblit,
	.fb_pan_display = drm_fb_helper_pan_display,
	.fb_blank = drm_fb_helper_blank,
	.fb_setcmap = drm_fb_helper_setcmap,
	.fb_debug_enter = drm_fb_helper_debug_enter,
	.fb_debug_leave = drm_fb_helper_debug_leave,
};

static int intelfb_alloc(struct drm_fb_helper *helper,
			 struct drm_fb_helper_surface_size *sizes)
{
	struct intel_fbdev *ifbdev =
		container_of(helper, struct intel_fbdev, helper);
	struct drm_device *dev = helper->dev;
	struct drm_mode_fb_cmd2 mode_cmd = {};
	struct drm_i915_gem_object *obj;
	int size, ret;

	/* we don't do packed 24bpp */
	if (sizes->surface_bpp == 24)
		sizes->surface_bpp = 32;

	mode_cmd.width = sizes->surface_width;
	mode_cmd.height = sizes->surface_height;

	mode_cmd.pitches[0] = ALIGN(mode_cmd.width *
				    DIV_ROUND_UP(sizes->surface_bpp, 8), 64);
	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
							  sizes->surface_depth);

	size = mode_cmd.pitches[0] * mode_cmd.height;
	size = ALIGN(size, PAGE_SIZE);
	obj = i915_gem_object_create_stolen(dev, size);
	if (obj == NULL)
		obj = i915_gem_alloc_object(dev, size);
	if (!obj) {
		DRM_ERROR("failed to allocate framebuffer\n");
		ret = -ENOMEM;
		goto out;
	}

	/* Flush everything out, we'll be doing GTT only from now on */
	ret = intel_pin_and_fence_fb_obj(dev, obj, NULL);
	if (ret) {
		DRM_ERROR("failed to pin fb: %d\n", ret);
		goto out_unref;
	}

	ret = intel_framebuffer_init(dev, &ifbdev->ifb, &mode_cmd, obj);
	if (ret)
		goto out_unpin;

	return 0;

out_unpin:
	i915_gem_object_unpin(obj);
out_unref:
	drm_gem_object_unreference(&obj->base);
out:
	return ret;
}

static int intelfb_create(struct drm_fb_helper *helper,
			  struct drm_fb_helper_surface_size *sizes)
{
	struct intel_fbdev *ifbdev =
		container_of(helper, struct intel_fbdev, helper);
	struct intel_framebuffer *intel_fb = &ifbdev->ifb;
	struct drm_device *dev = helper->dev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct fb_info *info;
	struct drm_framebuffer *fb;
	struct drm_i915_gem_object *obj;
	int size, ret;

	mutex_lock(&dev->struct_mutex);

	if (!intel_fb->obj) {
		DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
		ret = intelfb_alloc(helper, sizes);
		if (ret)
			goto out_unlock;
	} else {
		DRM_DEBUG_KMS("re-using BIOS fb\n");
		sizes->fb_width = intel_fb->base.width;
		sizes->fb_height = intel_fb->base.height;
	}

	obj = intel_fb->obj;
	size = obj->base.size;

	info = framebuffer_alloc(0, &dev->pdev->dev);
	if (!info) {
		ret = -ENOMEM;
		goto out_unpin;
	}

	info->par = helper;

	fb = &ifbdev->ifb.base;

	ifbdev->helper.fb = fb;
	ifbdev->helper.fbdev = info;

	strcpy(info->fix.id, "inteldrmfb");

	info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
	info->fbops = &intelfb_ops;

	ret = fb_alloc_cmap(&info->cmap, 256, 0);
	if (ret) {
		ret = -ENOMEM;
		goto out_unpin;
	}
	/* setup aperture base/size for vesafb takeover */
	info->apertures = alloc_apertures(1);
	if (!info->apertures) {
		ret = -ENOMEM;
		goto out_unpin;
	}
	info->apertures->ranges[0].base = dev->mode_config.fb_base;
	info->apertures->ranges[0].size = dev_priv->gtt.mappable_end;

	info->fix.smem_start = dev->mode_config.fb_base + i915_gem_obj_ggtt_offset(obj);
	info->fix.smem_len = size;

	info->screen_base =
		ioremap_wc(dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(obj),
			   size);
	if (!info->screen_base) {
		ret = -ENOSPC;
		goto out_unpin;
	}
	info->screen_size = size;

	/* This driver doesn't need a VT switch to restore the mode on resume */
	info->skip_vt_switch = true;

	drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
	drm_fb_helper_fill_var(info, &ifbdev->helper, sizes->fb_width, sizes->fb_height);

	/* If the object is shmemfs backed, it will have given us zeroed pages.
	 * If the object is stolen however, it will be full of whatever
	 * garbage was left in there.
	 */
	if (ifbdev->ifb.obj->stolen)
		memset_io(info->screen_base, 0, info->screen_size);

	/* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */

	DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08lx, bo %p\n",
		      fb->width, fb->height,
		      i915_gem_obj_ggtt_offset(obj), obj);

	mutex_unlock(&dev->struct_mutex);
	vga_switcheroo_client_fb_set(dev->pdev, info);
	return 0;

out_unpin:
	i915_gem_object_unpin(obj);
	drm_gem_object_unreference(&obj->base);
out_unlock:
	mutex_unlock(&dev->struct_mutex);
	return ret;
}

/** Sets the color ramps on behalf of RandR */
static void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
				    u16 blue, int regno)
{
	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);

	intel_crtc->lut_r[regno] = red >> 8;
	intel_crtc->lut_g[regno] = green >> 8;
	intel_crtc->lut_b[regno] = blue >> 8;
}

static void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
				    u16 *blue, int regno)
{
	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);

	*red = intel_crtc->lut_r[regno] << 8;
	*green = intel_crtc->lut_g[regno] << 8;
	*blue = intel_crtc->lut_b[regno] << 8;
}

static struct drm_fb_helper_funcs intel_fb_helper_funcs = {
	.gamma_set = intel_crtc_fb_gamma_set,
	.gamma_get = intel_crtc_fb_gamma_get,
	.fb_probe = intelfb_create,
};

static void intel_fbdev_destroy(struct drm_device *dev,
				struct intel_fbdev *ifbdev)
{
	if (ifbdev->helper.fbdev) {
		struct fb_info *info = ifbdev->helper.fbdev;

		unregister_framebuffer(info);
		iounmap(info->screen_base);
		if (info->cmap.len)
			fb_dealloc_cmap(&info->cmap);

		framebuffer_release(info);
	}

	drm_fb_helper_fini(&ifbdev->helper);

	drm_framebuffer_unregister_private(&ifbdev->ifb.base);
	intel_framebuffer_fini(&ifbdev->ifb);
}

int intel_fbdev_init(struct drm_device *dev)
{
	struct intel_fbdev *ifbdev;
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret;

	ifbdev = kzalloc(sizeof(*ifbdev), GFP_KERNEL);
	if (!ifbdev)
		return -ENOMEM;

	dev_priv->fbdev = ifbdev;
	ifbdev->helper.funcs = &intel_fb_helper_funcs;

	ret = drm_fb_helper_init(dev, &ifbdev->helper,
				 INTEL_INFO(dev)->num_pipes,
				 4);
	if (ret) {
		kfree(ifbdev);
		return ret;
	}

	drm_fb_helper_single_add_all_connectors(&ifbdev->helper);

	return 0;
}

void intel_fbdev_initial_config(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;

	/* Due to peculiar init order wrt to hpd handling this is separate. */
	drm_fb_helper_initial_config(&dev_priv->fbdev->helper, 32);
}

void intel_fbdev_fini(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	if (!dev_priv->fbdev)
		return;

	intel_fbdev_destroy(dev, dev_priv->fbdev);
	kfree(dev_priv->fbdev);
	dev_priv->fbdev = NULL;
}

void intel_fbdev_set_suspend(struct drm_device *dev, int state)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_fbdev *ifbdev = dev_priv->fbdev;
	struct fb_info *info;

	if (!ifbdev)
		return;

	info = ifbdev->helper.fbdev;

	/* On resume from hibernation: If the object is shmemfs backed, it has
	 * been restored from swap. If the object is stolen however, it will be
	 * full of whatever garbage was left in there.
	 */
	if (state == FBINFO_STATE_RUNNING && ifbdev->ifb.obj->stolen)
		memset_io(info->screen_base, 0, info->screen_size);

	fb_set_suspend(info, state);
}

MODULE_LICENSE("GPL and additional rights");

void intel_fbdev_output_poll_changed(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	drm_fb_helper_hotplug_event(&dev_priv->fbdev->helper);
}

void intel_fbdev_restore_mode(struct drm_device *dev)
{
	int ret;
	struct drm_i915_private *dev_priv = dev->dev_private;

	if (INTEL_INFO(dev)->num_pipes == 0)
		return;

	drm_modeset_lock_all(dev);

	ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper);
	if (ret)
		DRM_DEBUG("failed to restore crtc mode\n");

	drm_modeset_unlock_all(dev);
}
Commit	Line	Data
79e53945 JB	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/module.h>
	28	#include <linux/kernel.h>
	29	#include <linux/errno.h>
	30	#include <linux/string.h>
	31	#include <linux/mm.h>
	32	#include <linux/tty.h>
79e53945 JB	33	#include <linux/sysrq.h>
	34	#include <linux/delay.h>
	35	#include <linux/fb.h>
	36	#include <linux/init.h>
6a9ee8af	37	#include <linux/vga_switcheroo.h>
79e53945	38
760285e7 DH	39	#include <drm/drmP.h>
	40	#include <drm/drm_crtc.h>
	41	#include <drm/drm_fb_helper.h>
79e53945	42	#include "intel_drv.h"
760285e7	43	#include <drm/i915_drm.h>
79e53945 JB	44	#include "i915_drv.h"
79e53945 JB	45
79e53945 JB	46	static struct fb_ops intelfb_ops = {
79e53945 JB	47	.owner = THIS_MODULE,
785b93ef DA	48	.fb_check_var = drm_fb_helper_check_var,
785b93ef DA	49	.fb_set_par = drm_fb_helper_set_par,
79e53945 JB	50	.fb_fillrect = cfb_fillrect,
	51	.fb_copyarea = cfb_copyarea,
	52	.fb_imageblit = cfb_imageblit,
785b93ef DA	53	.fb_pan_display = drm_fb_helper_pan_display,
785b93ef DA	54	.fb_blank = drm_fb_helper_blank,
068143d3	55	.fb_setcmap = drm_fb_helper_setcmap,
81255565 JB	56	.fb_debug_enter = drm_fb_helper_debug_enter,
81255565 JB	57	.fb_debug_leave = drm_fb_helper_debug_leave,
79e53945 JB	58	};
79e53945 JB	59
8b4f49e0 JB	60	static int intelfb_alloc(struct drm_fb_helper *helper,
8b4f49e0 JB	61	struct drm_fb_helper_surface_size *sizes)
79e53945	62	{
3430824b VS	63	struct intel_fbdev *ifbdev =
	64	container_of(helper, struct intel_fbdev, helper);
	65	struct drm_device *dev = helper->dev;
3a7f2f6a	66	struct drm_mode_fb_cmd2 mode_cmd = {};
05394f39	67	struct drm_i915_gem_object *obj;
57084d05	68	int size, ret;
79e53945	69
b8c00ac5	70	/* we don't do packed 24bpp */
38651674 DA	71	if (sizes->surface_bpp == 24)
38651674 DA	72	sizes->surface_bpp = 32;
b8c00ac5	73
38651674 DA	74	mode_cmd.width = sizes->surface_width;
38651674 DA	75	mode_cmd.height = sizes->surface_height;
79e53945	76
de45eaf7 PZ	77	mode_cmd.pitches[0] = ALIGN(mode_cmd.width *
de45eaf7 PZ	78	DIV_ROUND_UP(sizes->surface_bpp, 8), 64);
308e5bcb JB	79	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
308e5bcb JB	80	sizes->surface_depth);
79e53945	81
308e5bcb	82	size = mode_cmd.pitches[0] * mode_cmd.height;
79e53945	83	size = ALIGN(size, PAGE_SIZE);
0ffb0ff2 CW	84	obj = i915_gem_object_create_stolen(dev, size);
	85	if (obj == NULL)
	86	obj = i915_gem_alloc_object(dev, size);
05394f39	87	if (!obj) {
1ae8c0a5	88	DRM_ERROR("failed to allocate framebuffer\n");
79e53945 JB	89	ret = -ENOMEM;
	90	goto out;
	91	}
79e53945	92
7213342d	93	/* Flush everything out, we'll be doing GTT only from now on */
c43b5634	94	ret = intel_pin_and_fence_fb_obj(dev, obj, NULL);
79e53945 JB	95	if (ret) {
	96	DRM_ERROR("failed to pin fb: %d\n", ret);
	97	goto out_unref;
	98	}
	99
8b4f49e0 JB	100	ret = intel_framebuffer_init(dev, &ifbdev->ifb, &mode_cmd, obj);
	101	if (ret)
	102	goto out_unpin;
	103
	104	return 0;
	105
	106	out_unpin:
	107	i915_gem_object_unpin(obj);
	108	out_unref:
	109	drm_gem_object_unreference(&obj->base);
	110	out:
	111	return ret;
	112	}
	113
	114	static int intelfb_create(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 intel_framebuffer *intel_fb = &ifbdev->ifb;
	120	struct drm_device *dev = helper->dev;
	121	struct drm_i915_private *dev_priv = dev->dev_private;
	122	struct fb_info *info;
	123	struct drm_framebuffer *fb;
	124	struct drm_i915_gem_object *obj;
	125	int size, ret;
	126
	127	mutex_lock(&dev->struct_mutex);
	128
	129	if (!intel_fb->obj) {
48e92120	130	DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
8b4f49e0 JB	131	ret = intelfb_alloc(helper, sizes);
	132	if (ret)
	133	goto out_unlock;
	134	} else {
48e92120	135	DRM_DEBUG_KMS("re-using BIOS fb\n");
8b4f49e0 JB	136	sizes->fb_width = intel_fb->base.width;
	137	sizes->fb_height = intel_fb->base.height;
	138	}
	139
	140	obj = intel_fb->obj;
	141	size = obj->base.size;
	142
	143	info = framebuffer_alloc(0, &dev->pdev->dev);
79e53945 JB	144	if (!info) {
79e53945 JB	145	ret = -ENOMEM;
b4476f52	146	goto out_unpin;
79e53945 JB	147	}
79e53945 JB	148
3430824b	149	info->par = helper;
79e53945	150
38651674	151	fb = &ifbdev->ifb.base;
79e53945	152
38651674 DA	153	ifbdev->helper.fb = fb;
38651674 DA	154	ifbdev->helper.fbdev = info;
785b93ef	155
79e53945	156	strcpy(info->fix.id, "inteldrmfb");
79e53945	157
8fd4bd22	158	info->flags = FBINFO_DEFAULT \| FBINFO_CAN_FORCE_OUTPUT;
79e53945 JB	159	info->fbops = &intelfb_ops;
79e53945 JB	160
35c3047a CW	161	ret = fb_alloc_cmap(&info->cmap, 256, 0);
	162	if (ret) {
	163	ret = -ENOMEM;
	164	goto out_unpin;
	165	}
4410f391	166	/* setup aperture base/size for vesafb takeover */
1471ca9a MS	167	info->apertures = alloc_apertures(1);
	168	if (!info->apertures) {
	169	ret = -ENOMEM;
	170	goto out_unpin;
	171	}
	172	info->apertures->ranges[0].base = dev->mode_config.fb_base;
93d18799	173	info->apertures->ranges[0].size = dev_priv->gtt.mappable_end;
4410f391	174
f343c5f6	175	info->fix.smem_start = dev->mode_config.fb_base + i915_gem_obj_ggtt_offset(obj);
79e53945 JB	176	info->fix.smem_len = size;
79e53945 JB	177
dd2757f8	178	info->screen_base =
f343c5f6	179	ioremap_wc(dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(obj),
dd2757f8	180	size);
79e53945 JB	181	if (!info->screen_base) {
79e53945 JB	182	ret = -ENOSPC;
b4476f52	183	goto out_unpin;
79e53945 JB	184	}
	185	info->screen_size = size;
	186
24576d23 JB	187	/* This driver doesn't need a VT switch to restore the mode on resume */
	188	info->skip_vt_switch = true;
	189
01f2c773	190	drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
38651674	191	drm_fb_helper_fill_var(info, &ifbdev->helper, sizes->fb_width, sizes->fb_height);
79e53945	192
88afe715 CW	193	/* If the object is shmemfs backed, it will have given us zeroed pages.
	194	* If the object is stolen however, it will be full of whatever
	195	* garbage was left in there.
	196	*/
	197	if (ifbdev->ifb.obj->stolen)
	198	memset_io(info->screen_base, 0, info->screen_size);
	199
fb2a99e1	200	/* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
79e53945	201
f343c5f6	202	DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08lx, bo %p\n",
8be48d92	203	fb->width, fb->height,
f343c5f6	204	i915_gem_obj_ggtt_offset(obj), obj);
79e53945 JB	205
79e53945 JB	206	mutex_unlock(&dev->struct_mutex);
6a9ee8af	207	vga_switcheroo_client_fb_set(dev->pdev, info);
79e53945 JB	208	return 0;
79e53945 JB	209
b4476f52	210	out_unpin:
05394f39	211	i915_gem_object_unpin(obj);
05394f39	212	drm_gem_object_unreference(&obj->base);
8b4f49e0	213	out_unlock:
79e53945	214	mutex_unlock(&dev->struct_mutex);
79e53945 JB	215	return ret;
	216	}
	217
67437680 PZ	218	/** Sets the color ramps on behalf of RandR */
	219	static void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
	220	u16 blue, int regno)
	221	{
	222	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	223
	224	intel_crtc->lut_r[regno] = red >> 8;
	225	intel_crtc->lut_g[regno] = green >> 8;
	226	intel_crtc->lut_b[regno] = blue >> 8;
	227	}
	228
	229	static void intel_crtc_fb_gamma_get(struct drm_crtc crtc, u16 red, u16 *green,
	230	u16 *blue, int regno)
	231	{
	232	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	233
	234	*red = intel_crtc->lut_r[regno] << 8;
	235	*green = intel_crtc->lut_g[regno] << 8;
	236	*blue = intel_crtc->lut_b[regno] << 8;
	237	}
	238
4abe3520 DA	239	static struct drm_fb_helper_funcs intel_fb_helper_funcs = {
	240	.gamma_set = intel_crtc_fb_gamma_set,
	241	.gamma_get = intel_crtc_fb_gamma_get,
cd5428a5	242	.fb_probe = intelfb_create,
4abe3520	243	};
79e53945	244
7b4f3990 CW	245	static void intel_fbdev_destroy(struct drm_device *dev,
7b4f3990 CW	246	struct intel_fbdev *ifbdev)
79e53945	247	{
8be48d92	248	if (ifbdev->helper.fbdev) {
ddfe1567 CW	249	struct fb_info *info = ifbdev->helper.fbdev;
ddfe1567 CW	250
79e53945 JB	251	unregister_framebuffer(info);
79e53945 JB	252	iounmap(info->screen_base);
4abe3520 DA	253	if (info->cmap.len)
4abe3520 DA	254	fb_dealloc_cmap(&info->cmap);
ddfe1567	255
79e53945 JB	256	framebuffer_release(info);
	257	}
	258
4abe3520	259	drm_fb_helper_fini(&ifbdev->helper);
79e53945	260
ddfe1567 CW	261	drm_framebuffer_unregister_private(&ifbdev->ifb.base);
ddfe1567 CW	262	intel_framebuffer_fini(&ifbdev->ifb);
79e53945	263	}
38651674 DA	264
	265	int intel_fbdev_init(struct drm_device *dev)
	266	{
8be48d92	267	struct intel_fbdev *ifbdev;
b51b32cd	268	struct drm_i915_private *dev_priv = dev->dev_private;
5a79395b	269	int ret;
8be48d92	270
b14c5679	271	ifbdev = kzalloc(sizeof(*ifbdev), GFP_KERNEL);
8be48d92 DA	272	if (!ifbdev)
	273	return -ENOMEM;
	274
	275	dev_priv->fbdev = ifbdev;
4abe3520 DA	276	ifbdev->helper.funcs = &intel_fb_helper_funcs;
4abe3520 DA	277
5a79395b	278	ret = drm_fb_helper_init(dev, &ifbdev->helper,
7eb552ae	279	INTEL_INFO(dev)->num_pipes,
955382f3	280	4);
5a79395b CW	281	if (ret) {
	282	kfree(ifbdev);
	283	return ret;
	284	}
8be48d92	285
0b4c0f3f	286	drm_fb_helper_single_add_all_connectors(&ifbdev->helper);
20afbda2	287
79e53945 JB	288	return 0;
79e53945 JB	289	}
38651674	290
20afbda2 DV	291	void intel_fbdev_initial_config(struct drm_device *dev)
20afbda2 DV	292	{
b51b32cd	293	struct drm_i915_private *dev_priv = dev->dev_private;
20afbda2 DV	294
	295	/* Due to peculiar init order wrt to hpd handling this is separate. */
	296	drm_fb_helper_initial_config(&dev_priv->fbdev->helper, 32);
	297	}
	298
38651674 DA	299	void intel_fbdev_fini(struct drm_device *dev)
38651674 DA	300	{
b51b32cd	301	struct drm_i915_private *dev_priv = dev->dev_private;
8be48d92 DA	302	if (!dev_priv->fbdev)
	303	return;
	304
38651674	305	intel_fbdev_destroy(dev, dev_priv->fbdev);
8be48d92	306	kfree(dev_priv->fbdev);
38651674 DA	307	dev_priv->fbdev = NULL;
38651674 DA	308	}
3fa016a0 DA	309
	310	void intel_fbdev_set_suspend(struct drm_device *dev, int state)
	311	{
b51b32cd	312	struct drm_i915_private *dev_priv = dev->dev_private;
1ffc5289 JN	313	struct intel_fbdev *ifbdev = dev_priv->fbdev;
	314	struct fb_info *info;
	315
	316	if (!ifbdev)
3fa016a0 DA	317	return;
3fa016a0 DA	318
1ffc5289 JN	319	info = ifbdev->helper.fbdev;
	320
	321	/* On resume from hibernation: If the object is shmemfs backed, it has
	322	* been restored from swap. If the object is stolen however, it will be
	323	* full of whatever garbage was left in there.
	324	*/
b6f3eff7	325	if (state == FBINFO_STATE_RUNNING && ifbdev->ifb.obj->stolen)
1ffc5289 JN	326	memset_io(info->screen_base, 0, info->screen_size);
	327
	328	fb_set_suspend(info, state);
3fa016a0 DA	329	}
3fa016a0 DA	330
79e53945	331	MODULE_LICENSE("GPL and additional rights");
eb1f8e4f	332
0632fef6	333	void intel_fbdev_output_poll_changed(struct drm_device *dev)
eb1f8e4f	334	{
b51b32cd	335	struct drm_i915_private *dev_priv = dev->dev_private;
eb1f8e4f DA	336	drm_fb_helper_hotplug_event(&dev_priv->fbdev->helper);
eb1f8e4f DA	337	}
e8e7a2b8	338
0632fef6	339	void intel_fbdev_restore_mode(struct drm_device *dev)
e8e7a2b8 DA	340	{
e8e7a2b8 DA	341	int ret;
b51b32cd	342	struct drm_i915_private *dev_priv = dev->dev_private;
e8e7a2b8	343
e3c74757 BW	344	if (INTEL_INFO(dev)->num_pipes == 0)
	345	return;
	346
a0e99e68	347	drm_modeset_lock_all(dev);
c291be9d	348
e8e7a2b8 DA	349	ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper);
	350	if (ret)
	351	DRM_DEBUG("failed to restore crtc mode\n");
b840d907	352
a0e99e68	353	drm_modeset_unlock_all(dev);
e8e7a2b8	354	}