WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/radeon_display.c

 static void radeon_crtc_destroy(struct drm_crtc *crtc)
+{
-	struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
-	if (radeon_crtc->mode_set.mode) {
-		drm_mode_destroy(crtc->dev, radeon_crtc->mode_set.mode);
+	struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
 	drm_crtc_cleanup(crtc);
 	kfree(radeon_crtc);
+}
 static const struct drm_crtc_funcs radeon_crtc_funcs = {
 //   .cursor_set = radeon_crtc_cursor_set,
-//   .cursor_move = radeon_crtc_cursor_move,
+	.cursor_move = radeon_crtc_cursor_move,
 	.gamma_set = radeon_crtc_gamma_set,
+{
 	struct radeon_device *rdev = dev->dev_private;
 	struct radeon_crtc *radeon_crtc;
 	int i;
-    ENTRY();
 	radeon_crtc = kzalloc(sizeof(struct radeon_crtc) + (RADEONFB_CONN_LIMIT * sizeof(struct drm_connector *)), GFP_KERNEL);
 	if (radeon_crtc == NULL)
 		return;
 	drm_crtc_init(dev, &radeon_crtc->base, &radeon_crtc_funcs);
+	drm_mode_crtc_set_gamma_size(&radeon_crtc->base, 256);
 	radeon_crtc->crtc_id = index;
-	drm_mode_crtc_set_gamma_size(&radeon_crtc->base, 256);
+	rdev->mode_info.crtcs[index] = radeon_crtc;
 	radeon_crtc->crtc_id = index;
+#if 0
 	radeon_crtc->mode_set.crtc = &radeon_crtc->base;
-	radeon_crtc->mode_set.crtc = &radeon_crtc->base;
+	radeon_crtc->mode_set.connectors = (struct drm_connector **)(radeon_crtc + 1);
-	radeon_crtc->mode_set.connectors = (struct drm_connector **)(radeon_crtc + 1);
+	radeon_crtc->mode_set.num_connectors = 0;
-	radeon_crtc->mode_set.num_connectors = 0;
+#endif
 	if (rdev->is_atom_bios && (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom))
 		radeon_atombios_init_crtc(dev, radeon_crtc);
 	else
-		radeon_legacy_init_crtc(dev, radeon_crtc);
-    LEAVE();
+		radeon_legacy_init_crtc(dev, radeon_crtc);
+}
 static const char *encoder_names[34] = {
+		}
 		i++;
+	}
+}
-bool radeon_setup_enc_conn(struct drm_device *dev)
+static bool radeon_setup_enc_conn(struct drm_device *dev)
+{
 	struct radeon_device *rdev = dev->dev_private;
 	struct drm_connector *drm_connector;
-	bool ret = false;
-    ENTRY();
+	bool ret = false;
 	if (rdev->bios) {
 		if (rdev->is_atom_bios) {
 			if (rdev->family >= CHIP_R600)
 	if (ret) {
 		radeon_print_display_setup(dev);
 		list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head)
 			radeon_ddc_dump(drm_connector);
+	}
-    LEAVE();
 	return ret;
+}
 	struct edid *edid;
 	int ret = 0;
 	if (!radeon_connector->ddc_bus)
+		return -1;
-		return -1;
+	if (!radeon_connector->edid) {
 	radeon_i2c_do_lock(radeon_connector, 1);
 	edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
+	radeon_i2c_do_lock(radeon_connector, 0);
+	} else
+		edid = radeon_connector->edid;
 	radeon_i2c_do_lock(radeon_connector, 0);
 	if (edid) {
 		/* update digital bits here */
 		if (edid->input & DRM_EDID_INPUT_DIGITAL)
 			radeon_connector->use_digital = 1;
 		ret = drm_add_edid_modes(&radeon_connector->base, edid);
 		kfree(edid);
 		return ret;
+	}
 	drm_mode_connector_update_edid_property(&radeon_connector->base, NULL);
-	return -1;
+	return 0;
+}
 static int radeon_ddc_dump(struct drm_connector *connector)
+{
 					frac_feedback_div = (min_frac_feed_div + max_frac_feed_div) / 2;
 					tmp = (uint64_t)pll->reference_freq * 10000 * feedback_div;
 					tmp += (uint64_t)pll->reference_freq * 1000 * frac_feedback_div;
 					current_freq = radeon_div(tmp, ref_div * post_div);
+					if (flags & RADEON_PLL_PREFER_CLOSEST_LOWER) {
+						error = freq - current_freq;
+						error = error < 0 ? 0xffffffff : error;
 					} else
 					error = abs(current_freq - freq);
 					vco_diff = abs(vco - best_vco);
 	*frac_fb_div_p = best_frac_feedback_div;
 	*ref_div_p = best_ref_div;
 	*post_div_p = best_post_div;
+}
 static void radeon_user_framebuffer_destroy(struct drm_framebuffer *fb)
+{
 	struct radeon_framebuffer *radeon_fb = to_radeon_framebuffer(fb);
 static const struct drm_framebuffer_funcs radeon_fb_funcs = {
 	.destroy = radeon_user_framebuffer_destroy,
     .create_handle = radeon_user_framebuffer_create_handle,
 };
 struct drm_framebuffer *
 radeon_framebuffer_create(struct drm_device *dev,
 			  struct drm_mode_fb_cmd *mode_cmd,
 			  struct drm_gem_object *obj)
 //   obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle);
 //
 //   return radeon_framebuffer_create(dev, mode_cmd, obj);
+}
 static const struct drm_mode_config_funcs radeon_mode_funcs = {
  //  .fb_create = radeon_user_framebuffer_create,
      .fb_changed = radeonfb_probe,
+};
+struct drm_prop_enum_list {
+	int type;
+	char *name;
+};
+static struct drm_prop_enum_list radeon_tmds_pll_enum_list[] =
+{	{ 0, "driver" },
+	{ 1, "bios" },
+};
+static struct drm_prop_enum_list radeon_tv_std_enum_list[] =
+{	{ TV_STD_NTSC, "ntsc" },
+	{ TV_STD_PAL, "pal" },
+	{ TV_STD_PAL_M, "pal-m" },
+	{ TV_STD_PAL_60, "pal-60" },
+	{ TV_STD_NTSC_J, "ntsc-j" },
+	{ TV_STD_SCART_PAL, "scart-pal" },
+	{ TV_STD_PAL_CN, "pal-cn" },
+	{ TV_STD_SECAM, "secam" },
 };
+int radeon_modeset_create_props(struct radeon_device *rdev)
+{
+	int i, sz;
+	if (rdev->is_atom_bios) {
+		rdev->mode_info.coherent_mode_property =
+			drm_property_create(rdev->ddev,
+					    DRM_MODE_PROP_RANGE,
+					    "coherent", 2);
+		if (!rdev->mode_info.coherent_mode_property)
+			return -ENOMEM;
+		rdev->mode_info.coherent_mode_property->values[0] = 0;
+		rdev->mode_info.coherent_mode_property->values[0] = 1;
+	}
+	if (!ASIC_IS_AVIVO(rdev)) {
+		sz = ARRAY_SIZE(radeon_tmds_pll_enum_list);
+		rdev->mode_info.tmds_pll_property =
+			drm_property_create(rdev->ddev,
+					    DRM_MODE_PROP_ENUM,
+					    "tmds_pll", sz);
+		for (i = 0; i < sz; i++) {
+			drm_property_add_enum(rdev->mode_info.tmds_pll_property,
+					      i,
+					      radeon_tmds_pll_enum_list[i].type,
+					      radeon_tmds_pll_enum_list[i].name);
+		}
+	}
+	rdev->mode_info.load_detect_property =
+		drm_property_create(rdev->ddev,
+				    DRM_MODE_PROP_RANGE,
+				    "load detection", 2);
+	if (!rdev->mode_info.load_detect_property)
+		return -ENOMEM;
+	rdev->mode_info.load_detect_property->values[0] = 0;
+	rdev->mode_info.load_detect_property->values[0] = 1;
+	drm_mode_create_scaling_mode_property(rdev->ddev);
+	sz = ARRAY_SIZE(radeon_tv_std_enum_list);
+	rdev->mode_info.tv_std_property =
+		drm_property_create(rdev->ddev,
+				    DRM_MODE_PROP_ENUM,
+				    "tv standard", sz);
+	for (i = 0; i < sz; i++) {
-int radeon_modeset_init(struct radeon_device *rdev)
+		drm_property_add_enum(rdev->mode_info.tv_std_property,
+				      i,
+				      radeon_tv_std_enum_list[i].type,
+				      radeon_tv_std_enum_list[i].name);
+	}
+	return 0;
+}
-    dbgprintf("%s\n",__FUNCTION__);
+int radeon_modeset_init(struct radeon_device *rdev)
+{
 		rdev->ddev->mode_config.max_height = 4096;
+	}
+	rdev->ddev->mode_config.fb_base = rdev->mc.aper_base;
+	ret = radeon_modeset_create_props(rdev);
+	if (ret) {
-	rdev->ddev->mode_config.fb_base = rdev->mc.aper_base;
+		return ret;
+	}
 	/* allocate crtcs - TODO single crtc */
 	for (i = 0; i < num_crtc; i++) {
 	ret = radeon_setup_enc_conn(rdev->ddev);
 	if (!ret) {
 		return ret;
+	}
 	drm_helper_initial_config(rdev->ddev);
-    dbgprintf("done %s\n",__FUNCTION__);
 	return 0;
+}
 void radeon_modeset_fini(struct radeon_device *rdev)
 		drm_mode_config_cleanup(rdev->ddev);
 		rdev->mode_info.mode_config_initialized = false;
+	}
+}
+bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
+				struct drm_display_mode *mode,
-void radeon_init_disp_bandwidth(struct drm_device *dev)
+				struct drm_display_mode *adjusted_mode)
 {
-	struct radeon_device *rdev = dev->dev_private;
-	struct drm_display_mode *modes[2];
-	int pixel_bytes[2];
+	struct drm_device *dev = crtc->dev;
-	struct drm_crtc *crtc;
-	pixel_bytes[0] = pixel_bytes[1] = 0;
-	modes[0] = modes[1] = NULL;
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+	struct drm_encoder *encoder;
+		struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+	struct radeon_encoder *radeon_encoder;
+	bool first = true;
-		struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
+	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+		radeon_encoder = to_radeon_encoder(encoder);
+		if (encoder->crtc != crtc)
+			continue;
+		if (first) {
+			radeon_crtc->rmx_type = radeon_encoder->rmx_type;
+			memcpy(&radeon_crtc->native_mode,
+				&radeon_encoder->native_mode,
+				sizeof(struct radeon_native_mode));
-		if (crtc->enabled && crtc->fb) {
+			first = false;
+		} else {
+			if (radeon_crtc->rmx_type != radeon_encoder->rmx_type) {
+				/* WARNING: Right now this can't happen but
+				 * in the future we need to check that scaling
+				 * are consistent accross different encoder
+				 * (ie all encoder can work with the same
+				 *  scaling).
+				 */
-			modes[radeon_crtc->crtc_id] = &crtc->mode;
+				DRM_ERROR("Scaling not consistent accross encoder.\n");
-			pixel_bytes[radeon_crtc->crtc_id] = crtc->fb->bits_per_pixel / 8;
+				return false;
-		}
+			}
-	}
+		}
+	}
-	if (ASIC_IS_AVIVO(rdev)) {
+	if (radeon_crtc->rmx_type != RMX_OFF) {
+		fixed20_12 a, b;
-		radeon_init_disp_bw_avivo(dev,
+		a.full = rfixed_const(crtc->mode.vdisplay);
-					  modes[0],
+		b.full = rfixed_const(radeon_crtc->native_mode.panel_xres);
+		radeon_crtc->vsc.full = rfixed_div(a, b);
-					  pixel_bytes[0],
+		a.full = rfixed_const(crtc->mode.hdisplay);
-					  modes[1],
+		b.full = rfixed_const(radeon_crtc->native_mode.panel_yres);
-					  pixel_bytes[1]);
+		radeon_crtc->hsc.full = rfixed_div(a, b);
-	} else {
-		radeon_init_disp_bw_legacy(dev,
-					   modes[0],
-					   pixel_bytes[0],
+	} else {
-					   modes[1],
+		radeon_crtc->vsc.full = rfixed_const(1);
+		radeon_crtc->hsc.full = rfixed_const(1);
 					   pixel_bytes[1]);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_display.c – Rev 1126 → 1179