1 /* 2 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> 3 * Copyright (c) 2007, 2010 Intel Corporation 4 * Jesse Barnes <jesse.barnes@intel.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the next 14 * paragraph) shall be included in all copies or substantial portions of the 15 * Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 * DEALINGS IN THE SOFTWARE. 24 */ 25 26 #include <linux/i2c.h> 27 #include <linux/slab.h> 28 29 #include <drm/drm_atomic_helper.h> 30 #include <drm/drm_edid.h> 31 #include <drm/drm_probe_helper.h> 32 33 #include "i915_drv.h" 34 #include "intel_backlight.h" 35 #include "intel_connector.h" 36 #include "intel_display_debugfs.h" 37 #include "intel_display_types.h" 38 #include "intel_hdcp.h" 39 #include "intel_panel.h" 40 41 static void intel_connector_modeset_retry_work_fn(struct work_struct *work) 42 { 43 struct intel_connector *connector = container_of(work, typeof(*connector), 44 modeset_retry_work); 45 struct intel_display *display = to_intel_display(connector); 46 47 drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s]\n", connector->base.base.id, 48 connector->base.name); 49 50 /* Grab the locks before changing connector property*/ 51 mutex_lock(&display->drm->mode_config.mutex); 52 /* Set connector link status to BAD and send a Uevent to notify 53 * userspace to do a modeset. 54 */ 55 drm_connector_set_link_status_property(&connector->base, 56 DRM_MODE_LINK_STATUS_BAD); 57 mutex_unlock(&display->drm->mode_config.mutex); 58 /* Send Hotplug uevent so userspace can reprobe */ 59 drm_kms_helper_connector_hotplug_event(&connector->base); 60 61 drm_connector_put(&connector->base); 62 } 63 64 void intel_connector_queue_modeset_retry_work(struct intel_connector *connector) 65 { 66 struct drm_i915_private *i915 = to_i915(connector->base.dev); 67 68 drm_connector_get(&connector->base); 69 if (!queue_work(i915->unordered_wq, &connector->modeset_retry_work)) 70 drm_connector_put(&connector->base); 71 } 72 73 void intel_connector_cancel_modeset_retry_work(struct intel_connector *connector) 74 { 75 if (cancel_work_sync(&connector->modeset_retry_work)) 76 drm_connector_put(&connector->base); 77 } 78 79 int intel_connector_init(struct intel_connector *connector) 80 { 81 struct intel_digital_connector_state *conn_state; 82 83 /* 84 * Allocate enough memory to hold intel_digital_connector_state, 85 * This might be a few bytes too many, but for connectors that don't 86 * need it we'll free the state and allocate a smaller one on the first 87 * successful commit anyway. 88 */ 89 conn_state = kzalloc(sizeof(*conn_state), GFP_KERNEL); 90 if (!conn_state) 91 return -ENOMEM; 92 93 __drm_atomic_helper_connector_reset(&connector->base, 94 &conn_state->base); 95 96 intel_panel_init_alloc(connector); 97 98 INIT_WORK(&connector->modeset_retry_work, 99 intel_connector_modeset_retry_work_fn); 100 101 return 0; 102 } 103 104 struct intel_connector *intel_connector_alloc(void) 105 { 106 struct intel_connector *connector; 107 108 connector = kzalloc(sizeof(*connector), GFP_KERNEL); 109 if (!connector) 110 return NULL; 111 112 if (intel_connector_init(connector) < 0) { 113 kfree(connector); 114 return NULL; 115 } 116 117 return connector; 118 } 119 120 /* 121 * Free the bits allocated by intel_connector_alloc. 122 * This should only be used after intel_connector_alloc has returned 123 * successfully, and before drm_connector_init returns successfully. 124 * Otherwise the destroy callbacks for the connector and the state should 125 * take care of proper cleanup/free (see intel_connector_destroy). 126 */ 127 void intel_connector_free(struct intel_connector *connector) 128 { 129 kfree(to_intel_digital_connector_state(connector->base.state)); 130 kfree(connector); 131 } 132 133 /* 134 * Connector type independent destroy hook for drm_connector_funcs. 135 */ 136 void intel_connector_destroy(struct drm_connector *connector) 137 { 138 struct intel_connector *intel_connector = to_intel_connector(connector); 139 140 drm_edid_free(intel_connector->detect_edid); 141 142 intel_hdcp_cleanup(intel_connector); 143 144 intel_panel_fini(intel_connector); 145 146 drm_connector_cleanup(connector); 147 148 if (intel_connector->mst.port) 149 drm_dp_mst_put_port_malloc(intel_connector->mst.port); 150 151 kfree(connector); 152 } 153 154 int intel_connector_register(struct drm_connector *connector) 155 { 156 struct intel_connector *intel_connector = to_intel_connector(connector); 157 int ret; 158 159 ret = intel_backlight_device_register(intel_connector); 160 if (ret) 161 goto err; 162 163 if (i915_inject_probe_failure(to_i915(connector->dev))) { 164 ret = -EFAULT; 165 goto err_backlight; 166 } 167 168 intel_connector_debugfs_add(intel_connector); 169 170 return 0; 171 172 err_backlight: 173 intel_backlight_device_unregister(intel_connector); 174 err: 175 return ret; 176 } 177 178 void intel_connector_unregister(struct drm_connector *connector) 179 { 180 struct intel_connector *intel_connector = to_intel_connector(connector); 181 182 intel_backlight_device_unregister(intel_connector); 183 } 184 185 void intel_connector_attach_encoder(struct intel_connector *connector, 186 struct intel_encoder *encoder) 187 { 188 connector->encoder = encoder; 189 drm_connector_attach_encoder(&connector->base, &encoder->base); 190 } 191 192 /* 193 * Simple connector->get_hw_state implementation for encoders that support only 194 * one connector and no cloning and hence the encoder state determines the state 195 * of the connector. 196 */ 197 bool intel_connector_get_hw_state(struct intel_connector *connector) 198 { 199 enum pipe pipe = 0; 200 struct intel_encoder *encoder = intel_attached_encoder(connector); 201 202 return encoder->get_hw_state(encoder, &pipe); 203 } 204 205 enum pipe intel_connector_get_pipe(struct intel_connector *connector) 206 { 207 struct drm_device *dev = connector->base.dev; 208 209 drm_WARN_ON(dev, 210 !drm_modeset_is_locked(&dev->mode_config.connection_mutex)); 211 212 if (!connector->base.state->crtc) 213 return INVALID_PIPE; 214 215 return to_intel_crtc(connector->base.state->crtc)->pipe; 216 } 217 218 /** 219 * intel_connector_update_modes - update connector from edid 220 * @connector: DRM connector device to use 221 * @drm_edid: previously read EDID information 222 */ 223 int intel_connector_update_modes(struct drm_connector *connector, 224 const struct drm_edid *drm_edid) 225 { 226 int ret; 227 228 drm_edid_connector_update(connector, drm_edid); 229 ret = drm_edid_connector_add_modes(connector); 230 231 return ret; 232 } 233 234 /** 235 * intel_ddc_get_modes - get modelist from monitor 236 * @connector: DRM connector device to use 237 * @ddc: DDC bus i2c adapter 238 * 239 * Fetch the EDID information from @connector using the DDC bus. 240 */ 241 int intel_ddc_get_modes(struct drm_connector *connector, 242 struct i2c_adapter *ddc) 243 { 244 const struct drm_edid *drm_edid; 245 int ret; 246 247 drm_edid = drm_edid_read_ddc(connector, ddc); 248 if (!drm_edid) 249 return 0; 250 251 ret = intel_connector_update_modes(connector, drm_edid); 252 drm_edid_free(drm_edid); 253 254 return ret; 255 } 256 257 static const struct drm_prop_enum_list force_audio_names[] = { 258 { HDMI_AUDIO_OFF_DVI, "force-dvi" }, 259 { HDMI_AUDIO_OFF, "off" }, 260 { HDMI_AUDIO_AUTO, "auto" }, 261 { HDMI_AUDIO_ON, "on" }, 262 }; 263 264 void 265 intel_attach_force_audio_property(struct drm_connector *connector) 266 { 267 struct drm_device *dev = connector->dev; 268 struct drm_i915_private *dev_priv = to_i915(dev); 269 struct drm_property *prop; 270 271 prop = dev_priv->display.properties.force_audio; 272 if (prop == NULL) { 273 prop = drm_property_create_enum(dev, 0, 274 "audio", 275 force_audio_names, 276 ARRAY_SIZE(force_audio_names)); 277 if (prop == NULL) 278 return; 279 280 dev_priv->display.properties.force_audio = prop; 281 } 282 drm_object_attach_property(&connector->base, prop, 0); 283 } 284 285 static const struct drm_prop_enum_list broadcast_rgb_names[] = { 286 { INTEL_BROADCAST_RGB_AUTO, "Automatic" }, 287 { INTEL_BROADCAST_RGB_FULL, "Full" }, 288 { INTEL_BROADCAST_RGB_LIMITED, "Limited 16:235" }, 289 }; 290 291 void 292 intel_attach_broadcast_rgb_property(struct drm_connector *connector) 293 { 294 struct drm_device *dev = connector->dev; 295 struct drm_i915_private *dev_priv = to_i915(dev); 296 struct drm_property *prop; 297 298 prop = dev_priv->display.properties.broadcast_rgb; 299 if (prop == NULL) { 300 prop = drm_property_create_enum(dev, DRM_MODE_PROP_ENUM, 301 "Broadcast RGB", 302 broadcast_rgb_names, 303 ARRAY_SIZE(broadcast_rgb_names)); 304 if (prop == NULL) 305 return; 306 307 dev_priv->display.properties.broadcast_rgb = prop; 308 } 309 310 drm_object_attach_property(&connector->base, prop, 0); 311 } 312 313 void 314 intel_attach_aspect_ratio_property(struct drm_connector *connector) 315 { 316 if (!drm_mode_create_aspect_ratio_property(connector->dev)) 317 drm_object_attach_property(&connector->base, 318 connector->dev->mode_config.aspect_ratio_property, 319 DRM_MODE_PICTURE_ASPECT_NONE); 320 } 321 322 void 323 intel_attach_hdmi_colorspace_property(struct drm_connector *connector) 324 { 325 if (!drm_mode_create_hdmi_colorspace_property(connector, 0)) 326 drm_connector_attach_colorspace_property(connector); 327 } 328 329 void 330 intel_attach_dp_colorspace_property(struct drm_connector *connector) 331 { 332 if (!drm_mode_create_dp_colorspace_property(connector, 0)) 333 drm_connector_attach_colorspace_property(connector); 334 } 335 336 void 337 intel_attach_scaling_mode_property(struct drm_connector *connector) 338 { 339 struct drm_i915_private *i915 = to_i915(connector->dev); 340 u32 scaling_modes; 341 342 scaling_modes = BIT(DRM_MODE_SCALE_ASPECT) | 343 BIT(DRM_MODE_SCALE_FULLSCREEN); 344 345 /* On GMCH platforms borders are only possible on the LVDS port */ 346 if (!HAS_GMCH(i915) || connector->connector_type == DRM_MODE_CONNECTOR_LVDS) 347 scaling_modes |= BIT(DRM_MODE_SCALE_CENTER); 348 349 drm_connector_attach_scaling_mode_property(connector, scaling_modes); 350 351 connector->state->scaling_mode = DRM_MODE_SCALE_ASPECT; 352 } 353