[mirror_ubuntu-artful-kernel.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_framebuffer *fb;
	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 obj: %d\n", ret);
		goto out_unref;
	}

	fb = __intel_framebuffer_create(dev, &mode_cmd, obj);
	if (IS_ERR(fb)) {
		ret = PTR_ERR(fb);
		goto out_unpin;
	}

	ifbdev->fb = to_intel_framebuffer(fb);

	return 0;

out_unpin:
	i915_gem_object_ggtt_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->fb;
	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 || WARN_ON(!intel_fb->obj)) {
		DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
		ret = intelfb_alloc(helper, sizes);
		if (ret)
			goto out_unlock;
		intel_fb = ifbdev->fb;
	} 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->fb->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->fb->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_ggtt_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_crtc *
intel_fb_helper_crtc(struct drm_fb_helper *fb_helper, struct drm_crtc *crtc)
{
	int i;

	for (i = 0; i < fb_helper->crtc_count; i++)
		if (fb_helper->crtc_info[i].mode_set.crtc == crtc)
			return &fb_helper->crtc_info[i];

	return NULL;
}

/*
 * Try to read the BIOS display configuration and use it for the initial
 * fb configuration.
 *
 * The BIOS or boot loader will generally create an initial display
 * configuration for us that includes some set of active pipes and displays.
 * This routine tries to figure out which pipes and connectors are active
 * and stuffs them into the crtcs and modes array given to us by the
 * drm_fb_helper code.
 *
 * The overall sequence is:
 *   intel_fbdev_init - from driver load
 *     intel_fbdev_init_bios - initialize the intel_fbdev using BIOS data
 *     drm_fb_helper_init - build fb helper structs
 *     drm_fb_helper_single_add_all_connectors - more fb helper structs
 *   intel_fbdev_initial_config - apply the config
 *     drm_fb_helper_initial_config - call ->probe then register_framebuffer()
 *         drm_setup_crtcs - build crtc config for fbdev
 *           intel_fb_initial_config - find active connectors etc
 *         drm_fb_helper_single_fb_probe - set up fbdev
 *           intelfb_create - re-use or alloc fb, build out fbdev structs
 *
 * Note that we don't make special consideration whether we could actually
 * switch to the selected modes without a full modeset. E.g. when the display
 * is in VGA mode we need to recalculate watermarks and set a new high-res
 * framebuffer anyway.
 */
static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper,
				    struct drm_fb_helper_crtc **crtcs,
				    struct drm_display_mode **modes,
				    bool *enabled, int width, int height)
{
	struct drm_device *dev = fb_helper->dev;
	int i, j;
	bool *save_enabled;
	bool any_enabled = false;

	/*
	 * If the user specified any force options, just bail here
	 * and use that config.
	 */
	for (i = 0; i < fb_helper->connector_count; i++) {
		struct drm_fb_helper_connector *fb_conn;
		struct drm_connector *connector;

		fb_conn = fb_helper->connector_info[i];
		connector = fb_conn->connector;

		if (!enabled[i])
			continue;

		if (connector->force != DRM_FORCE_UNSPECIFIED)
			return false;
	}

	save_enabled = kcalloc(dev->mode_config.num_connector, sizeof(bool),
			       GFP_KERNEL);
	if (!save_enabled)
		return false;

	memcpy(save_enabled, enabled, dev->mode_config.num_connector);

	for (i = 0; i < fb_helper->connector_count; i++) {
		struct drm_fb_helper_connector *fb_conn;
		struct drm_connector *connector;
		struct drm_encoder *encoder;
		struct drm_fb_helper_crtc *new_crtc;

		fb_conn = fb_helper->connector_info[i];
		connector = fb_conn->connector;
		if (!enabled[i]) {
			DRM_DEBUG_KMS("connector %d not enabled, skipping\n",
				      connector->base.id);
			continue;
		}

		encoder = connector->encoder;
		if (!encoder || WARN_ON(!encoder->crtc)) {
			DRM_DEBUG_KMS("connector %d has no encoder or crtc, skipping\n",
				      connector->base.id);
			enabled[i] = false;
			continue;
		}

		new_crtc = intel_fb_helper_crtc(fb_helper, encoder->crtc);

		/*
		 * Make sure we're not trying to drive multiple connectors
		 * with a single CRTC, since our cloning support may not
		 * match the BIOS.
		 */
		for (j = 0; j < fb_helper->connector_count; j++) {
			if (crtcs[j] == new_crtc) {
				any_enabled = false;
				goto out;
			}
		}

		DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
			      fb_conn->connector->base.id);

		/* go for command line mode first */
		modes[i] = drm_pick_cmdline_mode(fb_conn, width, height);

		/* try for preferred next */
		if (!modes[i]) {
			DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",
				      fb_conn->connector->base.id);
			modes[i] = drm_has_preferred_mode(fb_conn, width,
							  height);
		}

		/* last resort: use current mode */
		if (!modes[i]) {
			/*
			 * IMPORTANT: We want to use the adjusted mode (i.e.
			 * after the panel fitter upscaling) as the initial
			 * config, not the input mode, which is what crtc->mode
			 * usually contains. But since our current fastboot
			 * code puts a mode derived from the post-pfit timings
			 * into crtc->mode this works out correctly. We don't
			 * use hwmode anywhere right now, so use it for this
			 * since the fb helper layer wants a pointer to
			 * something we own.
			 */
			intel_mode_from_pipe_config(&encoder->crtc->hwmode,
						    &to_intel_crtc(encoder->crtc)->config);
			modes[i] = &encoder->crtc->hwmode;
		}
		crtcs[i] = new_crtc;

		DRM_DEBUG_KMS("connector %s on crtc %d: %s\n",
			      drm_get_connector_name(connector),
			      encoder->crtc->base.id,
			      modes[i]->name);

		any_enabled = true;
	}

out:
	if (!any_enabled) {
		memcpy(enabled, save_enabled, dev->mode_config.num_connector);
		kfree(save_enabled);
		return false;
	}

	kfree(save_enabled);
	return true;
}

static struct drm_fb_helper_funcs intel_fb_helper_funcs = {
	.initial_config = intel_fb_initial_config,
	.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->fb->base);
	drm_framebuffer_remove(&ifbdev->fb->base);
}

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->fb->obj->stolen)
		memset_io(info->screen_base, 0, info->screen_size);

	fb_set_suspend(info, state);
}

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 =
3430824b VS	64	container_of(helper, struct intel_fbdev, helper);
a8bb6818	65	struct drm_framebuffer *fb;
3430824b	66	struct drm_device *dev = helper->dev;
3a7f2f6a	67	struct drm_mode_fb_cmd2 mode_cmd = {};
05394f39	68	struct drm_i915_gem_object *obj;
57084d05	69	int size, ret;
79e53945	70
b8c00ac5	71	/* we don't do packed 24bpp */
38651674 DA	72	if (sizes->surface_bpp == 24)
38651674 DA	73	sizes->surface_bpp = 32;
b8c00ac5	74
38651674 DA	75	mode_cmd.width = sizes->surface_width;
38651674 DA	76	mode_cmd.height = sizes->surface_height;
79e53945	77
de45eaf7 PZ	78	mode_cmd.pitches[0] = ALIGN(mode_cmd.width *
de45eaf7 PZ	79	DIV_ROUND_UP(sizes->surface_bpp, 8), 64);
308e5bcb JB	80	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
308e5bcb JB	81	sizes->surface_depth);
79e53945	82
308e5bcb	83	size = mode_cmd.pitches[0] * mode_cmd.height;
79e53945	84	size = ALIGN(size, PAGE_SIZE);
0ffb0ff2 CW	85	obj = i915_gem_object_create_stolen(dev, size);
	86	if (obj == NULL)
	87	obj = i915_gem_alloc_object(dev, size);
05394f39	88	if (!obj) {
1ae8c0a5	89	DRM_ERROR("failed to allocate framebuffer\n");
79e53945 JB	90	ret = -ENOMEM;
	91	goto out;
	92	}
79e53945	93
7213342d	94	/* Flush everything out, we'll be doing GTT only from now on */
c43b5634	95	ret = intel_pin_and_fence_fb_obj(dev, obj, NULL);
79e53945	96	if (ret) {
a8bb6818	97	DRM_ERROR("failed to pin obj: %d\n", ret);
79e53945 JB	98	goto out_unref;
	99	}
	100
a8bb6818 DV	101	fb = __intel_framebuffer_create(dev, &mode_cmd, obj);
	102	if (IS_ERR(fb)) {
	103	ret = PTR_ERR(fb);
8b4f49e0	104	goto out_unpin;
a8bb6818 DV	105	}
	106
	107	ifbdev->fb = to_intel_framebuffer(fb);
8b4f49e0 JB	108
	109	return 0;
	110
	111	out_unpin:
d7f46fc4	112	i915_gem_object_ggtt_unpin(obj);
8b4f49e0 JB	113	out_unref:
	114	drm_gem_object_unreference(&obj->base);
	115	out:
	116	return ret;
	117	}
	118
	119	static int intelfb_create(struct drm_fb_helper *helper,
	120	struct drm_fb_helper_surface_size *sizes)
	121	{
	122	struct intel_fbdev *ifbdev =
	123	container_of(helper, struct intel_fbdev, helper);
8bcd4553	124	struct intel_framebuffer *intel_fb = ifbdev->fb;
8b4f49e0 JB	125	struct drm_device *dev = helper->dev;
	126	struct drm_i915_private *dev_priv = dev->dev_private;
	127	struct fb_info *info;
	128	struct drm_framebuffer *fb;
	129	struct drm_i915_gem_object *obj;
	130	int size, ret;
	131
	132	mutex_lock(&dev->struct_mutex);
	133
8bcd4553	134	if (!intel_fb \|\| WARN_ON(!intel_fb->obj)) {
48e92120	135	DRM_DEBUG_KMS("no BIOS fb, allocating a new one\n");
8b4f49e0 JB	136	ret = intelfb_alloc(helper, sizes);
	137	if (ret)
	138	goto out_unlock;
8bcd4553	139	intel_fb = ifbdev->fb;
8b4f49e0	140	} else {
48e92120	141	DRM_DEBUG_KMS("re-using BIOS fb\n");
8b4f49e0 JB	142	sizes->fb_width = intel_fb->base.width;
	143	sizes->fb_height = intel_fb->base.height;
	144	}
	145
	146	obj = intel_fb->obj;
	147	size = obj->base.size;
	148
	149	info = framebuffer_alloc(0, &dev->pdev->dev);
79e53945 JB	150	if (!info) {
79e53945 JB	151	ret = -ENOMEM;
b4476f52	152	goto out_unpin;
79e53945 JB	153	}
79e53945 JB	154
3430824b	155	info->par = helper;
79e53945	156
8bcd4553	157	fb = &ifbdev->fb->base;
79e53945	158
38651674 DA	159	ifbdev->helper.fb = fb;
38651674 DA	160	ifbdev->helper.fbdev = info;
785b93ef	161
79e53945	162	strcpy(info->fix.id, "inteldrmfb");
79e53945	163
8fd4bd22	164	info->flags = FBINFO_DEFAULT \| FBINFO_CAN_FORCE_OUTPUT;
79e53945 JB	165	info->fbops = &intelfb_ops;
79e53945 JB	166
35c3047a CW	167	ret = fb_alloc_cmap(&info->cmap, 256, 0);
	168	if (ret) {
	169	ret = -ENOMEM;
	170	goto out_unpin;
	171	}
4410f391	172	/* setup aperture base/size for vesafb takeover */
1471ca9a MS	173	info->apertures = alloc_apertures(1);
	174	if (!info->apertures) {
	175	ret = -ENOMEM;
	176	goto out_unpin;
	177	}
	178	info->apertures->ranges[0].base = dev->mode_config.fb_base;
93d18799	179	info->apertures->ranges[0].size = dev_priv->gtt.mappable_end;
4410f391	180
f343c5f6	181	info->fix.smem_start = dev->mode_config.fb_base + i915_gem_obj_ggtt_offset(obj);
79e53945 JB	182	info->fix.smem_len = size;
79e53945 JB	183
dd2757f8	184	info->screen_base =
f343c5f6	185	ioremap_wc(dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(obj),
dd2757f8	186	size);
79e53945 JB	187	if (!info->screen_base) {
79e53945 JB	188	ret = -ENOSPC;
b4476f52	189	goto out_unpin;
79e53945 JB	190	}
	191	info->screen_size = size;
	192
24576d23 JB	193	/* This driver doesn't need a VT switch to restore the mode on resume */
	194	info->skip_vt_switch = true;
	195
01f2c773	196	drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
38651674	197	drm_fb_helper_fill_var(info, &ifbdev->helper, sizes->fb_width, sizes->fb_height);
79e53945	198
88afe715 CW	199	/* If the object is shmemfs backed, it will have given us zeroed pages.
	200	* If the object is stolen however, it will be full of whatever
	201	* garbage was left in there.
	202	*/
8bcd4553	203	if (ifbdev->fb->obj->stolen)
88afe715 CW	204	memset_io(info->screen_base, 0, info->screen_size);
88afe715 CW	205
fb2a99e1	206	/* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
79e53945	207
f343c5f6	208	DRM_DEBUG_KMS("allocated %dx%d fb: 0x%08lx, bo %p\n",
8be48d92	209	fb->width, fb->height,
f343c5f6	210	i915_gem_obj_ggtt_offset(obj), obj);
79e53945 JB	211
79e53945 JB	212	mutex_unlock(&dev->struct_mutex);
6a9ee8af	213	vga_switcheroo_client_fb_set(dev->pdev, info);
79e53945 JB	214	return 0;
79e53945 JB	215
b4476f52	216	out_unpin:
d7f46fc4	217	i915_gem_object_ggtt_unpin(obj);
05394f39	218	drm_gem_object_unreference(&obj->base);
8b4f49e0	219	out_unlock:
79e53945	220	mutex_unlock(&dev->struct_mutex);
79e53945 JB	221	return ret;
	222	}
	223
67437680 PZ	224	/** Sets the color ramps on behalf of RandR */
	225	static void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
	226	u16 blue, int regno)
	227	{
	228	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	229
	230	intel_crtc->lut_r[regno] = red >> 8;
	231	intel_crtc->lut_g[regno] = green >> 8;
	232	intel_crtc->lut_b[regno] = blue >> 8;
	233	}
	234
	235	static void intel_crtc_fb_gamma_get(struct drm_crtc crtc, u16 red, u16 *green,
	236	u16 *blue, int regno)
	237	{
	238	struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
	239
	240	*red = intel_crtc->lut_r[regno] << 8;
	241	*green = intel_crtc->lut_g[regno] << 8;
	242	*blue = intel_crtc->lut_b[regno] << 8;
	243	}
	244
eb1bfe80 JB	245	static struct drm_fb_helper_crtc *
	246	intel_fb_helper_crtc(struct drm_fb_helper fb_helper, struct drm_crtc crtc)
	247	{
	248	int i;
	249
	250	for (i = 0; i < fb_helper->crtc_count; i++)
	251	if (fb_helper->crtc_info[i].mode_set.crtc == crtc)
	252	return &fb_helper->crtc_info[i];
	253
	254	return NULL;
	255	}
	256
	257	/*
	258	* Try to read the BIOS display configuration and use it for the initial
	259	* fb configuration.
	260	*
	261	* The BIOS or boot loader will generally create an initial display
	262	* configuration for us that includes some set of active pipes and displays.
	263	* This routine tries to figure out which pipes and connectors are active
	264	* and stuffs them into the crtcs and modes array given to us by the
	265	* drm_fb_helper code.
	266	*
	267	* The overall sequence is:
	268	* intel_fbdev_init - from driver load
	269	* intel_fbdev_init_bios - initialize the intel_fbdev using BIOS data
	270	* drm_fb_helper_init - build fb helper structs
	271	* drm_fb_helper_single_add_all_connectors - more fb helper structs
	272	* intel_fbdev_initial_config - apply the config
	273	* drm_fb_helper_initial_config - call ->probe then register_framebuffer()
	274	* drm_setup_crtcs - build crtc config for fbdev
	275	* intel_fb_initial_config - find active connectors etc
	276	* drm_fb_helper_single_fb_probe - set up fbdev
	277	* intelfb_create - re-use or alloc fb, build out fbdev structs
	278	*
	279	* Note that we don't make special consideration whether we could actually
	280	* switch to the selected modes without a full modeset. E.g. when the display
	281	* is in VGA mode we need to recalculate watermarks and set a new high-res
	282	* framebuffer anyway.
	283	*/
	284	static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper,
	285	struct drm_fb_helper_crtc **crtcs,
	286	struct drm_display_mode **modes,
	287	bool *enabled, int width, int height)
	288	{
02f5eebb	289	struct drm_device *dev = fb_helper->dev;
eb1bfe80	290	int i, j;
02f5eebb JB	291	bool *save_enabled;
	292	bool any_enabled = false;
	293
ef34ab89 JB	294	/*
	295	* If the user specified any force options, just bail here
	296	* and use that config.
	297	*/
	298	for (i = 0; i < fb_helper->connector_count; i++) {
	299	struct drm_fb_helper_connector *fb_conn;
	300	struct drm_connector *connector;
	301
	302	fb_conn = fb_helper->connector_info[i];
	303	connector = fb_conn->connector;
	304
	305	if (!enabled[i])
	306	continue;
	307
	308	if (connector->force != DRM_FORCE_UNSPECIFIED)
	309	return false;
	310	}
	311
02f5eebb JB	312	save_enabled = kcalloc(dev->mode_config.num_connector, sizeof(bool),
	313	GFP_KERNEL);
	314	if (!save_enabled)
	315	return false;
	316
	317	memcpy(save_enabled, enabled, dev->mode_config.num_connector);
eb1bfe80 JB	318
	319	for (i = 0; i < fb_helper->connector_count; i++) {
	320	struct drm_fb_helper_connector *fb_conn;
	321	struct drm_connector *connector;
	322	struct drm_encoder *encoder;
	323	struct drm_fb_helper_crtc *new_crtc;
	324
	325	fb_conn = fb_helper->connector_info[i];
	326	connector = fb_conn->connector;
	327	if (!enabled[i]) {
	328	DRM_DEBUG_KMS("connector %d not enabled, skipping\n",
	329	connector->base.id);
	330	continue;
	331	}
	332
	333	encoder = connector->encoder;
	334	if (!encoder \|\| WARN_ON(!encoder->crtc)) {
	335	DRM_DEBUG_KMS("connector %d has no encoder or crtc, skipping\n",
	336	connector->base.id);
	337	enabled[i] = false;
	338	continue;
	339	}
	340
	341	new_crtc = intel_fb_helper_crtc(fb_helper, encoder->crtc);
	342
	343	/*
	344	* Make sure we're not trying to drive multiple connectors
	345	* with a single CRTC, since our cloning support may not
	346	* match the BIOS.
	347	*/
	348	for (j = 0; j < fb_helper->connector_count; j++) {
02f5eebb JB	349	if (crtcs[j] == new_crtc) {
	350	any_enabled = false;
	351	goto out;
	352	}
eb1bfe80 JB	353	}
	354
	355	DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
	356	fb_conn->connector->base.id);
	357
	358	/* go for command line mode first */
	359	modes[i] = drm_pick_cmdline_mode(fb_conn, width, height);
	360
	361	/* try for preferred next */
	362	if (!modes[i]) {
	363	DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",
	364	fb_conn->connector->base.id);
	365	modes[i] = drm_has_preferred_mode(fb_conn, width,
	366	height);
	367	}
	368
	369	/* last resort: use current mode */
	370	if (!modes[i]) {
	371	/*
	372	* IMPORTANT: We want to use the adjusted mode (i.e.
	373	* after the panel fitter upscaling) as the initial
	374	* config, not the input mode, which is what crtc->mode
	375	* usually contains. But since our current fastboot
	376	* code puts a mode derived from the post-pfit timings
	377	* into crtc->mode this works out correctly. We don't
	378	* use hwmode anywhere right now, so use it for this
	379	* since the fb helper layer wants a pointer to
	380	* something we own.
	381	*/
	382	intel_mode_from_pipe_config(&encoder->crtc->hwmode,
	383	&to_intel_crtc(encoder->crtc)->config);
	384	modes[i] = &encoder->crtc->hwmode;
	385	}
	386	crtcs[i] = new_crtc;
	387
	388	DRM_DEBUG_KMS("connector %s on crtc %d: %s\n",
	389	drm_get_connector_name(connector),
	390	encoder->crtc->base.id,
	391	modes[i]->name);
02f5eebb JB	392
	393	any_enabled = true;
	394	}
	395
	396	out:
	397	if (!any_enabled) {
	398	memcpy(enabled, save_enabled, dev->mode_config.num_connector);
	399	kfree(save_enabled);
	400	return false;
eb1bfe80 JB	401	}
eb1bfe80 JB	402
02f5eebb	403	kfree(save_enabled);
eb1bfe80 JB	404	return true;
	405	}
	406
4abe3520	407	static struct drm_fb_helper_funcs intel_fb_helper_funcs = {
eb1bfe80	408	.initial_config = intel_fb_initial_config,
4abe3520 DA	409	.gamma_set = intel_crtc_fb_gamma_set,
4abe3520 DA	410	.gamma_get = intel_crtc_fb_gamma_get,
cd5428a5	411	.fb_probe = intelfb_create,
4abe3520	412	};
79e53945	413
7b4f3990 CW	414	static void intel_fbdev_destroy(struct drm_device *dev,
7b4f3990 CW	415	struct intel_fbdev *ifbdev)
79e53945	416	{
8be48d92	417	if (ifbdev->helper.fbdev) {
ddfe1567 CW	418	struct fb_info *info = ifbdev->helper.fbdev;
ddfe1567 CW	419
79e53945 JB	420	unregister_framebuffer(info);
79e53945 JB	421	iounmap(info->screen_base);
4abe3520 DA	422	if (info->cmap.len)
4abe3520 DA	423	fb_dealloc_cmap(&info->cmap);
ddfe1567	424
79e53945 JB	425	framebuffer_release(info);
	426	}
	427
4abe3520	428	drm_fb_helper_fini(&ifbdev->helper);
79e53945	429
8bcd4553	430	drm_framebuffer_unregister_private(&ifbdev->fb->base);
9d661251	431	drm_framebuffer_remove(&ifbdev->fb->base);
79e53945	432	}
38651674 DA	433
	434	int intel_fbdev_init(struct drm_device *dev)
	435	{
8be48d92	436	struct intel_fbdev *ifbdev;
b51b32cd	437	struct drm_i915_private *dev_priv = dev->dev_private;
5a79395b	438	int ret;
8be48d92	439
b14c5679	440	ifbdev = kzalloc(sizeof(*ifbdev), GFP_KERNEL);
8be48d92 DA	441	if (!ifbdev)
	442	return -ENOMEM;
	443
	444	dev_priv->fbdev = ifbdev;
4abe3520 DA	445	ifbdev->helper.funcs = &intel_fb_helper_funcs;
4abe3520 DA	446
5a79395b	447	ret = drm_fb_helper_init(dev, &ifbdev->helper,
7eb552ae	448	INTEL_INFO(dev)->num_pipes,
955382f3	449	4);
5a79395b CW	450	if (ret) {
	451	kfree(ifbdev);
	452	return ret;
	453	}
8be48d92	454
0b4c0f3f	455	drm_fb_helper_single_add_all_connectors(&ifbdev->helper);
20afbda2	456
79e53945 JB	457	return 0;
79e53945 JB	458	}
38651674	459
20afbda2 DV	460	void intel_fbdev_initial_config(struct drm_device *dev)
20afbda2 DV	461	{
b51b32cd	462	struct drm_i915_private *dev_priv = dev->dev_private;
20afbda2 DV	463
	464	/* Due to peculiar init order wrt to hpd handling this is separate. */
	465	drm_fb_helper_initial_config(&dev_priv->fbdev->helper, 32);
	466	}
	467
38651674 DA	468	void intel_fbdev_fini(struct drm_device *dev)
38651674 DA	469	{
b51b32cd	470	struct drm_i915_private *dev_priv = dev->dev_private;
8be48d92 DA	471	if (!dev_priv->fbdev)
	472	return;
	473
38651674	474	intel_fbdev_destroy(dev, dev_priv->fbdev);
8be48d92	475	kfree(dev_priv->fbdev);
38651674 DA	476	dev_priv->fbdev = NULL;
38651674 DA	477	}
3fa016a0 DA	478
	479	void intel_fbdev_set_suspend(struct drm_device *dev, int state)
	480	{
b51b32cd	481	struct drm_i915_private *dev_priv = dev->dev_private;
1ffc5289 JN	482	struct intel_fbdev *ifbdev = dev_priv->fbdev;
	483	struct fb_info *info;
	484
	485	if (!ifbdev)
3fa016a0 DA	486	return;
3fa016a0 DA	487
1ffc5289 JN	488	info = ifbdev->helper.fbdev;
	489
	490	/* On resume from hibernation: If the object is shmemfs backed, it has
	491	* been restored from swap. If the object is stolen however, it will be
	492	* full of whatever garbage was left in there.
	493	*/
8bcd4553	494	if (state == FBINFO_STATE_RUNNING && ifbdev->fb->obj->stolen)
1ffc5289 JN	495	memset_io(info->screen_base, 0, info->screen_size);
	496
	497	fb_set_suspend(info, state);
3fa016a0 DA	498	}
3fa016a0 DA	499
0632fef6	500	void intel_fbdev_output_poll_changed(struct drm_device *dev)
eb1f8e4f	501	{
b51b32cd	502	struct drm_i915_private *dev_priv = dev->dev_private;
eb1f8e4f DA	503	drm_fb_helper_hotplug_event(&dev_priv->fbdev->helper);
eb1f8e4f DA	504	}
e8e7a2b8	505
0632fef6	506	void intel_fbdev_restore_mode(struct drm_device *dev)
e8e7a2b8 DA	507	{
e8e7a2b8 DA	508	int ret;
b51b32cd	509	struct drm_i915_private *dev_priv = dev->dev_private;
e8e7a2b8	510
e3c74757 BW	511	if (INTEL_INFO(dev)->num_pipes == 0)
	512	return;
	513
a0e99e68	514	drm_modeset_lock_all(dev);
c291be9d	515
e8e7a2b8 DA	516	ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper);
	517	if (ret)
	518	DRM_DEBUG("failed to restore crtc mode\n");
b840d907	519
a0e99e68	520	drm_modeset_unlock_all(dev);
e8e7a2b8	521	}