Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7fff400b authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'drm-fbdev-cleanup' into drm-core-next 

* drm-fbdev-cleanup:
  drm/fb: remove drm_fb_helper_setcolreg
  drm/kms/fb: use slow work mechanism for normal hotplug also.
  drm/kms/fb: add polling support for when nothing is connected.
  drm/kms/fb: provide a 1024x768 fbcon if no outputs found.
  drm/kms/fb: separate fbdev connector list from core drm connectors
  drm/kms/fb: move to using fb helper crtc grouping instead of core crtc list
  drm/fb: fix fbdev object model + cleanup properly.

Conflicts:
	drivers/gpu/drm/i915/i915_drv.h
	drivers/gpu/drm/nouveau/nouveau_drv.h
parents 0bcb1d84 b1f20198

drivers/gpu/drm/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ config DRM_KMS_HELPER 
	depends on DRM

	select FB

	select FRAMEBUFFER_CONSOLE if !EMBEDDED

	select SLOW_WORK

	help

	  FB and CRTC helpers for KMS drivers.

drivers/gpu/drm/drm_crtc.c

+0 −2
Original line number Diff line number Diff line
@@ -495,7 +495,6 @@ void drm_connector_cleanup(struct drm_connector *connector) 
	list_for_each_entry_safe(mode, t, &connector->user_modes, head)

		drm_mode_remove(connector, mode);



	kfree(connector->fb_helper_private);

	mutex_lock(&dev->mode_config.mutex);

	drm_mode_object_put(dev, &connector->base);

	list_del(&connector->head);
@@ -859,7 +858,6 @@ void drm_mode_config_init(struct drm_device *dev) 
	mutex_init(&dev->mode_config.mutex);

	mutex_init(&dev->mode_config.idr_mutex);

	INIT_LIST_HEAD(&dev->mode_config.fb_list);

	INIT_LIST_HEAD(&dev->mode_config.fb_kernel_list);

	INIT_LIST_HEAD(&dev->mode_config.crtc_list);

	INIT_LIST_HEAD(&dev->mode_config.connector_list);

	INIT_LIST_HEAD(&dev->mode_config.encoder_list);

drivers/gpu/drm/drm_crtc_helper.c

+1 −394
Original line number Diff line number Diff line
@@ -55,7 +55,7 @@ static void drm_mode_validate_flag(struct drm_connector *connector, 
}



/**

 * drm_helper_probe_connector_modes - get complete set of display modes

 * drm_helper_probe_single_connector_modes - get complete set of display modes

 * @dev: DRM device

 * @maxX: max width for modes

 * @maxY: max height for modes
@@ -154,21 +154,6 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector, 
}

EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);



int drm_helper_probe_connector_modes(struct drm_device *dev, uint32_t maxX,

				      uint32_t maxY)

{

	struct drm_connector *connector;

	int count = 0;



	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {

		count += drm_helper_probe_single_connector_modes(connector,

								 maxX, maxY);

	}



	return count;

}

EXPORT_SYMBOL(drm_helper_probe_connector_modes);



/**

 * drm_helper_encoder_in_use - check if a given encoder is in use

 * @encoder: encoder to check
@@ -263,302 +248,6 @@ void drm_helper_disable_unused_functions(struct drm_device *dev) 
}

EXPORT_SYMBOL(drm_helper_disable_unused_functions);



static struct drm_display_mode *drm_has_preferred_mode(struct drm_connector *connector, int width, int height)

{

	struct drm_display_mode *mode;



	list_for_each_entry(mode, &connector->modes, head) {

		if (drm_mode_width(mode) > width ||

		    drm_mode_height(mode) > height)

			continue;

		if (mode->type & DRM_MODE_TYPE_PREFERRED)

			return mode;

	}

	return NULL;

}



static bool drm_has_cmdline_mode(struct drm_connector *connector)

{

	struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private;

	struct drm_fb_helper_cmdline_mode *cmdline_mode;



	if (!fb_help_conn)

		return false;



	cmdline_mode = &fb_help_conn->cmdline_mode;

	return cmdline_mode->specified;

}



static struct drm_display_mode *drm_pick_cmdline_mode(struct drm_connector *connector, int width, int height)

{

	struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private;

	struct drm_fb_helper_cmdline_mode *cmdline_mode;

	struct drm_display_mode *mode = NULL;



	if (!fb_help_conn)

		return mode;



	cmdline_mode = &fb_help_conn->cmdline_mode;

	if (cmdline_mode->specified == false)

		return mode;



	/* attempt to find a matching mode in the list of modes

	 *  we have gotten so far, if not add a CVT mode that conforms

	 */

	if (cmdline_mode->rb || cmdline_mode->margins)

		goto create_mode;



	list_for_each_entry(mode, &connector->modes, head) {

		/* check width/height */

		if (mode->hdisplay != cmdline_mode->xres ||

		    mode->vdisplay != cmdline_mode->yres)

			continue;



		if (cmdline_mode->refresh_specified) {

			if (mode->vrefresh != cmdline_mode->refresh)

				continue;

		}



		if (cmdline_mode->interlace) {

			if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))

				continue;

		}

		return mode;

	}



create_mode:

	mode = drm_cvt_mode(connector->dev, cmdline_mode->xres,

			    cmdline_mode->yres,

			    cmdline_mode->refresh_specified ? cmdline_mode->refresh : 60,

			    cmdline_mode->rb, cmdline_mode->interlace,

			    cmdline_mode->margins);

	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);

	list_add(&mode->head, &connector->modes);

	return mode;

}



static bool drm_connector_enabled(struct drm_connector *connector, bool strict)

{

	bool enable;



	if (strict) {

		enable = connector->status == connector_status_connected;

	} else {

		enable = connector->status != connector_status_disconnected;

	}

	return enable;

}



static void drm_enable_connectors(struct drm_device *dev, bool *enabled)

{

	bool any_enabled = false;

	struct drm_connector *connector;

	int i = 0;



	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {

		enabled[i] = drm_connector_enabled(connector, true);

		DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,

			  enabled[i] ? "yes" : "no");

		any_enabled |= enabled[i];

		i++;

	}



	if (any_enabled)

		return;



	i = 0;

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {

		enabled[i] = drm_connector_enabled(connector, false);

		i++;

	}

}



static bool drm_target_preferred(struct drm_device *dev,

				 struct drm_display_mode **modes,

				 bool *enabled, int width, int height)

{

	struct drm_connector *connector;

	int i = 0;



	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {



		if (enabled[i] == false) {

			i++;

			continue;

		}



		DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",

			      connector->base.id);



		/* got for command line mode first */

		modes[i] = drm_pick_cmdline_mode(connector, width, height);

		if (!modes[i]) {

			DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",

				      connector->base.id);

			modes[i] = drm_has_preferred_mode(connector, width, height);

		}

		/* No preferred modes, pick one off the list */

		if (!modes[i] && !list_empty(&connector->modes)) {

			list_for_each_entry(modes[i], &connector->modes, head)

				break;

		}

		DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :

			  "none");

		i++;

	}

	return true;

}



static int drm_pick_crtcs(struct drm_device *dev,

			  struct drm_crtc **best_crtcs,

			  struct drm_display_mode **modes,

			  int n, int width, int height)

{

	int c, o;

	struct drm_connector *connector;

	struct drm_connector_helper_funcs *connector_funcs;

	struct drm_encoder *encoder;

	struct drm_crtc *best_crtc;

	int my_score, best_score, score;

	struct drm_crtc **crtcs, *crtc;



	if (n == dev->mode_config.num_connector)

		return 0;

	c = 0;

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {

		if (c == n)

			break;

		c++;

	}



	best_crtcs[n] = NULL;

	best_crtc = NULL;

	best_score = drm_pick_crtcs(dev, best_crtcs, modes, n+1, width, height);

	if (modes[n] == NULL)

		return best_score;



	crtcs = kmalloc(dev->mode_config.num_connector *

			sizeof(struct drm_crtc *), GFP_KERNEL);

	if (!crtcs)

		return best_score;



	my_score = 1;

	if (connector->status == connector_status_connected)

		my_score++;

	if (drm_has_cmdline_mode(connector))

		my_score++;

	if (drm_has_preferred_mode(connector, width, height))

		my_score++;



	connector_funcs = connector->helper_private;

	encoder = connector_funcs->best_encoder(connector);

	if (!encoder)

		goto out;



	connector->encoder = encoder;



	/* select a crtc for this connector and then attempt to configure

	   remaining connectors */

	c = 0;

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {



		if ((encoder->possible_crtcs & (1 << c)) == 0) {

			c++;

			continue;

		}



		for (o = 0; o < n; o++)

			if (best_crtcs[o] == crtc)

				break;



		if (o < n) {

			/* ignore cloning for now */

			c++;

			continue;

		}



		crtcs[n] = crtc;

		memcpy(crtcs, best_crtcs, n * sizeof(struct drm_crtc *));

		score = my_score + drm_pick_crtcs(dev, crtcs, modes, n + 1,

						  width, height);

		if (score > best_score) {

			best_crtc = crtc;

			best_score = score;

			memcpy(best_crtcs, crtcs,

			       dev->mode_config.num_connector *

			       sizeof(struct drm_crtc *));

		}

		c++;

	}

out:

	kfree(crtcs);

	return best_score;

}



static void drm_setup_crtcs(struct drm_device *dev)

{

	struct drm_crtc **crtcs;

	struct drm_display_mode **modes;

	struct drm_encoder *encoder;

	struct drm_connector *connector;

	bool *enabled;

	int width, height;

	int i, ret;



	DRM_DEBUG_KMS("\n");



	width = dev->mode_config.max_width;

	height = dev->mode_config.max_height;



	/* clean out all the encoder/crtc combos */

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {

		encoder->crtc = NULL;

	}



	crtcs = kcalloc(dev->mode_config.num_connector,

			sizeof(struct drm_crtc *), GFP_KERNEL);

	modes = kcalloc(dev->mode_config.num_connector,

			sizeof(struct drm_display_mode *), GFP_KERNEL);

	enabled = kcalloc(dev->mode_config.num_connector,

			  sizeof(bool), GFP_KERNEL);



	drm_enable_connectors(dev, enabled);



	ret = drm_target_preferred(dev, modes, enabled, width, height);

	if (!ret)

		DRM_ERROR("Unable to find initial modes\n");



	DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height);



	drm_pick_crtcs(dev, crtcs, modes, 0, width, height);



	i = 0;

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {

		struct drm_display_mode *mode = modes[i];

		struct drm_crtc *crtc = crtcs[i];



		if (connector->encoder == NULL) {

			i++;

			continue;

		}



		if (mode && crtc) {

			DRM_DEBUG_KMS("desired mode %s set on crtc %d\n",

				  mode->name, crtc->base.id);

			crtc->desired_mode = mode;

			connector->encoder->crtc = crtc;

		} else {

			connector->encoder->crtc = NULL;

			connector->encoder = NULL;

		}

		i++;

	}



	kfree(crtcs);

	kfree(modes);

	kfree(enabled);

}



/**

 * drm_encoder_crtc_ok - can a given crtc drive a given encoder?

 * @encoder: encoder to test
@@ -936,10 +625,6 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set) 
				ret = -EINVAL;

				goto fail;

			}

			/* TODO are these needed? */

			set->crtc->desired_x = set->x;

			set->crtc->desired_y = set->y;

			set->crtc->desired_mode = set->mode;

		}

		drm_helper_disable_unused_functions(dev);

	} else if (fb_changed) {
@@ -984,63 +669,6 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set) 
}

EXPORT_SYMBOL(drm_crtc_helper_set_config);



bool drm_helper_plugged_event(struct drm_device *dev)

{

	DRM_DEBUG_KMS("\n");



	drm_helper_probe_connector_modes(dev, dev->mode_config.max_width,

					 dev->mode_config.max_height);



	drm_setup_crtcs(dev);



	/* alert the driver fb layer */

	dev->mode_config.funcs->fb_changed(dev);



	/* FIXME: send hotplug event */

	return true;

}

/**

 * drm_initial_config - setup a sane initial connector configuration

 * @dev: DRM device

 *

 * LOCKING:

 * Called at init time, must take mode config lock.

 *

 * Scan the CRTCs and connectors and try to put together an initial setup.

 * At the moment, this is a cloned configuration across all heads with

 * a new framebuffer object as the backing store.

 *

 * RETURNS:

 * Zero if everything went ok, nonzero otherwise.

 */

bool drm_helper_initial_config(struct drm_device *dev)

{

	int count = 0;



	/* disable all the possible outputs/crtcs before entering KMS mode */

	drm_helper_disable_unused_functions(dev);



	drm_fb_helper_parse_command_line(dev);



	count = drm_helper_probe_connector_modes(dev,

						 dev->mode_config.max_width,

						 dev->mode_config.max_height);



	/*

	 * we shouldn't end up with no modes here.

	 */

	if (count == 0)

		printk(KERN_INFO "No connectors reported connected with modes\n");



	drm_setup_crtcs(dev);



	/* alert the driver fb layer */

	dev->mode_config.funcs->fb_changed(dev);



	return 0;

}

EXPORT_SYMBOL(drm_helper_initial_config);



static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)

{

	int dpms = DRM_MODE_DPMS_OFF;
@@ -1123,27 +751,6 @@ void drm_helper_connector_dpms(struct drm_connector *connector, int mode) 
}

EXPORT_SYMBOL(drm_helper_connector_dpms);



/**

 * drm_hotplug_stage_two

 * @dev DRM device

 * @connector hotpluged connector

 *

 * LOCKING.

 * Caller must hold mode config lock, function might grab struct lock.

 *

 * Stage two of a hotplug.

 *

 * RETURNS:

 * Zero on success, errno on failure.

 */

int drm_helper_hotplug_stage_two(struct drm_device *dev)

{

	drm_helper_plugged_event(dev);



	return 0;

}

EXPORT_SYMBOL(drm_helper_hotplug_stage_two);



int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,

				   struct drm_mode_fb_cmd *mode_cmd)

{

drivers/gpu/drm/drm_fb_helper.c

+650 −263

File changed.

Preview size limit exceeded, changes collapsed.

drivers/gpu/drm/i915/i915_dma.c

+1 −1
Original line number Diff line number Diff line
@@ -1492,7 +1492,7 @@ static int i915_load_modeset_init(struct drm_device *dev, 


	I915_WRITE(INSTPM, (1 << 5) | (1 << 21));



	drm_helper_initial_config(dev);

	intel_fbdev_init(dev);



	return 0;