Subversion Repositories Kolibri OS

/*

 * Copyright 2006 Dave Airlie 

 * Copyright © 2006-2007 Intel Corporation

 *   Jesse Barnes 

 *

 * 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:

 *  Eric Anholt 

 */

#include 

#include 

//#include 

#include "drmP.h"

#include "drm.h"

#include "drm_crtc.h"

#include "drm_edid.h"

#include "intel_drv.h"

#include "i915_drm.h"

#include "i915_drv.h"

#include "intel_sdvo_regs.h"

unsigned int hweight16(unsigned int w)

{

    unsigned int res = w - ((w >> 1) & 0x5555);

    res = (res & 0x3333) + ((res >> 2) & 0x3333);

    res = (res + (res >> 4)) & 0x0F0F;

    return (res + (res >> 8)) & 0x00FF;

}

#define SDVO_TMDS_MASK (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1)

#define SDVO_RGB_MASK  (SDVO_OUTPUT_RGB0 | SDVO_OUTPUT_RGB1)

#define SDVO_LVDS_MASK (SDVO_OUTPUT_LVDS0 | SDVO_OUTPUT_LVDS1)

#define SDVO_TV_MASK   (SDVO_OUTPUT_CVBS0 | SDVO_OUTPUT_SVID0)

#define SDVO_OUTPUT_MASK (SDVO_TMDS_MASK | SDVO_RGB_MASK | SDVO_LVDS_MASK |\

                         SDVO_TV_MASK)

#define IS_TV(c)    (c->output_flag & SDVO_TV_MASK)

#define IS_TMDS(c)  (c->output_flag & SDVO_TMDS_MASK)

#define IS_LVDS(c)  (c->output_flag & SDVO_LVDS_MASK)

#define IS_TV_OR_LVDS(c) (c->output_flag & (SDVO_TV_MASK | SDVO_LVDS_MASK))

static const char *tv_format_names[] = {

    "NTSC_M"   , "NTSC_J"  , "NTSC_443",

    "PAL_B"    , "PAL_D"   , "PAL_G"   ,

    "PAL_H"    , "PAL_I"   , "PAL_M"   ,

    "PAL_N"    , "PAL_NC"  , "PAL_60"  ,

    "SECAM_B"  , "SECAM_D" , "SECAM_G" ,

    "SECAM_K"  , "SECAM_K1", "SECAM_L" ,

    "SECAM_60"

};

#define TV_FORMAT_NUM  (sizeof(tv_format_names) / sizeof(*tv_format_names))

struct intel_sdvo {

    struct intel_encoder base;

    struct i2c_adapter *i2c;

    u8 slave_addr;

    struct i2c_adapter ddc;

    /* Register for the SDVO device: SDVOB or SDVOC */

    int sdvo_reg;

    /* Active outputs controlled by this SDVO output */

    uint16_t controlled_output;

    /*

     * Capabilities of the SDVO device returned by

     * i830_sdvo_get_capabilities()

     */

    struct intel_sdvo_caps caps;

    /* Pixel clock limitations reported by the SDVO device, in kHz */

    int pixel_clock_min, pixel_clock_max;

    /*

    * For multiple function SDVO device,

    * this is for current attached outputs.

    */

    uint16_t attached_output;

    /**

     * 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;

    /**

     * 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

     * to decide this for us, the S-Video output on our HDMI+S-Video card

     * shows up as RGB1 (VGA).

     */

    bool is_tv;

    /* This is for current tv format name */

    int tv_format_index;

    /**

     * This is set if we treat the device as HDMI, instead of DVI.

     */

    bool is_hdmi;

    bool has_hdmi_monitor;

    bool has_hdmi_audio;

    /**

     * This is set if we detect output of sdvo device as LVDS and

     * have a valid fixed mode to use with the panel.

     */

    bool is_lvds;

    /**

     * This is sdvo fixed pannel mode pointer

     */

    struct drm_display_mode *sdvo_lvds_fixed_mode;

    /* DDC bus used by this SDVO encoder */

    uint8_t ddc_bus;

    /* Input timings for adjusted_mode */

    struct intel_sdvo_dtd input_dtd;

};

struct intel_sdvo_connector {

    struct intel_connector base;

    /* Mark the type of connector */

    uint16_t output_flag;

    int force_audio;

    /* This contains all current supported TV format */

    u8 tv_format_supported[TV_FORMAT_NUM];

    int   format_supported_num;

    struct drm_property *tv_format;

    /* add the property for the SDVO-TV */

    struct drm_property *left;

    struct drm_property *right;

    struct drm_property *top;

    struct drm_property *bottom;

    struct drm_property *hpos;

    struct drm_property *vpos;

    struct drm_property *contrast;

    struct drm_property *saturation;

    struct drm_property *hue;

    struct drm_property *sharpness;

    struct drm_property *flicker_filter;

    struct drm_property *flicker_filter_adaptive;

    struct drm_property *flicker_filter_2d;

    struct drm_property *tv_chroma_filter;

    struct drm_property *tv_luma_filter;

    struct drm_property *dot_crawl;

    /* 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;

};

static struct intel_sdvo *to_intel_sdvo(struct drm_encoder *encoder)

{

    return container_of(encoder, struct intel_sdvo, base.base);

}

static struct intel_sdvo *intel_attached_sdvo(struct drm_connector *connector)

{

	return container_of(intel_attached_encoder(connector),

			    struct intel_sdvo, base);

}

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);

}

static bool

intel_sdvo_output_setup(struct intel_sdvo *intel_sdvo, uint16_t flags);

static bool

intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,

			      struct intel_sdvo_connector *intel_sdvo_connector,

			      int type);

static bool

intel_sdvo_create_enhance_property(struct intel_sdvo *intel_sdvo,

				   struct intel_sdvo_connector *intel_sdvo_connector);

/**

 * Writes the SDVOB or SDVOC with the given value, but always writes both

 * SDVOB and SDVOC to work around apparent hardware issues (according to

 * comments in the BIOS).

 */

static void intel_sdvo_write_sdvox(struct intel_sdvo *intel_sdvo, u32 val)

{

	struct drm_device *dev = intel_sdvo->base.base.dev;

	struct drm_i915_private *dev_priv = dev->dev_private;

	u32 bval = val, cval = val;

	int i;

	if (intel_sdvo->sdvo_reg == PCH_SDVOB) {

		I915_WRITE(intel_sdvo->sdvo_reg, val);

		I915_READ(intel_sdvo->sdvo_reg);

		return;

	}

	if (intel_sdvo->sdvo_reg == SDVOB) {

		cval = I915_READ(SDVOC);

	} else {

		bval = I915_READ(SDVOB);

	}

	/*

	 * Write the registers twice for luck. Sometimes,

	 * writing them only once doesn't appear to 'stick'.

	 * The BIOS does this too. Yay, magic

	 */

	for (i = 0; i < 2; i++)

	{

		I915_WRITE(SDVOB, bval);

		I915_READ(SDVOB);

		I915_WRITE(SDVOC, cval);

		I915_READ(SDVOC);

	}

}

static bool intel_sdvo_read_byte(struct intel_sdvo *intel_sdvo, u8 addr, u8 *ch)

{

	struct i2c_msg msgs[] = {