kolibrios/drivers/old/radeonhd/rhd_connector.c

/*
 * Copyright 2007, 2008  Luc Verhaegen <lverhaegen@novell.com>
 * Copyright 2007, 2008  Matthias Hopf <mhopf@novell.com>
 * Copyright 2007, 2008 Egbert Eich   <eich@novell.com>
 * Copyright 2007, 2008  Advanced Micro Devices, Inc.
 *
 * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "xf86.h"

/* for usleep */
#if HAVE_XF86_ANSIC_H
# include "xf86_ansic.h"
#else
# include <unistd.h>
# include <string.h>
# include <stdio.h>
#endif

#include "rhd.h"
#include "edid.h"

#ifdef ATOM_BIOS
# include "rhd_atombios.h"
#endif

#include "rhd_connector.h"
#include "rhd_output.h"
#include "rhd_regs.h"
#include "rhd_monitor.h"
#include "rhd_card.h"

#include "xf86i2c.h"
#include "rhd_i2c.h"



/*
 *
 */
struct rhdHPD {
    Bool Stored;
    CARD32 StoreMask;
    CARD32 StoreEnable;
};

/*
 *
 */
void
RHDHPDSave(RHDPtr rhdPtr)
{
    struct rhdHPD *hpd = rhdPtr->HPD;

    RHDFUNC(rhdPtr);

    hpd->StoreMask = RHDRegRead(rhdPtr, DC_GPIO_HPD_MASK);
    hpd->StoreEnable = RHDRegRead(rhdPtr, DC_GPIO_HPD_EN);

    hpd->Stored = TRUE;
}

/*
 *
 */
void
RHDHPDRestore(RHDPtr rhdPtr)
{
  struct rhdHPD *hpd = rhdPtr->HPD;

  RHDFUNC(rhdPtr);

    if (hpd->Stored) {
	RHDRegWrite(rhdPtr, DC_GPIO_HPD_MASK, hpd->StoreMask);
	RHDRegWrite(rhdPtr, DC_GPIO_HPD_EN, hpd->StoreEnable);
    } else
	xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR,
		   "%s: no registers stored.\n", __func__);
}

/*
 *
 */
static void
RHDHPDSet(RHDPtr rhdPtr)
{
  RHDFUNC(rhdPtr);

    /* give the hw full control */
    RHDRegWrite(rhdPtr, DC_GPIO_HPD_MASK, 0);
    RHDRegWrite(rhdPtr, DC_GPIO_HPD_EN, 0);

  usleep(1);
}

/*
 *
 */
static Bool
RHDHPDCheck(struct rhdConnector *Connector)
{
    Bool ret;

    RHDFUNC(Connector);

    ret = RHDRegRead(Connector, DC_GPIO_HPD_Y);
    RHDDebug(Connector->scrnIndex, "%s returned: %x mask: %x\n",
	     __func__,ret, Connector->HPDMask);

    return (ret & Connector->HPDMask);
}

struct rhdCsState {
    int vga_cnt;
    int dvi_cnt;
};

/*
 *
 */
static char *
rhdConnectorSynthName(struct rhdConnectorInfo *ConnectorInfo,
		      struct rhdCsState **state)
{
  char *str = NULL;
    char *TypeName;
  char *str1, *str2;
    int cnt;

    ASSERT(state != NULL);

    if (!*state) {
	if (!(*state = xcalloc(sizeof(struct rhdCsState), 1)))
	    return NULL;
    }
    switch (ConnectorInfo->Type) {
	case RHD_CONNECTOR_NONE:
	    return NULL;
	case RHD_CONNECTOR_DVI:
	case RHD_CONNECTOR_DVI_SINGLE:
	    if (ConnectorInfo->Output[0] && ConnectorInfo->Output[1]) {
		TypeName = "DVI-I";
		cnt = ++(*state)->dvi_cnt;
	    } else if (ConnectorInfo->Output[0] == RHD_OUTPUT_DACA
		     || ConnectorInfo->Output[0] == RHD_OUTPUT_DACB
		     || ConnectorInfo->Output[1] == RHD_OUTPUT_DACA
		     || ConnectorInfo->Output[1] == RHD_OUTPUT_DACB
		) {
		if (ConnectorInfo->HPD == RHD_HPD_NONE) {
		    TypeName = "VGA";
		    cnt = ++(*state)->vga_cnt;
		} else {
		    TypeName = "DVI-A";
		    cnt = ++(*state)->dvi_cnt;
		}
	    } else {
		TypeName = "DVI-D";
		cnt = ++(*state)->dvi_cnt;
	    }
	    str = xalloc(12);
	    snprintf(str, 11, "%s %i",TypeName, cnt);
	    return str;

    case RHD_CONNECTOR_VGA:
	    str = xalloc(10);
      snprintf(str, 9, "VGA %i",++(*state)->vga_cnt);
	    return str;

    case RHD_CONNECTOR_PANEL:
	    str = xalloc(10);
	    snprintf(str, 9, "PANEL");
	    return str;

    case RHD_CONNECTOR_TV:
	    str1 = xstrdup(ConnectorInfo->Name);
	    str = xalloc(20);
      str2 = strchr(str1, ' ');
      if (str2) *(str2) = '\0';
        snprintf(str, 20, "TV %s",str1);
	    xfree(str1);
	    return str;

	case RHD_CONNECTOR_PCIE: /* should never get here */
	    return NULL;
    }
    return NULL;
}

/*
 *
 */
Bool
RHDConnectorsInit(RHDPtr rhdPtr, struct rhdCard *Card)
{
  struct rhdConnectorInfo *ConnectorInfo;
  struct rhdConnector *Connector;
  struct rhdOutput *Output;
  struct rhdCsState *csstate = NULL;
  int i, j, k, l, hpd;
  Bool InfoAllocated = FALSE;

    RHDFUNC(rhdPtr);

    /* Card->ConnectorInfo is there to work around quirks, so check it first */
    if (Card && (Card->ConnectorInfo[0].Type != RHD_CONNECTOR_NONE)) {
    ConnectorInfo = Card->ConnectorInfo;
	xf86DrvMsg(rhdPtr->scrnIndex, X_INFO,
		   "ConnectorInfo from quirk table:\n");
	RhdPrintConnectorInfo (rhdPtr, ConnectorInfo);
    } else {
#ifdef ATOM_BIOS
	/* common case */
    AtomBiosArgRec data;
    AtomBiosResult result;

  data.chipset = rhdPtr->ChipSet;
  result = RHDAtomBiosFunc(rhdPtr, rhdPtr->atomBIOS,
             ATOMBIOS_GET_CONNECTORS, &data);
	if (result == ATOM_SUCCESS) {
	    ConnectorInfo = data.ConnectorInfo;
	    InfoAllocated = TRUE;
	} else
#endif
    {
	    xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR, "%s: Failed to retrieve "
		       "Connector information.\n", __func__);
	    return FALSE;
    }
  }

    /* Init HPD */
    rhdPtr->HPD = xnfcalloc(sizeof(struct rhdHPD), 1);
  RHDHPDSave(rhdPtr);
  RHDHPDSet(rhdPtr);

    for (i = 0, j = 0; i < RHD_CONNECTORS_MAX; i++) {
    if (ConnectorInfo[i].Type == RHD_CONNECTOR_NONE)
      continue;

	RHDDebug(rhdPtr->scrnIndex, "%s: %d (%s) type %d, ddc %d, hpd %d\n",
              __func__, i, ConnectorInfo[i].Name, ConnectorInfo[i].Type,
		 ConnectorInfo[i].DDC, ConnectorInfo[i].HPD);

	Connector = xnfcalloc(sizeof(struct rhdConnector), 1);
	Connector->scrnIndex = rhdPtr->scrnIndex;
    Connector->Type = ConnectorInfo[i].Type;
    Connector->Name = rhdConnectorSynthName(&ConnectorInfo[i], &csstate);

	/* Get the DDC bus of this connector */
	if (ConnectorInfo[i].DDC != RHD_DDC_NONE) {
	    RHDI2CDataArg data;
	    int ret;

	    data.i = ConnectorInfo[i].DDC;
	    ret = RHDI2CFunc(rhdPtr->scrnIndex,
			     rhdPtr->I2C, RHD_I2C_GETBUS, &data);
	    if (ret == RHD_I2C_SUCCESS)
        Connector->DDC = data.i2cBusPtr;
    }

	/* attach HPD */
    hpd = ConnectorInfo[i].HPD;
	switch (rhdPtr->hpdUsage) {
      case RHD_HPD_USAGE_OFF:
      case RHD_HPD_USAGE_AUTO_OFF:
        hpd = RHD_HPD_NONE;
        break;
      case RHD_HPD_USAGE_SWAP:
      case RHD_HPD_USAGE_AUTO_SWAP:
	    switch (hpd) {
          case RHD_HPD_0:
            hpd = RHD_HPD_1;
            break;
          case RHD_HPD_1:
            hpd = RHD_HPD_0;
            break;
        }
        break;
      default:
        break;
    }
	switch(hpd) {
      case RHD_HPD_0:
        Connector->HPDMask = 0x00000001;
        Connector->HPDCheck = RHDHPDCheck;
        break;
      case RHD_HPD_1:
        Connector->HPDMask = 0x00000100;
        Connector->HPDCheck = RHDHPDCheck;
        break;
      case RHD_HPD_2:
        Connector->HPDMask = 0x00010000;
        Connector->HPDCheck = RHDHPDCheck;
        break;
	case RHD_HPD_3:
	    Connector->HPDMask = 0x01000000;
	    Connector->HPDCheck = RHDHPDCheck;
	    break;
      default:
        Connector->HPDCheck = NULL;
        break;
    }

	/* create Outputs */
	for (k = 0; k < 2; k++) {
	    if (ConnectorInfo[i].Output[k] == RHD_OUTPUT_NONE)
        continue;

	    /* Check whether the output exists already */
	    for (Output = rhdPtr->Outputs; Output; Output = Output->Next)
        if (Output->Id == ConnectorInfo[i].Output[k])
          break;

	    if (!Output) {
		if (!RHDUseAtom(rhdPtr, NULL, atomUsageOutput)) {
		switch (ConnectorInfo[i].Output[k]) {
          case RHD_OUTPUT_DACA:
            Output = RHDDACAInit(rhdPtr);
            RHDOutputAdd(rhdPtr, Output);
            break;
          case RHD_OUTPUT_DACB:
            Output = RHDDACBInit(rhdPtr);
            RHDOutputAdd(rhdPtr, Output);
            break;
          case RHD_OUTPUT_TMDSA:
            Output = RHDTMDSAInit(rhdPtr);
            RHDOutputAdd(rhdPtr, Output);
            break;
          case RHD_OUTPUT_LVTMA:
            Output = RHDLVTMAInit(rhdPtr, ConnectorInfo[i].Type);
            RHDOutputAdd(rhdPtr, Output);
            break;
		    case RHD_OUTPUT_DVO:
			Output = RHDDDIAInit(rhdPtr);
		    if (Output)
			RHDOutputAdd(rhdPtr, Output);
		    break;
		case RHD_OUTPUT_KLDSKP_LVTMA:
		case RHD_OUTPUT_UNIPHYA:
		case RHD_OUTPUT_UNIPHYB:
		    Output = RHDDIGInit(rhdPtr, ConnectorInfo[i].Output[k], ConnectorInfo[i].Type);
		    RHDOutputAdd(rhdPtr, Output);
		    break;
          default:
		    xf86DrvMsg(rhdPtr->scrnIndex, X_ERROR,
				   "%s: unhandled output id: %d. Trying fallback to AtomBIOS\n", __func__,
			       ConnectorInfo[i].Output[k]);
            break;
        }
	    }
#ifdef ATOM_BIOS
		if (!Output) {
		    Output = RHDAtomOutputInit(rhdPtr, ConnectorInfo[i].Type,
					       ConnectorInfo[i].Output[k]);
		    if (Output)
			RHDOutputAdd(rhdPtr, Output);
		}
#endif
	    }

	    if (Output) {
		xf86DrvMsg(rhdPtr->scrnIndex, X_PROBED,
			   "Attaching Output %s to Connector %s\n",
			   Output->Name, Connector->Name);
        for (l = 0; l < 2; l++)
		    if (!Connector->Output[l]) {
            Connector->Output[l] = Output;
            break;
          }
	    }
    }

    rhdPtr->Connector[j] = Connector;
    j++;
  }
  if (csstate)
	xfree(csstate);

    /* Deallocate what atombios code allocated */
    if (ConnectorInfo && InfoAllocated) {
    for (i = 0; i < RHD_CONNECTORS_MAX; i++)
	    if (ConnectorInfo[i].Type != RHD_CONNECTOR_NONE)
		xfree(ConnectorInfo[i].Name);
	/* Don't free the Privates as they are hooked into the rhdConnector structures !!! */
	xfree(ConnectorInfo);
  }

  RHDHPDRestore(rhdPtr);

  return (j && 1);
}

/*
 *
 */
void
RHDConnectorsDestroy(RHDPtr rhdPtr)
{
  struct rhdConnector *Connector;
  int i;

  RHDFUNC(rhdPtr);

    for (i = 0; i < RHD_CONNECTORS_MAX; i++) {
    Connector = rhdPtr->Connector[i];
	if (Connector) {
	    if (Connector->Monitor)
		RHDMonitorDestroy(Connector->Monitor);
	    xfree(Connector->Name);
	    xfree(Connector);
    }
  }
}

/*
 *
 */
void
RhdPrintConnectorInfo(RHDPtr rhdPtr, struct rhdConnectorInfo *cp)
{
  int n;
  int scrnIndex=0;

  const char *c_name[] =
	{ "RHD_CONNECTOR_NONE", "RHD_CONNECTOR_VGA", "RHD_CONNECTOR_DVI",
	  "RHD_CONNECTOR_DVI_SINGLE", "RHD_CONNECTOR_PANEL",
	  "RHD_CONNECTOR_TV", "RHD_CONNECTOR_PCIE" };

  const char *ddc_name[] =
	{ "RHD_DDC_0", "RHD_DDC_1", "RHD_DDC_2", "RHD_DDC_3", "RHD_DDC_4" };

  const char *hpd_name_normal[] =
	{ "RHD_HPD_NONE", "RHD_HPD_0", "RHD_HPD_1", "RHD_HPD_2", "RHD_HPD_3" };
  const char *hpd_name_off[] =
	{ "RHD_HPD_NONE", "RHD_HPD_NONE /*0*/", "RHD_HPD_NONE /*1*/", "RHD_HPD_NONE /*2*/", "RHD_HPD_NONE /*3*/" };
    const char *hpd_name_swapped[] =
	{ "RHD_HPD_NONE", "RHD_HPD_1 /*swapped*/", "RHD_HPD_0 /*swapped*/", "RHD_HPD_2", "RHD_HPD_3" };

  const char *output_name[] =
	{ "RHD_OUTPUT_NONE", "RHD_OUTPUT_DACA", "RHD_OUTPUT_DACB", "RHD_OUTPUT_TMDSA",
	  "RHD_OUTPUT_LVTMA", "RHD_OUTPUT_DVO", "RHD_OUTPUT_KLDSKP_LVTMA",
	  "RHD_OUTPUT_UNIPHYA", "RHD_OUTPUT_UNIPHYB", "RHD_OUTPUT_UNIPHYC", "RHD_OUTPUT_UNIPHYD",
	  "RHD_OUTPUT_UNIPHYE", "RHD_OUTPUT_UNIPHYF" };
  const char **hpd_name;

    switch (rhdPtr->hpdUsage) {
    case RHD_HPD_USAGE_OFF:
    case RHD_HPD_USAGE_AUTO_OFF:
      hpd_name = hpd_name_off;
      break;
    case RHD_HPD_USAGE_SWAP:
    case RHD_HPD_USAGE_AUTO_SWAP:
      hpd_name = hpd_name_swapped;
      break;
    default:
     hpd_name = hpd_name_normal;
     break;
  }

    for (n = 0; n < RHD_CONNECTORS_MAX; n++) {
    if (cp[n].Type == RHD_CONNECTOR_NONE)
	    break;
	xf86DrvMsg(scrnIndex, X_INFO, "Connector[%i] {%s, \"%s\", %s, %s, { %s, %s } }\n",
		   n, c_name[cp[n].Type], cp[n].Name,
		   cp[n].DDC == RHD_DDC_NONE ? "RHD_DDC_NONE" : ddc_name[cp[n].DDC],
		   hpd_name[cp[n].HPD], output_name[cp[n].Output[0]],
		   output_name[cp[n].Output[1]]);
  }
}

/*
 * Should we enable HDMI on this connector?
 */
Bool RHDConnectorEnableHDMI(struct rhdConnector *Connector)
{
    RHDPtr rhdPtr = RHDPTRI(Connector);
    RHDFUNC(rhdPtr);

    /* check if user forced HDMI on this connector */
//    switch(RhdParseBooleanOption(&rhdPtr->hdmi, Connector->Name)) {
//	case RHD_OPTION_ON:
//	case RHD_OPTION_DEFAULT:
//	    xf86DrvMsg(rhdPtr->scrnIndex, X_INFO, "Enabling HDMI on %s because of config option\n", Connector->Name);
//	    return TRUE;
//	case RHD_OPTION_OFF:
//	    xf86DrvMsg(rhdPtr->scrnIndex, X_INFO, "Disabling HDMI on %s because of config option\n", Connector->Name);
//	    return FALSE;
//	case RHD_OPTION_NOT_SET:
//	    /* ask connected monitor if it supports HDMI */
//	    /* TODO: Not implemented yet! */
//	    return FALSE;
//    }

    return FALSE;
}