WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_fb_helper.c

+ *
  * The fb helper functions are useful to provide an fbdev on top of a drm kernel
  * mode setting driver. They can be used mostly independantely from the crtc
  * helper functions used by many drivers to implement the kernel mode setting
  * interfaces.
+ *
+ * Initialization is done as a three-step process with drm_fb_helper_init(),
+ * drm_fb_helper_single_add_all_connectors() and drm_fb_helper_initial_config().
+ * Drivers with fancier requirements than the default beheviour can override the
+ * second step with their own code.  Teardown is done with drm_fb_helper_fini().
+ *
+ * At runtime drivers should restore the fbdev console by calling
+ * drm_fb_helper_restore_fbdev_mode() from their ->lastclose callback. They
+ * should also notify the fb helper code from updates to the output
+ * configuration by calling drm_fb_helper_hotplug_event(). For easier
+ * integration with the output polling code in drm_crtc_helper.c the modeset
+ * code proves a ->output_poll_changed callback.
+ *
+ * All other functions exported by the fb helper library can be used to
+ * implement the fbdev driver interface by the driver.
  */
+/**
+ * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev
+ * 					       emulation helper
+ * @fb_helper: fbdev initialized with drm_fb_helper_init
+ *
+ * This functions adds all the available connectors for use with the given
+ * fb_helper. This is a separate step to allow drivers to freely assign
+ * connectors to the fbdev, e.g. if some are reserved for special purposes or
+ * not adequate to be used for the fbcon.
+ *
+ * Since this is part of the initial setup before the fbdev is published, no
+ * locking is required.
-/* simple single crtc case helper function */
+ */
 int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
+{
 	struct drm_device *dev = fb_helper->dev;
 	struct drm_connector *connector;
 	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
+}
+static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
+{
+	struct drm_device *dev = fb_helper->dev;
+	struct drm_crtc *crtc;
+	int bound = 0, crtcs_bound = 0;
+	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+		if (crtc->fb)
+			crtcs_bound++;
+		if (crtc->fb == fb_helper->fb)
+			bound++;
+	}
+	if (bound < crtcs_bound)
 		return false;
 	return true;
+}
 static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
+{
 	struct drm_fb_helper *fb_helper = info->par;
 	struct drm_device *dev = fb_helper->dev;
+	struct drm_crtc *crtc;
+	struct drm_connector *connector;
+	int i, j;
+	/*
+	 * fbdev->blank can be called from irq context in case of a panic.
-	struct drm_crtc *crtc;
+	 * Since we already have our own special panic handler which will
-	struct drm_connector *connector;
+	 * restore the fbdev console mode completely, just bail out early.
+	 */
-	int i, j;
+	/*
+	 * For each CRTC in this fb, turn the connectors on/off.
+	 */
+	drm_modeset_lock_all(dev);
 	if (!drm_fb_helper_is_bound(fb_helper)) {
-	/*
+		drm_modeset_unlock_all(dev);
-	 * For each CRTC in this fb, turn the connectors on/off.
+		return;
 	 */
 			connector->funcs->dpms(connector, dpms_mode);
 			drm_object_property_set_value(&connector->base,
 				dev->mode_config.dpms_property, dpms_mode);
+		}
+	}
-				mutex_unlock(&dev->mode_config.mutex);
+	drm_modeset_unlock_all(dev);
+}
+/**
+ * drm_fb_helper_blank - implementation for ->fb_blank
+ * @blank: desired blanking state
+ * @info: fbdev registered by the helper
  */
 int drm_fb_helper_blank(int blank, struct fb_info *info)
+{
 	switch (blank) {
 	/* Display: On; HSync: On, VSync: On */
 			drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
+	}
 	kfree(helper->crtc_info);
+}
+/**
+ * drm_fb_helper_init - initialize a drm_fb_helper structure
+ * @dev: drm device
+ * @fb_helper: driver-allocated fbdev helper structure to initialize
+ * @crtc_count: maximum number of crtcs to support in this fbdev emulation
+ * @max_conn_count: max connector count
+ *
+ * This allocates the structures for the fbdev helper with the given limits.
+ * Note that this won't yet touch the hardware (through the driver interfaces)
+ * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
+ * to allow driver writes more control over the exact init sequence.
+ *
+ * Drivers must set fb_helper->funcs before calling
+ * drm_fb_helper_initial_config().
+ *
+ * RETURNS:
+ * Zero if everything went ok, nonzero otherwise.
  */
 int drm_fb_helper_init(struct drm_device *dev,
 		       struct drm_fb_helper *fb_helper,
 		       int crtc_count, int max_conn_count)
+{
 	if (fb->depth != 16)
 		fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
 	return 0;
+}
+/**
+ * drm_fb_helper_setcmap - implementation for ->fb_setcmap
+ * @cmap: cmap to set
+ * @info: fbdev registered by the helper
  */
 int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
+{
 	struct drm_fb_helper *fb_helper = info->par;
 	struct drm_crtc_helper_funcs *crtc_funcs;
+	}
 	return rc;
+}
 EXPORT_SYMBOL(drm_fb_helper_setcmap);
+/**
+ * drm_fb_helper_check_var - implementation for ->fb_check_var
+ * @var: screeninfo to check
+ * @info: fbdev registered by the helper
  */
 int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
 			    struct fb_info *info)
+{
 	struct drm_fb_helper *fb_helper = info->par;
+	}
 	return 0;
+}
 EXPORT_SYMBOL(drm_fb_helper_check_var);
+/**
+ * drm_fb_helper_set_par - implementation for ->fb_set_par
+ * @info: fbdev registered by the helper
+ *
+ * This will let fbcon do the mode init and is called at initialization time by
+ * the fbdev core when registering the driver, and later on through the hotplug
+ * callback.
-/* this will let fbcon do the mode init */
+ */
 int drm_fb_helper_set_par(struct fb_info *info)
+{
 	struct drm_fb_helper *fb_helper = info->par;
 	struct drm_device *dev = fb_helper->dev;
-	struct fb_var_screeninfo *var = &info->var;
-	struct drm_crtc *crtc;
+	struct fb_var_screeninfo *var = &info->var;
 	int ret;
 	int i;
 	if (var->pixclock != 0) {
 		DRM_ERROR("PIXEL CLOCK SET\n");
 		return -EINVAL;
+	}
-	mutex_lock(&dev->mode_config.mutex);
-		for (i = 0; i < fb_helper->crtc_count; i++) {
+	drm_modeset_lock_all(dev);
-		crtc = fb_helper->crtc_info[i].mode_set.crtc;
+		for (i = 0; i < fb_helper->crtc_count; i++) {
-			ret = crtc->funcs->set_config(&fb_helper->crtc_info[i].mode_set);
+		ret = drm_mode_set_config_internal(&fb_helper->crtc_info[i].mode_set);
 		if (ret) {
-			mutex_unlock(&dev->mode_config.mutex);
+			drm_modeset_unlock_all(dev);
 				return ret;
+		}
+	}
-	mutex_unlock(&dev->mode_config.mutex);
+	drm_modeset_unlock_all(dev);
 	if (fb_helper->delayed_hotplug) {
 		fb_helper->delayed_hotplug = false;
-//       drm_fb_helper_hotplug_event(fb_helper);
+		drm_fb_helper_hotplug_event(fb_helper);
+	}
+	return 0;
+}
+EXPORT_SYMBOL(drm_fb_helper_set_par);
 /**
-	return 0;
+ * drm_fb_helper_pan_display - implementation for ->fb_pan_display
  * @var: updated screen information
-EXPORT_SYMBOL(drm_fb_helper_set_par);
+ * @info: fbdev registered by the helper
  */
 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
 			      struct fb_info *info)
+{
 	struct drm_fb_helper *fb_helper = info->par;
+	struct drm_device *dev = fb_helper->dev;
+	struct drm_mode_set *modeset;
-	struct drm_device *dev = fb_helper->dev;
+	struct drm_crtc *crtc;
+	int ret = 0;
+	int i;
-	struct drm_mode_set *modeset;
+	drm_modeset_lock_all(dev);
-	struct drm_crtc *crtc;
+	if (!drm_fb_helper_is_bound(fb_helper)) {
-	int ret = 0;
+		drm_modeset_unlock_all(dev);
-	int i;
+		return -EBUSY;
+	}
 	mutex_lock(&dev->mode_config.mutex);
 		for (i = 0; i < fb_helper->crtc_count; i++) {
 		crtc = fb_helper->crtc_info[i].mode_set.crtc;
 		modeset = &fb_helper->crtc_info[i].mode_set;
 		modeset->x = var->xoffset;
 		modeset->y = var->yoffset;
 		if (modeset->num_connectors) {
-			ret = crtc->funcs->set_config(modeset);
+			ret = drm_mode_set_config_internal(modeset);
 			if (!ret) {
+				info->var.xoffset = var->xoffset;
+				info->var.yoffset = var->yoffset;
+			}
+		}
+	}
-				info->var.xoffset = var->xoffset;
+	drm_modeset_unlock_all(dev);
-				info->var.yoffset = var->yoffset;
+	return ret;
+}
-		}
+EXPORT_SYMBOL(drm_fb_helper_pan_display);
-	mutex_unlock(&dev->mode_config.mutex);
+/*
-	return ret;
+ * Allocates the backing storage and sets up the fbdev info structure through
  * the ->fb_probe callback and then registers the fbdev and sets up the panic
-EXPORT_SYMBOL(drm_fb_helper_pan_display);
+ * notifier.
 		sizes.fb_width = sizes.surface_width = 1024;
 		sizes.fb_height = sizes.surface_height = 768;
+	}
 	/* push down into drivers */
-    new_fb = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
+	ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
-	if (new_fb < 0)
+	if (ret < 0)
-		return new_fb;
+		return ret;
+	info = fb_helper->fbdev;
+	/*
+	 * Set the fb pointer - usually drm_setup_crtcs does this for hotplug
+	 * events, but at init time drm_setup_crtcs needs to be called before
+	 * the fb is allocated (since we need to figure out the desired size of
-	info = fb_helper->fbdev;
+	 * the fb before we can allocate it ...). Hence we need to fix things up
+	 * here again.
 	 */
-	/* set the fb pointer */
-	for (i = 0; i < fb_helper->crtc_count; i++)
-		fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
-	if (new_fb) {
-		info->var.pixclock = 0;
-//       dev_info(fb_helper->dev->dev, "fb%d: %s frame buffer device\n",
-//               info->node, info->fix.id);
+	for (i = 0; i < fb_helper->crtc_count; i++)
-	} else {
+		if (fb_helper->crtc_info[i].mode_set.num_connectors)
-		drm_fb_helper_set_par(info);
+		fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
+		info->var.pixclock = 0;
+        list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
+	return 0;
+}
+/**
+ * drm_fb_helper_fill_fix - initializes fixed fbdev information
+ * @info: fbdev registered by the helper
+ * @pitch: desired pitch
+ * @depth: desired depth
+ *
-	if (new_fb)
+ * Helper to fill in the fixed fbdev information useful for a non-accelerated
-        list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
+ * fbdev emulations. Drivers which support acceleration methods which impose
  * additional constraints need to set up their own limits.
 	return 0;
 	info->fix.line_length = pitch;
 	return;
+}
 EXPORT_SYMBOL(drm_fb_helper_fill_fix);
+/**
+ * drm_fb_helper_fill_var - initalizes variable fbdev information
+ * @info: fbdev instance to set up
+ * @fb_helper: fb helper instance to use as template
+ * @fb_width: desired fb width
+ * @fb_height: desired fb height
+ *
+ * Sets up the variable fbdev metainformation from the given fb helper instance
+ * and the drm framebuffer allocated in fb_helper->fb.
+ *
+ * Drivers should call this (or their equivalent setup code) from their
+ * ->fb_probe callback after having allocated the fbdev backing
+ * storage framebuffer.
  */
 void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
 			    uint32_t fb_width, uint32_t fb_height)
+{
 	struct drm_framebuffer *fb = fb_helper->fb;
 	/* need to set the modesets up here for use later */
 	/* fill out the connector<->crtc mappings into the modesets */
 	for (i = 0; i < fb_helper->crtc_count; i++) {
 		modeset = &fb_helper->crtc_info[i].mode_set;
 		modeset->num_connectors = 0;
+		modeset->fb = NULL;
+	}
 	for (i = 0; i < fb_helper->connector_count; i++) {
 		struct drm_display_mode *mode = modes[i];
 			if (modeset->mode)
 				drm_mode_destroy(dev, modeset->mode);
 			modeset->mode = drm_mode_duplicate(dev,
 							   fb_crtc->desired_mode);
 			modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
+			modeset->fb = fb_helper->fb;
+		}
+	}
+	/* Clear out any old modes if there are no more connected outputs. */
+	for (i = 0; i < fb_helper->crtc_count; i++) {
+		modeset = &fb_helper->crtc_info[i].mode_set;
+		if (modeset->num_connectors == 0) {
+			BUG_ON(modeset->fb);
+			BUG_ON(modeset->num_connectors);
+			if (modeset->mode)
+				drm_mode_destroy(dev, modeset->mode);
+			modeset->mode = NULL;
+		}
+	}
 out:
 	kfree(crtcs);
 	kfree(modes);
 	kfree(enabled);
+}
 /**
- * drm_helper_initial_config - setup a sane initial connector configuration
+ * drm_fb_helper_initial_config - setup a sane initial connector configuration
  * @fb_helper: fb_helper device struct
- * @bpp_sel: bpp value to use for the framebuffer configuration
- *
- * LOCKING:
- * Called at init time by the driver to set up the @fb_helper initial
- * configuration, must take the mode config lock.
+ * @bpp_sel: bpp value to use for the framebuffer configuration
+ *
  * Scans the CRTCs and connectors and tries 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.
+ *
+ * Note that this also registers the fbdev and so allows userspace to call into
+ * the driver through the fbdev interfaces.
+ *
+ * This function will call down into the ->fb_probe callback to let
+ * the driver allocate and initialize the fbdev info structure and the drm
+ * framebuffer used to back the fbdev. drm_fb_helper_fill_var() and
+ * drm_fb_helper_fill_fix() are provided as helpers to setup simple default
- * a new framebuffer object as the backing store.
+ * values for the fbdev info structure.
+ *
  * RETURNS:
  * Zero if everything went ok, nonzero otherwise.
  */
 bool drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
+{
-	struct drm_device *dev = fb_helper->dev;
-	int count = 0;
-	/* disable all the possible outputs/crtcs before entering KMS mode */
+	struct drm_device *dev = fb_helper->dev;
-	drm_helper_disable_unused_functions(fb_helper->dev);
+	int count = 0;
 //   drm_fb_helper_parse_command_line(fb_helper);
 	return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
+}
-EXPORT_SYMBOL(drm_fb_helper_initial_config);
 EXPORT_SYMBOL(drm_fb_helper_initial_config);
 #if 0
 /**
  * drm_fb_helper_hotplug_event - respond to a hotplug notification by
  *                               probing all the outputs attached to the fb
- * @fb_helper: the drm_fb_helper
- *
- * LOCKING:
- * Called at runtime, must take mode config lock.
+ * @fb_helper: the drm_fb_helper
+ *
  * Scan the connectors attached to the fb_helper and try to put together a
+ * setup after *notification of a change in output configuration.
+ *
+ * Called at runtime, takes the mode config locks to be able to check/change the
+ * modeset configuration. Must be run from process context (which usually means
+ * either the output polling work or a work item launched from the driver's
+ * hotplug interrupt).
+ *
+ * Note that the driver must ensure that this is only called _after_ the fb has
- * setup after *notification of a change in output configuration.
+ * been fully set up, i.e. after the call to drm_fb_helper_initial_config.
+ *
  * RETURNS:
  * 0 on success and a non-zero error code otherwise.
  */
 int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
+{
 	struct drm_device *dev = fb_helper->dev;
-	int count = 0;
-	u32 max_width, max_height, bpp_sel;
-	int bound = 0, crtcs_bound = 0;
+	int count = 0;
-	struct drm_crtc *crtc;
+	u32 max_width, max_height, bpp_sel;
-	if (!fb_helper->fb)
-		return 0;
-	mutex_lock(&dev->mode_config.mutex);
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
-		if (crtc->fb)
-			crtcs_bound++;
-		if (crtc->fb == fb_helper->fb)
+	if (!fb_helper->fb)
-			bound++;
+		return 0;
-	}
 	mutex_lock(&fb_helper->dev->mode_config.mutex);
-	if (bound < crtcs_bound) {
+	if (!drm_fb_helper_is_bound(fb_helper)) {
 		fb_helper->delayed_hotplug = true;
-		mutex_unlock(&dev->mode_config.mutex);
+		mutex_unlock(&fb_helper->dev->mode_config.mutex);
 		return 0;
+	}
 	DRM_DEBUG_KMS("\n");
+	max_width = fb_helper->fb->width;
+	max_height = fb_helper->fb->height;
+	bpp_sel = fb_helper->fb->bits_per_pixel;
 	max_width = fb_helper->fb->width;
+	count = drm_fb_helper_probe_connector_modes(fb_helper, max_width,
-	max_height = fb_helper->fb->height;
+						    max_height);
-	bpp_sel = fb_helper->fb->bits_per_pixel;
+	mutex_unlock(&fb_helper->dev->mode_config.mutex);
-	count = drm_fb_helper_probe_connector_modes(fb_helper, max_width,
+	drm_modeset_lock_all(dev);
-						    max_height);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_fb_helper.c – Rev 3298 → 3480