/* * Copyright (C) 2008 Maarten Maathuis. * All Rights Reserved. * * 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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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. * */ #include "nv50_connector.h" static struct nv50_output *nv50_connector_to_output(struct nv50_connector *connector, bool digital) { struct nv50_display *display = nv50_get_display(connector->dev); struct nv50_output *output = NULL; bool digital_possible = false; bool analog_possible = false; switch (connector->type) { case CONNECTOR_VGA: case CONNECTOR_TV: analog_possible = true; break; case CONNECTOR_DVI_I: analog_possible = true; digital_possible = true; break; case CONNECTOR_DVI_D: case CONNECTOR_LVDS: digital_possible = true; break; default: break; } /* Return early on bad situations. */ if (!analog_possible && !digital_possible) return NULL; if (!analog_possible && !digital) return NULL; if (!digital_possible && digital) return NULL; list_for_each_entry(output, &display->outputs, item) { if (connector->bus != output->bus) continue; if (digital && output->type == OUTPUT_TMDS) return output; if (digital && output->type == OUTPUT_LVDS) return output; if (!digital && output->type == OUTPUT_DAC) return output; if (!digital && output->type == OUTPUT_TV) return output; } return NULL; } static int nv50_connector_hpd_detect(struct nv50_connector *connector) { struct drm_nouveau_private *dev_priv = connector->dev->dev_private; bool present = 0; uint32_t reg = 0; /* Assume connected for the moment. */ if (connector->type == CONNECTOR_LVDS) { NV50_DEBUG("LVDS is defaulting to connected for the moment.\n"); return 1; } /* No i2c port, no idea what to do for hotplug. */ if (connector->i2c_chan->index == 15) { DRM_ERROR("You have a non-LVDS SOR with no i2c port, please report\n"); return -EINVAL; } if (connector->i2c_chan->index > 3) { DRM_ERROR("You have an unusual configuration, index is %d\n", connector->i2c_chan->index); DRM_ERROR("Please report.\n"); return -EINVAL; } /* Check hotplug pins. */ reg = NV_READ(NV50_PCONNECTOR_HOTPLUG_STATE); if (reg & (NV50_PCONNECTOR_HOTPLUG_STATE_PIN_CONNECTED_I2C0 << (4 * connector->i2c_chan->index))) present = 1; if (present) NV50_DEBUG("Hotplug detect returned positive for bus %d\n", connector->bus); else NV50_DEBUG("Hotplug detect returned negative for bus %d\n", connector->bus); return present; } static int nv50_connector_i2c_detect(struct nv50_connector *connector) { /* kindly borrrowed from the intel driver, hope it works. */ uint8_t out_buf[] = { 0x0, 0x0}; uint8_t buf[2]; int ret; struct i2c_msg msgs[] = { { .addr = 0x50, .flags = 0, .len = 1, .buf = out_buf, }, { .addr = 0x50, .flags = I2C_M_RD, .len = 1, .buf = buf, } }; if (!connector->i2c_chan) return -EINVAL; ret = i2c_transfer(&connector->i2c_chan->adapter, msgs, 2); NV50_DEBUG("I2C detect returned %d\n", ret); if (ret == 2) return true; return false; } static int nv50_connector_destroy(struct nv50_connector *connector) { struct drm_device *dev = connector->dev; struct drm_nouveau_private *dev_priv = dev->dev_private; struct nv50_display *display = nv50_get_display(dev); NV50_DEBUG("\n"); if (!display || !connector) return -EINVAL; list_del(&connector->item); if (connector->i2c_chan) nv50_i2c_channel_destroy(connector->i2c_chan); if (dev_priv->free_connector) dev_priv->free_connector(connector); return 0; } int nv50_connector_create(struct drm_device *dev, int bus, int i2c_index, int type) { struct nv50_connector *connector = NULL; struct drm_nouveau_private *dev_priv = dev->dev_private; struct nv50_display *display = NULL; NV50_DEBUG("\n"); /* This allows the public layer to do it's thing. */ if (dev_priv->alloc_connector) connector = dev_priv->alloc_connector(dev); if (!connector) return -ENOMEM; connector->dev = dev; display = nv50_get_display(dev); if (!display) goto out; if (type == CONNECTOR_UNKNOWN) goto out; list_add_tail(&connector->item, &display->connectors); connector->bus = bus; connector->type = type; switch (type) { case CONNECTOR_VGA: DRM_INFO("Detected a VGA connector\n"); break; case CONNECTOR_DVI_D: DRM_INFO("Detected a DVI-D connector\n"); break; case CONNECTOR_DVI_I: DRM_INFO("Detected a DVI-I connector\n"); break; case CONNECTOR_LVDS: DRM_INFO("Detected a LVDS connector\n"); break; case CONNECTOR_TV: DRM_INFO("Detected a TV connector\n"); break; default: DRM_ERROR("Unknown connector, this is not good.\n"); break; } /* some reasonable defaults */ if (type == CONNECTOR_DVI_D || type == CONNECTOR_DVI_I || type == CONNECTOR_LVDS) connector->requested_scaling_mode = SCALE_FULLSCREEN; else connector->requested_scaling_mode = SCALE_NON_GPU; connector->use_dithering = false; if (i2c_index < 0xf) connector->i2c_chan = nv50_i2c_channel_create(dev, i2c_index); /* set function pointers */ connector->hpd_detect = nv50_connector_hpd_detect; connector->i2c_detect = nv50_connector_i2c_detect; connector->destroy = nv50_connector_destroy; connector->to_output = nv50_connector_to_output; return 0; out: if (dev_priv->free_connector) dev_priv->free_connector(connector); return -EINVAL; }