Re: [PATCH v4 9/9] drm/i915: Convert intel_sdvo connector properties to atomic.

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Wed, Apr 12, 2017 at 12:50:07PM +0200, Maarten Lankhorst wrote:
> SDVO was the last connector that's still using the legacy paths
> for properties, and this is with a reason!
> 
> This connector implements a lot of properties dynamically,
> and some of them shared with the digital connector state,
> so sdvo_connector_state subclasses intel_digital_connector_state.
> 
> set_property had a lot of validation, but this is handled in the
> drm core, so most of the validation can die off. The properties
> are written right before enabling the connector, since there is no
> good way to update the properties without crtc.
> 
> Signed-off-by: Maarten Lankhorst <maarten.lankhorst@xxxxxxxxxxxxxxx>

Yeah, somewhat silly that we can't just reuse the core decoding for all of
these, but oh well. For the series, except where I dropped some comments

Reviewed-by: Daniel Vetter <daniel.vetter@xxxxxxxx>

For the others r-b once those comments are addressed, I don't expect a
huge impact on those (e.g. as long as we register the scaling property
from within panel_init you can keep the allowed_pfit_mode_mask stuff
you're adding here).
-Daniel


> ---
>  drivers/gpu/drm/i915/intel_atomic.c  |  40 ---
>  drivers/gpu/drm/i915/intel_display.c |  37 ---
>  drivers/gpu/drm/i915/intel_drv.h     |   6 -
>  drivers/gpu/drm/i915/intel_sdvo.c    | 538 ++++++++++++++++++-----------------
>  4 files changed, 281 insertions(+), 340 deletions(-)
> 
> diff --git a/drivers/gpu/drm/i915/intel_atomic.c b/drivers/gpu/drm/i915/intel_atomic.c
> index eb72166675f0..f068b623cf10 100644
> --- a/drivers/gpu/drm/i915/intel_atomic.c
> +++ b/drivers/gpu/drm/i915/intel_atomic.c
> @@ -36,46 +36,6 @@
>  #include "intel_drv.h"
>  
>  /**
> - * intel_connector_atomic_get_property - fetch legacy connector property value
> - * @connector: connector to fetch property for
> - * @state: state containing the property value
> - * @property: property to look up
> - * @val: pointer to write property value into
> - *
> - * The DRM core does not store shadow copies of properties for
> - * atomic-capable drivers.  This entrypoint is used to fetch
> - * the current value of a driver-specific connector property.
> - *
> - * This is a intermediary solution until all connectors are
> - * converted to support full atomic properties.
> - */
> -int intel_connector_atomic_get_property(struct drm_connector *connector,
> -					const struct drm_connector_state *state,
> -					struct drm_property *property,
> -					uint64_t *val)
> -{
> -	int i;
> -
> -	/*
> -	 * TODO: We only have atomic modeset for planes at the moment, so the
> -	 * crtc/connector code isn't quite ready yet.  Until it's ready,
> -	 * continue to look up all property values in the DRM's shadow copy
> -	 * in obj->properties->values[].
> -	 *
> -	 * When the crtc/connector state work matures, this function should
> -	 * be updated to read the values out of the state structure instead.
> -	 */
> -	for (i = 0; i < connector->base.properties->count; i++) {
> -		if (connector->base.properties->properties[i] == property) {
> -			*val = connector->base.properties->values[i];
> -			return 0;
> -		}
> -	}
> -
> -	return -EINVAL;
> -}
> -
> -/**
>   * intel_digital_connector_atomic_get_property - hook for connector->atomic_get_property.
>   * @connector: Connector to get the property for.
>   * @state: Connector state to retrieve the property from.
> diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
> index 5eb4ddb04797..c2c367b90c0a 100644
> --- a/drivers/gpu/drm/i915/intel_display.c
> +++ b/drivers/gpu/drm/i915/intel_display.c
> @@ -13075,43 +13075,6 @@ static int intel_atomic_commit(struct drm_device *dev,
>  	return 0;
>  }
>  
> -void intel_crtc_restore_mode(struct drm_crtc *crtc)
> -{
> -	struct drm_device *dev = crtc->dev;
> -	struct drm_atomic_state *state;
> -	struct drm_crtc_state *crtc_state;
> -	int ret;
> -
> -	state = drm_atomic_state_alloc(dev);
> -	if (!state) {
> -		DRM_DEBUG_KMS("[CRTC:%d:%s] crtc restore failed, out of memory",
> -			      crtc->base.id, crtc->name);
> -		return;
> -	}
> -
> -	state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
> -
> -retry:
> -	crtc_state = drm_atomic_get_crtc_state(state, crtc);
> -	ret = PTR_ERR_OR_ZERO(crtc_state);
> -	if (!ret) {
> -		if (!crtc_state->active)
> -			goto out;
> -
> -		crtc_state->mode_changed = true;
> -		ret = drm_atomic_commit(state);
> -	}
> -
> -	if (ret == -EDEADLK) {
> -		drm_atomic_state_clear(state);
> -		drm_modeset_backoff(state->acquire_ctx);
> -		goto retry;
> -	}
> -
> -out:
> -	drm_atomic_state_put(state);
> -}
> -
>  static const struct drm_crtc_funcs intel_crtc_funcs = {
>  	.gamma_set = drm_atomic_helper_legacy_gamma_set,
>  	.set_config = drm_atomic_helper_set_config,
> diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
> index d1bba4790eae..d2118413dd18 100644
> --- a/drivers/gpu/drm/i915/intel_drv.h
> +++ b/drivers/gpu/drm/i915/intel_drv.h
> @@ -1318,7 +1318,6 @@ unsigned int intel_rotation_info_size(const struct intel_rotation_info *rot_info
>  bool intel_has_pending_fb_unpin(struct drm_i915_private *dev_priv);
>  void intel_mark_busy(struct drm_i915_private *dev_priv);
>  void intel_mark_idle(struct drm_i915_private *dev_priv);
> -void intel_crtc_restore_mode(struct drm_crtc *crtc);
>  int intel_display_suspend(struct drm_device *dev);
>  void intel_pps_unlock_regs_wa(struct drm_i915_private *dev_priv);
>  void intel_encoder_destroy(struct drm_encoder *encoder);
> @@ -1879,11 +1878,6 @@ void intel_pipe_update_end(struct intel_crtc *crtc, struct intel_flip_work *work
>  void intel_tv_init(struct drm_i915_private *dev_priv);
>  
>  /* intel_atomic.c */
> -int intel_connector_atomic_get_property(struct drm_connector *connector,
> -					const struct drm_connector_state *state,
> -					struct drm_property *property,
> -					uint64_t *val);
> -
>  int intel_digital_connector_atomic_get_property(struct drm_connector *connector,
>  						const struct drm_connector_state *state,
>  						struct drm_property *property,
> diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
> index 9855e4d48542..0aac7ce2b218 100644
> --- a/drivers/gpu/drm/i915/intel_sdvo.c
> +++ b/drivers/gpu/drm/i915/intel_sdvo.c
> @@ -100,18 +100,6 @@ struct intel_sdvo {
>  	uint16_t hotplug_active;
>  
>  	/**
> -	 * This is used to select the color range of RBG outputs in HDMI mode.
> -	 * It is only valid when using TMDS encoding and 8 bit per color mode.
> -	 */
> -	uint32_t color_range;
> -	bool color_range_auto;
> -
> -	/**
> -	 * HDMI user specified aspect ratio
> -	 */
> -	enum hdmi_picture_aspect aspect_ratio;
> -
> -	/**
>  	 * This is set if we're going to treat the device as TV-out.
>  	 *
>  	 * While we have these nice friendly flags for output types that ought
> @@ -122,9 +110,6 @@ struct intel_sdvo {
>  
>  	enum port port;
>  
> -	/* This is for current tv format name */
> -	int tv_format_index;
> -
>  	/**
>  	 * This is set if we treat the device as HDMI, instead of DVI.
>  	 */
> @@ -159,8 +144,6 @@ struct intel_sdvo_connector {
>  	/* Mark the type of connector */
>  	uint16_t output_flag;
>  
> -	enum hdmi_force_audio force_audio;
> -
>  	/* This contains all current supported TV format */
>  	u8 tv_format_supported[TV_FORMAT_NUM];
>  	int   format_supported_num;
> @@ -187,24 +170,19 @@ struct intel_sdvo_connector {
>  	/* add the property for the SDVO-TV/LVDS */
>  	struct drm_property *brightness;
>  
> -	/* Add variable to record current setting for the above property */
> -	u32	left_margin, right_margin, top_margin, bottom_margin;
> -
>  	/* this is to get the range of margin.*/
> -	u32	max_hscan,  max_vscan;
> -	u32	max_hpos, cur_hpos;
> -	u32	max_vpos, cur_vpos;
> -	u32	cur_brightness, max_brightness;
> -	u32	cur_contrast,	max_contrast;
> -	u32	cur_saturation, max_saturation;
> -	u32	cur_hue,	max_hue;
> -	u32	cur_sharpness,	max_sharpness;
> -	u32	cur_flicker_filter,		max_flicker_filter;
> -	u32	cur_flicker_filter_adaptive,	max_flicker_filter_adaptive;
> -	u32	cur_flicker_filter_2d,		max_flicker_filter_2d;
> -	u32	cur_tv_chroma_filter,	max_tv_chroma_filter;
> -	u32	cur_tv_luma_filter,	max_tv_luma_filter;
> -	u32	cur_dot_crawl,	max_dot_crawl;
> +	u32 max_hscan, max_vscan;
> +};
> +
> +struct intel_sdvo_connector_state {
> +	/* base.base: tv.saturation/contrast/hue/brightness */
> +	struct intel_digital_connector_state base;
> +
> +	struct {
> +		unsigned overscan_h, overscan_v, hpos, vpos, sharpness;
> +		unsigned flicker_filter, flicker_filter_2d, flicker_filter_adaptive;
> +		unsigned chroma_filter, luma_filter, dot_crawl;
> +	} tv;
>  };
>  
>  static struct intel_sdvo *to_sdvo(struct intel_encoder *encoder)
> @@ -217,9 +195,16 @@ static struct intel_sdvo *intel_attached_sdvo(struct drm_connector *connector)
>  	return to_sdvo(intel_attached_encoder(connector));
>  }
>  
> -static struct intel_sdvo_connector *to_intel_sdvo_connector(struct drm_connector *connector)
> +static struct intel_sdvo_connector *
> +to_intel_sdvo_connector(struct drm_connector *connector)
>  {
> -	return container_of(to_intel_connector(connector), struct intel_sdvo_connector, base);
> +	return container_of(connector, struct intel_sdvo_connector, base.base);
> +}
> +
> +static struct intel_sdvo_connector_state *
> +to_intel_sdvo_connector_state(struct drm_connector_state *conn_state)
> +{
> +	return container_of(conn_state, struct intel_sdvo_connector_state, base.base);
>  }
>  
>  static bool
> @@ -1035,12 +1020,13 @@ static bool intel_sdvo_set_avi_infoframe(struct intel_sdvo *intel_sdvo,
>  					  sdvo_data, sizeof(sdvo_data));
>  }
>  
> -static bool intel_sdvo_set_tv_format(struct intel_sdvo *intel_sdvo)
> +static bool intel_sdvo_set_tv_format(struct intel_sdvo *intel_sdvo,
> +				     struct drm_connector_state *conn_state)
>  {
>  	struct intel_sdvo_tv_format format;
>  	uint32_t format_map;
>  
> -	format_map = 1 << intel_sdvo->tv_format_index;
> +	format_map = 1 << conn_state->tv.mode;
>  	memset(&format, 0, sizeof(format));
>  	memcpy(&format, &format_map, min(sizeof(format), sizeof(format_map)));
>  
> @@ -1127,8 +1113,8 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder,
>  				      struct drm_connector_state *conn_state)
>  {
>  	struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
> -	struct intel_sdvo_connector *intel_sdvo_connector =
> -		to_intel_sdvo_connector(conn_state->connector);
> +	struct intel_sdvo_connector_state *intel_sdvo_state =
> +		to_intel_sdvo_connector_state(conn_state);
>  	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
>  	struct drm_display_mode *mode = &pipe_config->base.mode;
>  
> @@ -1167,14 +1153,14 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder,
>  	pipe_config->pixel_multiplier =
>  		intel_sdvo_get_pixel_multiplier(adjusted_mode);
>  
> -	if (intel_sdvo_connector->force_audio != HDMI_AUDIO_OFF_DVI)
> +	if (intel_sdvo_state->base.force_audio != HDMI_AUDIO_OFF_DVI)
>  		pipe_config->has_hdmi_sink = intel_sdvo->has_hdmi_monitor;
>  
> -	if (intel_sdvo_connector->force_audio == HDMI_AUDIO_ON ||
> -	    (intel_sdvo_connector->force_audio == HDMI_AUDIO_AUTO && intel_sdvo->has_hdmi_audio))
> +	if (intel_sdvo_state->base.force_audio == HDMI_AUDIO_ON ||
> +	    (intel_sdvo_state->base.force_audio == HDMI_AUDIO_AUTO && intel_sdvo->has_hdmi_audio))
>  		pipe_config->has_audio = true;
>  
> -	if (intel_sdvo->color_range_auto) {
> +	if (intel_sdvo_state->base.broadcast_rgb == INTEL_BROADCAST_RGB_AUTO) {
>  		/* See CEA-861-E - 5.1 Default Encoding Parameters */
>  		/* FIXME: This bit is only valid when using TMDS encoding and 8
>  		 * bit per color mode. */
> @@ -1183,7 +1169,7 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder,
>  			pipe_config->limited_color_range = true;
>  	} else {
>  		if (pipe_config->has_hdmi_sink &&
> -		    intel_sdvo->color_range == HDMI_COLOR_RANGE_16_235)
> +		    intel_sdvo_state->base.broadcast_rgb == INTEL_BROADCAST_RGB_LIMITED)
>  			pipe_config->limited_color_range = true;
>  	}
>  
> @@ -1193,11 +1179,73 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder,
>  
>  	/* Set user selected PAR to incoming mode's member */
>  	if (intel_sdvo->is_hdmi)
> -		adjusted_mode->picture_aspect_ratio = intel_sdvo->aspect_ratio;
> +		adjusted_mode->picture_aspect_ratio = conn_state->picture_aspect_ratio;
>  
>  	return true;
>  }
>  
> +#define UPDATE_PROPERTY(input, NAME) \
> +	do { \
> +		val = input; \
> +		intel_sdvo_set_value(intel_sdvo, SDVO_CMD_SET_##NAME, &val, sizeof(val)); \
> +	} while (0)
> +
> +static void intel_sdvo_update_props(struct intel_sdvo *intel_sdvo,
> +				    struct intel_sdvo_connector_state *sdvo_state)
> +{
> +	struct drm_connector_state *conn_state = &sdvo_state->base.base;
> +	struct intel_sdvo_connector *intel_sdvo_conn =
> +		to_intel_sdvo_connector(conn_state->connector);
> +	uint16_t val;
> +
> +	if (intel_sdvo_conn->left)
> +		UPDATE_PROPERTY(sdvo_state->tv.overscan_h, OVERSCAN_H);
> +
> +	if (intel_sdvo_conn->top)
> +		UPDATE_PROPERTY(sdvo_state->tv.overscan_v, OVERSCAN_V);
> +
> +	if (intel_sdvo_conn->hpos)
> +		UPDATE_PROPERTY(sdvo_state->tv.hpos, HPOS);
> +
> +	if (intel_sdvo_conn->vpos)
> +		UPDATE_PROPERTY(sdvo_state->tv.vpos, VPOS);
> +
> +	if (intel_sdvo_conn->saturation)
> +		UPDATE_PROPERTY(conn_state->tv.saturation, SATURATION);
> +
> +	if (intel_sdvo_conn->contrast)
> +		UPDATE_PROPERTY(conn_state->tv.contrast, CONTRAST);
> +
> +	if (intel_sdvo_conn->hue)
> +		UPDATE_PROPERTY(conn_state->tv.hue, HUE);
> +
> +	if (intel_sdvo_conn->brightness)
> +		UPDATE_PROPERTY(conn_state->tv.brightness, BRIGHTNESS);
> +
> +	if (intel_sdvo_conn->sharpness)
> +		UPDATE_PROPERTY(sdvo_state->tv.sharpness, SHARPNESS);
> +
> +	if (intel_sdvo_conn->flicker_filter)
> +		UPDATE_PROPERTY(sdvo_state->tv.flicker_filter, FLICKER_FILTER);
> +
> +	if (intel_sdvo_conn->flicker_filter_2d)
> +		UPDATE_PROPERTY(sdvo_state->tv.flicker_filter_2d, FLICKER_FILTER_2D);
> +
> +	if (intel_sdvo_conn->flicker_filter_adaptive)
> +		UPDATE_PROPERTY(sdvo_state->tv.flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE);
> +
> +	if (intel_sdvo_conn->tv_chroma_filter)
> +		UPDATE_PROPERTY(sdvo_state->tv.chroma_filter, TV_CHROMA_FILTER);
> +
> +	if (intel_sdvo_conn->tv_luma_filter)
> +		UPDATE_PROPERTY(sdvo_state->tv.luma_filter, TV_LUMA_FILTER);
> +
> +	if (intel_sdvo_conn->dot_crawl)
> +		UPDATE_PROPERTY(sdvo_state->tv.dot_crawl, DOT_CRAWL);
> +
> +#undef UPDATE_PROPERTY
> +}
> +
>  static void intel_sdvo_pre_enable(struct intel_encoder *intel_encoder,
>  				  struct intel_crtc_state *crtc_state,
>  				  struct drm_connector_state *conn_state)
> @@ -1205,6 +1253,7 @@ static void intel_sdvo_pre_enable(struct intel_encoder *intel_encoder,
>  	struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev);
>  	struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
>  	const struct drm_display_mode *adjusted_mode = &crtc_state->base.adjusted_mode;
> +	struct intel_sdvo_connector_state *sdvo_state = to_intel_sdvo_connector_state(conn_state);
>  	struct drm_display_mode *mode = &crtc_state->base.mode;
>  	struct intel_sdvo *intel_sdvo = to_sdvo(intel_encoder);
>  	u32 sdvox;
> @@ -1212,6 +1261,8 @@ static void intel_sdvo_pre_enable(struct intel_encoder *intel_encoder,
>  	struct intel_sdvo_dtd input_dtd, output_dtd;
>  	int rate;
>  
> +	intel_sdvo_update_props(intel_sdvo, sdvo_state);
> +
>  	/* First, set the input mapping for the first input to our controlled
>  	 * output. This is only correct if we're a single-input device, in
>  	 * which case the first input is the output from the appropriate SDVO
> @@ -1253,7 +1304,7 @@ static void intel_sdvo_pre_enable(struct intel_encoder *intel_encoder,
>  		intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_DVI);
>  
>  	if (intel_sdvo->is_tv &&
> -	    !intel_sdvo_set_tv_format(intel_sdvo))
> +	    !intel_sdvo_set_tv_format(intel_sdvo, conn_state))
>  		return;
>  
>  	intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
> @@ -1885,6 +1936,7 @@ static const struct drm_display_mode sdvo_tv_modes[] = {
>  static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
>  {
>  	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
> +	const struct drm_connector_state *conn_state = connector->state;
>  	struct intel_sdvo_sdtv_resolution_request tv_res;
>  	uint32_t reply = 0, format_map = 0;
>  	int i;
> @@ -1895,7 +1947,7 @@ static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
>  	/* Read the list of supported input resolutions for the selected TV
>  	 * format.
>  	 */
> -	format_map = 1 << intel_sdvo->tv_format_index;
> +	format_map = 1 << conn_state->tv.mode;
>  	memcpy(&tv_res, &format_map,
>  	       min(sizeof(format_map), sizeof(struct intel_sdvo_sdtv_resolution_request)));
>  
> @@ -1985,187 +2037,120 @@ static void intel_sdvo_destroy(struct drm_connector *connector)
>  }
>  
>  static int
> -intel_sdvo_set_property(struct drm_connector *connector,
> -			struct drm_property *property,
> -			uint64_t val)
> +intel_sdvo_connector_atomic_get_property(struct drm_connector *connector,
> +					 const struct drm_connector_state *state,
> +					 struct drm_property *property,
> +					 uint64_t *val)
>  {
> -	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
>  	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
> -	struct drm_i915_private *dev_priv = to_i915(connector->dev);
> -	uint16_t temp_value;
> -	uint8_t cmd;
> -	int ret;
> -
> -	ret = drm_object_property_set_value(&connector->base, property, val);
> -	if (ret)
> -		return ret;
> -
> -	if (property == dev_priv->force_audio_property) {
> -		int i = val;
> -		bool has_audio, old_audio;
> -
> -		if (intel_sdvo_connector->force_audio == HDMI_AUDIO_AUTO)
> -			old_audio = intel_sdvo->has_hdmi_audio;
> -		else
> -			old_audio = intel_sdvo_connector->force_audio == HDMI_AUDIO_ON;
> -
> -		if (i == HDMI_AUDIO_AUTO)
> -			has_audio = intel_sdvo->has_hdmi_audio;
> -		else
> -			has_audio = (i == HDMI_AUDIO_ON);
> -
> -		intel_sdvo_connector->force_audio = i;
> -
> -		if (has_audio == old_audio)
> -			return 0;
> -
> -		goto done;
> -	}
> -
> -	if (property == dev_priv->broadcast_rgb_property) {
> -		bool old_auto = intel_sdvo->color_range_auto;
> -		uint32_t old_range = intel_sdvo->color_range;
> -
> -		switch (val) {
> -		case INTEL_BROADCAST_RGB_AUTO:
> -			intel_sdvo->color_range_auto = true;
> -			break;
> -		case INTEL_BROADCAST_RGB_FULL:
> -			intel_sdvo->color_range_auto = false;
> -			intel_sdvo->color_range = 0;
> -			break;
> -		case INTEL_BROADCAST_RGB_LIMITED:
> -			intel_sdvo->color_range_auto = false;
> -			/* FIXME: this bit is only valid when using TMDS
> -			 * encoding and 8 bit per color mode. */
> -			intel_sdvo->color_range = HDMI_COLOR_RANGE_16_235;
> -			break;
> -		default:
> -			return -EINVAL;
> -		}
> -
> -		if (old_auto == intel_sdvo->color_range_auto &&
> -		    old_range == intel_sdvo->color_range)
> -			return 0;
> -
> -		goto done;
> -	}
> -
> -	if (property == connector->dev->mode_config.aspect_ratio_property) {
> -		switch (val) {
> -		case DRM_MODE_PICTURE_ASPECT_NONE:
> -			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_NONE;
> -			break;
> -		case DRM_MODE_PICTURE_ASPECT_4_3:
> -			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_4_3;
> -			break;
> -		case DRM_MODE_PICTURE_ASPECT_16_9:
> -			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_16_9;
> -			break;
> -		default:
> -			return -EINVAL;
> -		}
> -		goto done;
> -	}
> -
> -#define CHECK_PROPERTY(name, NAME) \
> -	if (intel_sdvo_connector->name == property) { \
> -		if (intel_sdvo_connector->cur_##name == temp_value) return 0; \
> -		if (intel_sdvo_connector->max_##name < temp_value) return -EINVAL; \
> -		cmd = SDVO_CMD_SET_##NAME; \
> -		intel_sdvo_connector->cur_##name = temp_value; \
> -		goto set_value; \
> -	}
> +	const struct intel_sdvo_connector_state *sdvo_state = to_intel_sdvo_connector_state((void *)state);
>  
>  	if (property == intel_sdvo_connector->tv_format) {
> -		if (val >= TV_FORMAT_NUM)
> -			return -EINVAL;
> -
> -		if (intel_sdvo->tv_format_index ==
> -		    intel_sdvo_connector->tv_format_supported[val])
> -			return 0;
> -
> -		intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[val];
> -		goto done;
> -	} else if (IS_TV_OR_LVDS(intel_sdvo_connector)) {
> -		temp_value = val;
> -		if (intel_sdvo_connector->left == property) {
> -			drm_object_property_set_value(&connector->base,
> -							 intel_sdvo_connector->right, val);
> -			if (intel_sdvo_connector->left_margin == temp_value)
> -				return 0;
> +		int i;
>  
> -			intel_sdvo_connector->left_margin = temp_value;
> -			intel_sdvo_connector->right_margin = temp_value;
> -			temp_value = intel_sdvo_connector->max_hscan -
> -				intel_sdvo_connector->left_margin;
> -			cmd = SDVO_CMD_SET_OVERSCAN_H;
> -			goto set_value;
> -		} else if (intel_sdvo_connector->right == property) {
> -			drm_object_property_set_value(&connector->base,
> -							 intel_sdvo_connector->left, val);
> -			if (intel_sdvo_connector->right_margin == temp_value)
> -				return 0;
> +		for (i = 0; i < intel_sdvo_connector->format_supported_num; i++)
> +			if (state->tv.mode == intel_sdvo_connector->tv_format_supported[i]) {
> +				*val = i;
>  
> -			intel_sdvo_connector->left_margin = temp_value;
> -			intel_sdvo_connector->right_margin = temp_value;
> -			temp_value = intel_sdvo_connector->max_hscan -
> -				intel_sdvo_connector->left_margin;
> -			cmd = SDVO_CMD_SET_OVERSCAN_H;
> -			goto set_value;
> -		} else if (intel_sdvo_connector->top == property) {
> -			drm_object_property_set_value(&connector->base,
> -							 intel_sdvo_connector->bottom, val);
> -			if (intel_sdvo_connector->top_margin == temp_value)
>  				return 0;
> +			}
>  
> -			intel_sdvo_connector->top_margin = temp_value;
> -			intel_sdvo_connector->bottom_margin = temp_value;
> -			temp_value = intel_sdvo_connector->max_vscan -
> -				intel_sdvo_connector->top_margin;
> -			cmd = SDVO_CMD_SET_OVERSCAN_V;
> -			goto set_value;
> -		} else if (intel_sdvo_connector->bottom == property) {
> -			drm_object_property_set_value(&connector->base,
> -							 intel_sdvo_connector->top, val);
> -			if (intel_sdvo_connector->bottom_margin == temp_value)
> -				return 0;
> +		WARN_ON(1);
> +		*val = 0;
> +	} else if (property == intel_sdvo_connector->top ||
> +		   property == intel_sdvo_connector->bottom)
> +		*val = intel_sdvo_connector->max_vscan - sdvo_state->tv.overscan_v;
> +	else if (property == intel_sdvo_connector->left ||
> +		 property == intel_sdvo_connector->right)
> +		*val = intel_sdvo_connector->max_hscan - sdvo_state->tv.overscan_h;
> +	else if (property == intel_sdvo_connector->hpos)
> +		*val = sdvo_state->tv.hpos;
> +	else if (property == intel_sdvo_connector->vpos)
> +		*val = sdvo_state->tv.vpos;
> +	else if (property == intel_sdvo_connector->saturation)
> +		*val = state->tv.saturation;
> +	else if (property == intel_sdvo_connector->contrast)
> +		*val = state->tv.contrast;
> +	else if (property == intel_sdvo_connector->hue)
> +		*val = state->tv.hue;
> +	else if (property == intel_sdvo_connector->brightness)
> +		*val = state->tv.brightness;
> +	else if (property == intel_sdvo_connector->sharpness)
> +		*val = sdvo_state->tv.sharpness;
> +	else if (property == intel_sdvo_connector->flicker_filter)
> +		*val = sdvo_state->tv.flicker_filter;
> +	else if (property == intel_sdvo_connector->flicker_filter_2d)
> +		*val = sdvo_state->tv.flicker_filter_2d;
> +	else if (property == intel_sdvo_connector->flicker_filter_adaptive)
> +		*val = sdvo_state->tv.flicker_filter_adaptive;
> +	else if (property == intel_sdvo_connector->tv_chroma_filter)
> +		*val = sdvo_state->tv.chroma_filter;
> +	else if (property == intel_sdvo_connector->tv_luma_filter)
> +		*val = sdvo_state->tv.luma_filter;
> +	else if (property == intel_sdvo_connector->dot_crawl)
> +		*val = sdvo_state->tv.dot_crawl;
> +	else
> +		return intel_digital_connector_atomic_get_property(connector, state, property, val);
>  
> -			intel_sdvo_connector->top_margin = temp_value;
> -			intel_sdvo_connector->bottom_margin = temp_value;
> -			temp_value = intel_sdvo_connector->max_vscan -
> -				intel_sdvo_connector->top_margin;
> -			cmd = SDVO_CMD_SET_OVERSCAN_V;
> -			goto set_value;
> -		}
> -		CHECK_PROPERTY(hpos, HPOS)
> -		CHECK_PROPERTY(vpos, VPOS)
> -		CHECK_PROPERTY(saturation, SATURATION)
> -		CHECK_PROPERTY(contrast, CONTRAST)
> -		CHECK_PROPERTY(hue, HUE)
> -		CHECK_PROPERTY(brightness, BRIGHTNESS)
> -		CHECK_PROPERTY(sharpness, SHARPNESS)
> -		CHECK_PROPERTY(flicker_filter, FLICKER_FILTER)
> -		CHECK_PROPERTY(flicker_filter_2d, FLICKER_FILTER_2D)
> -		CHECK_PROPERTY(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE)
> -		CHECK_PROPERTY(tv_chroma_filter, TV_CHROMA_FILTER)
> -		CHECK_PROPERTY(tv_luma_filter, TV_LUMA_FILTER)
> -		CHECK_PROPERTY(dot_crawl, DOT_CRAWL)
> -	}
> +	return 0;
> +}
>  
> -	return -EINVAL; /* unknown property */
> +static int
> +intel_sdvo_connector_atomic_set_property(struct drm_connector *connector,
> +					 struct drm_connector_state *state,
> +					 struct drm_property *property,
> +					 uint64_t val)
> +{
> +	struct intel_sdvo_connector *intel_sdvo_connector = to_intel_sdvo_connector(connector);
> +	struct intel_sdvo_connector_state *sdvo_state = to_intel_sdvo_connector_state(state);
>  
> -set_value:
> -	if (!intel_sdvo_set_value(intel_sdvo, cmd, &temp_value, 2))
> -		return -EIO;
> +	if (property == intel_sdvo_connector->tv_format) {
> +		state->tv.mode = intel_sdvo_connector->tv_format_supported[val];
>  
> +		if (state->crtc) {
> +			struct drm_crtc_state *crtc_state =
> +				drm_atomic_get_new_crtc_state(state->state, state->crtc);
>  
> -done:
> -	if (intel_sdvo->base.base.crtc)
> -		intel_crtc_restore_mode(intel_sdvo->base.base.crtc);
> +			crtc_state->connectors_changed = true;
> +		}
> +	} else if (property == intel_sdvo_connector->top ||
> +		   property == intel_sdvo_connector->bottom)
> +		/* Cannot set these independent from each other */
> +		sdvo_state->tv.overscan_v = intel_sdvo_connector->max_vscan - val;
> +	else if (property == intel_sdvo_connector->left ||
> +		 property == intel_sdvo_connector->right)
> +		/* Cannot set these independent from each other */
> +		sdvo_state->tv.overscan_h = intel_sdvo_connector->max_hscan - val;
> +	else if (property == intel_sdvo_connector->hpos)
> +		sdvo_state->tv.hpos = val;
> +	else if (property == intel_sdvo_connector->vpos)
> +		sdvo_state->tv.vpos = val;
> +	else if (property == intel_sdvo_connector->saturation)
> +		state->tv.saturation = val;
> +	else if (property == intel_sdvo_connector->contrast)
> +		state->tv.contrast = val;
> +	else if (property == intel_sdvo_connector->hue)
> +		state->tv.hue = val;
> +	else if (property == intel_sdvo_connector->brightness)
> +		state->tv.brightness = val;
> +	else if (property == intel_sdvo_connector->sharpness)
> +		sdvo_state->tv.sharpness = val;
> +	else if (property == intel_sdvo_connector->flicker_filter)
> +		sdvo_state->tv.flicker_filter = val;
> +	else if (property == intel_sdvo_connector->flicker_filter_2d)
> +		sdvo_state->tv.flicker_filter_2d = val;
> +	else if (property == intel_sdvo_connector->flicker_filter_adaptive)
> +		sdvo_state->tv.flicker_filter_adaptive = val;
> +	else if (property == intel_sdvo_connector->tv_chroma_filter)
> +		sdvo_state->tv.chroma_filter = val;
> +	else if (property == intel_sdvo_connector->tv_luma_filter)
> +		sdvo_state->tv.luma_filter = val;
> +	else if (property == intel_sdvo_connector->dot_crawl)
> +		sdvo_state->tv.dot_crawl = val;
> +	else
> +		return intel_digital_connector_atomic_set_property(connector, state, property, val);
>  
>  	return 0;
> -#undef CHECK_PROPERTY
>  }
>  
>  static int
> @@ -2193,22 +2178,61 @@ intel_sdvo_connector_unregister(struct drm_connector *connector)
>  	intel_connector_unregister(connector);
>  }
>  
> +static struct drm_connector_state *
> +intel_sdvo_connector_duplicate_state(struct drm_connector *connector)
> +{
> +	struct intel_sdvo_connector_state *state;
> +
> +	state = kmemdup(connector->state, sizeof(*state), GFP_KERNEL);
> +	if (!state)
> +		return NULL;
> +
> +	__drm_atomic_helper_connector_duplicate_state(connector, &state->base.base);
> +	return &state->base.base;
> +}
> +
>  static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
>  	.dpms = drm_atomic_helper_connector_dpms,
>  	.detect = intel_sdvo_detect,
>  	.fill_modes = drm_helper_probe_single_connector_modes,
> -	.set_property = intel_sdvo_set_property,
> -	.atomic_get_property = intel_connector_atomic_get_property,
> +	.set_property = drm_atomic_helper_connector_set_property,
> +	.atomic_get_property = intel_sdvo_connector_atomic_get_property,
> +	.atomic_set_property = intel_sdvo_connector_atomic_set_property,
>  	.late_register = intel_sdvo_connector_register,
>  	.early_unregister = intel_sdvo_connector_unregister,
>  	.destroy = intel_sdvo_destroy,
>  	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
> -	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
> +	.atomic_duplicate_state = intel_sdvo_connector_duplicate_state,
>  };
>  
> +static int intel_sdvo_atomic_check(struct drm_connector *conn,
> +				   struct drm_connector_state *new_conn_state)
> +{
> +	struct drm_atomic_state *state = new_conn_state->state;
> +	struct drm_connector_state *old_conn_state =
> +		drm_atomic_get_old_connector_state(state, conn);
> +	struct intel_sdvo_connector_state *old_state =
> +		to_intel_sdvo_connector_state(old_conn_state);
> +	struct intel_sdvo_connector_state *new_state =
> +		to_intel_sdvo_connector_state(new_conn_state);
> +
> +	if (new_conn_state->crtc &&
> +	    (memcmp(&old_state->tv, &new_state->tv, sizeof(old_state->tv)) ||
> +	     memcmp(&old_conn_state->tv, &new_conn_state->tv, sizeof(old_conn_state->tv)))) {
> +		struct drm_crtc_state *crtc_state =
> +			drm_atomic_get_new_crtc_state(new_conn_state->state,
> +						      new_conn_state->crtc);
> +
> +		crtc_state->connectors_changed = true;
> +	}
> +
> +	return intel_digital_connector_atomic_check(conn, new_conn_state);
> +}
> +
>  static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs = {
>  	.get_modes = intel_sdvo_get_modes,
>  	.mode_valid = intel_sdvo_mode_valid,
> +	.atomic_check = intel_sdvo_atomic_check,
>  };
>  
>  static void intel_sdvo_enc_destroy(struct drm_encoder *encoder)
> @@ -2400,25 +2424,28 @@ intel_sdvo_add_hdmi_properties(struct intel_sdvo *intel_sdvo,
>  	intel_attach_force_audio_property(&connector->base.base);
>  	if (INTEL_GEN(dev_priv) >= 4 && IS_MOBILE(dev_priv)) {
>  		intel_attach_broadcast_rgb_property(&connector->base.base);
> -		intel_sdvo->color_range_auto = true;
>  	}
>  	intel_attach_aspect_ratio_property(&connector->base.base);
> -	intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_NONE;
>  }
>  
>  static struct intel_sdvo_connector *intel_sdvo_connector_alloc(void)
>  {
>  	struct intel_sdvo_connector *sdvo_connector;
> +	struct intel_sdvo_connector_state *conn_state;
>  
>  	sdvo_connector = kzalloc(sizeof(*sdvo_connector), GFP_KERNEL);
>  	if (!sdvo_connector)
>  		return NULL;
>  
> -	if (intel_connector_init(&sdvo_connector->base) < 0) {
> +	conn_state = kzalloc(sizeof(*conn_state), GFP_KERNEL);
> +	if (!conn_state) {
>  		kfree(sdvo_connector);
>  		return NULL;
>  	}
>  
> +	__drm_atomic_helper_connector_reset(&sdvo_connector->base.base,
> +					    &conn_state->base.base);
> +
>  	return sdvo_connector;
>  }
>  
> @@ -2710,31 +2737,30 @@ static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
>  				intel_sdvo_connector->tv_format, i,
>  				i, tv_format_names[intel_sdvo_connector->tv_format_supported[i]]);
>  
> -	intel_sdvo->tv_format_index = intel_sdvo_connector->tv_format_supported[0];
> -	drm_object_attach_property(&intel_sdvo_connector->base.base.base,
> -				      intel_sdvo_connector->tv_format, 0);
> +	intel_sdvo_connector->base.base.state->tv.mode = intel_sdvo_connector->tv_format_supported[0];
> +	drm_object_attach_property(&intel_sdvo_connector->base.base.base, 0, 0);
>  	return true;
>  
>  }
>  
> -#define ENHANCEMENT(name, NAME) do { \
> +#define _ENHANCEMENT(state_assignment, name, NAME) do { \
>  	if (enhancements.name) { \
>  		if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_MAX_##NAME, &data_value, 4) || \
>  		    !intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_##NAME, &response, 2)) \
>  			return false; \
> -		intel_sdvo_connector->max_##name = data_value[0]; \
> -		intel_sdvo_connector->cur_##name = response; \
>  		intel_sdvo_connector->name = \
>  			drm_property_create_range(dev, 0, #name, 0, data_value[0]); \
>  		if (!intel_sdvo_connector->name) return false; \
> +		state_assignment = response; \
>  		drm_object_attach_property(&connector->base, \
> -					      intel_sdvo_connector->name, \
> -					      intel_sdvo_connector->cur_##name); \
> +					   intel_sdvo_connector->name, 0); \
>  		DRM_DEBUG_KMS(#name ": max %d, default %d, current %d\n", \
>  			      data_value[0], data_value[1], response); \
>  	} \
>  } while (0)
>  
> +#define ENHANCEMENT(state, name, NAME) _ENHANCEMENT((state)->name, name, NAME)
> +
>  static bool
>  intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  				      struct intel_sdvo_connector *intel_sdvo_connector,
> @@ -2742,6 +2768,9 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  {
>  	struct drm_device *dev = intel_sdvo->base.base.dev;
>  	struct drm_connector *connector = &intel_sdvo_connector->base.base;
> +	struct drm_connector_state *conn_state = connector->state;
> +	struct intel_sdvo_connector_state *sdvo_state =
> +		to_intel_sdvo_connector_state(conn_state);
>  	uint16_t response, data_value[2];
>  
>  	/* when horizontal overscan is supported, Add the left/right  property */
> @@ -2756,17 +2785,16 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  					  &response, 2))
>  			return false;
>  
> +		sdvo_state->tv.overscan_h = response;
> +
>  		intel_sdvo_connector->max_hscan = data_value[0];
> -		intel_sdvo_connector->left_margin = data_value[0] - response;
> -		intel_sdvo_connector->right_margin = intel_sdvo_connector->left_margin;
>  		intel_sdvo_connector->left =
>  			drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]);
>  		if (!intel_sdvo_connector->left)
>  			return false;
>  
>  		drm_object_attach_property(&connector->base,
> -					      intel_sdvo_connector->left,
> -					      intel_sdvo_connector->left_margin);
> +					   intel_sdvo_connector->left, 0);
>  
>  		intel_sdvo_connector->right =
>  			drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]);
> @@ -2774,8 +2802,7 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  			return false;
>  
>  		drm_object_attach_property(&connector->base,
> -					      intel_sdvo_connector->right,
> -					      intel_sdvo_connector->right_margin);
> +					      intel_sdvo_connector->right, 0);
>  		DRM_DEBUG_KMS("h_overscan: max %d, "
>  			      "default %d, current %d\n",
>  			      data_value[0], data_value[1], response);
> @@ -2792,9 +2819,9 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  					  &response, 2))
>  			return false;
>  
> +		sdvo_state->tv.overscan_v = response;
> +
>  		intel_sdvo_connector->max_vscan = data_value[0];
> -		intel_sdvo_connector->top_margin = data_value[0] - response;
> -		intel_sdvo_connector->bottom_margin = intel_sdvo_connector->top_margin;
>  		intel_sdvo_connector->top =
>  			drm_property_create_range(dev, 0,
>  					    "top_margin", 0, data_value[0]);
> @@ -2802,8 +2829,7 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  			return false;
>  
>  		drm_object_attach_property(&connector->base,
> -					      intel_sdvo_connector->top,
> -					      intel_sdvo_connector->top_margin);
> +					   intel_sdvo_connector->top, 0);
>  
>  		intel_sdvo_connector->bottom =
>  			drm_property_create_range(dev, 0,
> @@ -2812,40 +2838,37 @@ intel_sdvo_create_enhance_property_tv(struct intel_sdvo *intel_sdvo,
>  			return false;
>  
>  		drm_object_attach_property(&connector->base,
> -					      intel_sdvo_connector->bottom,
> -					      intel_sdvo_connector->bottom_margin);
> +					      intel_sdvo_connector->bottom, 0);
>  		DRM_DEBUG_KMS("v_overscan: max %d, "
>  			      "default %d, current %d\n",
>  			      data_value[0], data_value[1], response);
>  	}
>  
> -	ENHANCEMENT(hpos, HPOS);
> -	ENHANCEMENT(vpos, VPOS);
> -	ENHANCEMENT(saturation, SATURATION);
> -	ENHANCEMENT(contrast, CONTRAST);
> -	ENHANCEMENT(hue, HUE);
> -	ENHANCEMENT(sharpness, SHARPNESS);
> -	ENHANCEMENT(brightness, BRIGHTNESS);
> -	ENHANCEMENT(flicker_filter, FLICKER_FILTER);
> -	ENHANCEMENT(flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE);
> -	ENHANCEMENT(flicker_filter_2d, FLICKER_FILTER_2D);
> -	ENHANCEMENT(tv_chroma_filter, TV_CHROMA_FILTER);
> -	ENHANCEMENT(tv_luma_filter, TV_LUMA_FILTER);
> +	ENHANCEMENT(&sdvo_state->tv, hpos, HPOS);
> +	ENHANCEMENT(&sdvo_state->tv, vpos, VPOS);
> +	ENHANCEMENT(&conn_state->tv, saturation, SATURATION);
> +	ENHANCEMENT(&conn_state->tv, contrast, CONTRAST);
> +	ENHANCEMENT(&conn_state->tv, hue, HUE);
> +	ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS);
> +	ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS);
> +	ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER);
> +	ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE);
> +	ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D);
> +	_ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER);
> +	_ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER);
>  
>  	if (enhancements.dot_crawl) {
>  		if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_DOT_CRAWL, &response, 2))
>  			return false;
>  
> -		intel_sdvo_connector->max_dot_crawl = 1;
> -		intel_sdvo_connector->cur_dot_crawl = response & 0x1;
> +		sdvo_state->tv.dot_crawl = response & 0x1;
>  		intel_sdvo_connector->dot_crawl =
>  			drm_property_create_range(dev, 0, "dot_crawl", 0, 1);
>  		if (!intel_sdvo_connector->dot_crawl)
>  			return false;
>  
>  		drm_object_attach_property(&connector->base,
> -					      intel_sdvo_connector->dot_crawl,
> -					      intel_sdvo_connector->cur_dot_crawl);
> +					   intel_sdvo_connector->dot_crawl, 0);
>  		DRM_DEBUG_KMS("dot crawl: current %d\n", response);
>  	}
>  
> @@ -2861,11 +2884,12 @@ intel_sdvo_create_enhance_property_lvds(struct intel_sdvo *intel_sdvo,
>  	struct drm_connector *connector = &intel_sdvo_connector->base.base;
>  	uint16_t response, data_value[2];
>  
> -	ENHANCEMENT(brightness, BRIGHTNESS);
> +	ENHANCEMENT(&connector->state->tv, brightness, BRIGHTNESS);
>  
>  	return true;
>  }
>  #undef ENHANCEMENT
> +#undef _ENHANCEMENT
>  
>  static bool intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,
>  					       struct intel_sdvo_connector *intel_sdvo_connector)
> -- 
> 2.7.4
> 
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
Intel-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/intel-gfx





[Index of Archives]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]
  Powered by Linux