intel_hdmi.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305
  1. /*
  2. * Copyright 2006 Dave Airlie <airlied@linux.ie>
  3. * Copyright © 2006-2009 Intel Corporation
  4. *
  5. * Permission is hereby granted, free of charge, to any person obtaining a
  6. * copy of this software and associated documentation files (the "Software"),
  7. * to deal in the Software without restriction, including without limitation
  8. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9. * and/or sell copies of the Software, and to permit persons to whom the
  10. * Software is furnished to do so, subject to the following conditions:
  11. *
  12. * The above copyright notice and this permission notice (including the next
  13. * paragraph) shall be included in all copies or substantial portions of the
  14. * Software.
  15. *
  16. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22. * DEALINGS IN THE SOFTWARE.
  23. *
  24. * Authors:
  25. * Eric Anholt <eric@anholt.net>
  26. * Jesse Barnes <jesse.barnes@intel.com>
  27. */
  28. #include <linux/i2c.h>
  29. #include <linux/slab.h>
  30. #include <linux/delay.h>
  31. #include "drmP.h"
  32. #include "drm.h"
  33. #include "drm_crtc.h"
  34. #include "drm_edid.h"
  35. #include "intel_drv.h"
  36. #include "i915_drm.h"
  37. #include "i915_drv.h"
  38. struct intel_hdmi_priv {
  39. u32 sdvox_reg;
  40. bool has_hdmi_sink;
  41. };
  42. static void intel_hdmi_mode_set(struct drm_encoder *encoder,
  43. struct drm_display_mode *mode,
  44. struct drm_display_mode *adjusted_mode)
  45. {
  46. struct drm_device *dev = encoder->dev;
  47. struct drm_i915_private *dev_priv = dev->dev_private;
  48. struct drm_crtc *crtc = encoder->crtc;
  49. struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
  50. struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
  51. struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
  52. u32 sdvox;
  53. sdvox = SDVO_ENCODING_HDMI | SDVO_BORDER_ENABLE;
  54. if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
  55. sdvox |= SDVO_VSYNC_ACTIVE_HIGH;
  56. if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC)
  57. sdvox |= SDVO_HSYNC_ACTIVE_HIGH;
  58. if (hdmi_priv->has_hdmi_sink) {
  59. sdvox |= SDVO_AUDIO_ENABLE;
  60. if (HAS_PCH_CPT(dev))
  61. sdvox |= HDMI_MODE_SELECT;
  62. }
  63. if (intel_crtc->pipe == 1) {
  64. if (HAS_PCH_CPT(dev))
  65. sdvox |= PORT_TRANS_B_SEL_CPT;
  66. else
  67. sdvox |= SDVO_PIPE_B_SELECT;
  68. }
  69. I915_WRITE(hdmi_priv->sdvox_reg, sdvox);
  70. POSTING_READ(hdmi_priv->sdvox_reg);
  71. }
  72. static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
  73. {
  74. struct drm_device *dev = encoder->dev;
  75. struct drm_i915_private *dev_priv = dev->dev_private;
  76. struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
  77. struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
  78. u32 temp;
  79. temp = I915_READ(hdmi_priv->sdvox_reg);
  80. /* HW workaround, need to toggle enable bit off and on for 12bpc, but
  81. * we do this anyway which shows more stable in testing.
  82. */
  83. if (HAS_PCH_SPLIT(dev)) {
  84. I915_WRITE(hdmi_priv->sdvox_reg, temp & ~SDVO_ENABLE);
  85. POSTING_READ(hdmi_priv->sdvox_reg);
  86. }
  87. if (mode != DRM_MODE_DPMS_ON) {
  88. temp &= ~SDVO_ENABLE;
  89. } else {
  90. temp |= SDVO_ENABLE;
  91. }
  92. I915_WRITE(hdmi_priv->sdvox_reg, temp);
  93. POSTING_READ(hdmi_priv->sdvox_reg);
  94. /* HW workaround, need to write this twice for issue that may result
  95. * in first write getting masked.
  96. */
  97. if (HAS_PCH_SPLIT(dev)) {
  98. I915_WRITE(hdmi_priv->sdvox_reg, temp);
  99. POSTING_READ(hdmi_priv->sdvox_reg);
  100. }
  101. }
  102. static int intel_hdmi_mode_valid(struct drm_connector *connector,
  103. struct drm_display_mode *mode)
  104. {
  105. if (mode->clock > 165000)
  106. return MODE_CLOCK_HIGH;
  107. if (mode->clock < 20000)
  108. return MODE_CLOCK_HIGH;
  109. if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
  110. return MODE_NO_DBLESCAN;
  111. return MODE_OK;
  112. }
  113. static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
  114. struct drm_display_mode *mode,
  115. struct drm_display_mode *adjusted_mode)
  116. {
  117. return true;
  118. }
  119. static enum drm_connector_status
  120. intel_hdmi_detect(struct drm_connector *connector)
  121. {
  122. struct drm_encoder *encoder = intel_attached_encoder(connector);
  123. struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
  124. struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv;
  125. struct edid *edid = NULL;
  126. enum drm_connector_status status = connector_status_disconnected;
  127. hdmi_priv->has_hdmi_sink = false;
  128. edid = drm_get_edid(connector,
  129. intel_encoder->ddc_bus);
  130. if (edid) {
  131. if (edid->input & DRM_EDID_INPUT_DIGITAL) {
  132. status = connector_status_connected;
  133. hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
  134. }
  135. connector->display_info.raw_edid = NULL;
  136. kfree(edid);
  137. }
  138. return status;
  139. }
  140. static int intel_hdmi_get_modes(struct drm_connector *connector)
  141. {
  142. struct drm_encoder *encoder = intel_attached_encoder(connector);
  143. struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
  144. /* We should parse the EDID data and find out if it's an HDMI sink so
  145. * we can send audio to it.
  146. */
  147. return intel_ddc_get_modes(connector, intel_encoder->ddc_bus);
  148. }
  149. static void intel_hdmi_destroy(struct drm_connector *connector)
  150. {
  151. drm_sysfs_connector_remove(connector);
  152. drm_connector_cleanup(connector);
  153. kfree(connector);
  154. }
  155. static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs = {
  156. .dpms = intel_hdmi_dpms,
  157. .mode_fixup = intel_hdmi_mode_fixup,
  158. .prepare = intel_encoder_prepare,
  159. .mode_set = intel_hdmi_mode_set,
  160. .commit = intel_encoder_commit,
  161. };
  162. static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
  163. .dpms = drm_helper_connector_dpms,
  164. .detect = intel_hdmi_detect,
  165. .fill_modes = drm_helper_probe_single_connector_modes,
  166. .destroy = intel_hdmi_destroy,
  167. };
  168. static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs = {
  169. .get_modes = intel_hdmi_get_modes,
  170. .mode_valid = intel_hdmi_mode_valid,
  171. .best_encoder = intel_attached_encoder,
  172. };
  173. static void intel_hdmi_enc_destroy(struct drm_encoder *encoder)
  174. {
  175. struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
  176. if (intel_encoder->i2c_bus)
  177. intel_i2c_destroy(intel_encoder->i2c_bus);
  178. drm_encoder_cleanup(encoder);
  179. kfree(intel_encoder);
  180. }
  181. static const struct drm_encoder_funcs intel_hdmi_enc_funcs = {
  182. .destroy = intel_hdmi_enc_destroy,
  183. };
  184. void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
  185. {
  186. struct drm_i915_private *dev_priv = dev->dev_private;
  187. struct drm_connector *connector;
  188. struct intel_encoder *intel_encoder;
  189. struct intel_connector *intel_connector;
  190. struct intel_hdmi_priv *hdmi_priv;
  191. intel_encoder = kcalloc(sizeof(struct intel_encoder) +
  192. sizeof(struct intel_hdmi_priv), 1, GFP_KERNEL);
  193. if (!intel_encoder)
  194. return;
  195. intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
  196. if (!intel_connector) {
  197. kfree(intel_encoder);
  198. return;
  199. }
  200. hdmi_priv = (struct intel_hdmi_priv *)(intel_encoder + 1);
  201. connector = &intel_connector->base;
  202. drm_connector_init(dev, connector, &intel_hdmi_connector_funcs,
  203. DRM_MODE_CONNECTOR_HDMIA);
  204. drm_connector_helper_add(connector, &intel_hdmi_connector_helper_funcs);
  205. intel_encoder->type = INTEL_OUTPUT_HDMI;
  206. connector->polled = DRM_CONNECTOR_POLL_HPD;
  207. connector->interlace_allowed = 0;
  208. connector->doublescan_allowed = 0;
  209. intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
  210. /* Set up the DDC bus. */
  211. if (sdvox_reg == SDVOB) {
  212. intel_encoder->clone_mask = (1 << INTEL_HDMIB_CLONE_BIT);
  213. intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "HDMIB");
  214. dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS;
  215. } else if (sdvox_reg == SDVOC) {
  216. intel_encoder->clone_mask = (1 << INTEL_HDMIC_CLONE_BIT);
  217. intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOD, "HDMIC");
  218. dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS;
  219. } else if (sdvox_reg == HDMIB) {
  220. intel_encoder->clone_mask = (1 << INTEL_HDMID_CLONE_BIT);
  221. intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOE,
  222. "HDMIB");
  223. dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS;
  224. } else if (sdvox_reg == HDMIC) {
  225. intel_encoder->clone_mask = (1 << INTEL_HDMIE_CLONE_BIT);
  226. intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOD,
  227. "HDMIC");
  228. dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS;
  229. } else if (sdvox_reg == HDMID) {
  230. intel_encoder->clone_mask = (1 << INTEL_HDMIF_CLONE_BIT);
  231. intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOF,
  232. "HDMID");
  233. dev_priv->hotplug_supported_mask |= HDMID_HOTPLUG_INT_STATUS;
  234. }
  235. if (!intel_encoder->ddc_bus)
  236. goto err_connector;
  237. hdmi_priv->sdvox_reg = sdvox_reg;
  238. intel_encoder->dev_priv = hdmi_priv;
  239. drm_encoder_init(dev, &intel_encoder->enc, &intel_hdmi_enc_funcs,
  240. DRM_MODE_ENCODER_TMDS);
  241. drm_encoder_helper_add(&intel_encoder->enc, &intel_hdmi_helper_funcs);
  242. drm_mode_connector_attach_encoder(&intel_connector->base,
  243. &intel_encoder->enc);
  244. drm_sysfs_connector_add(connector);
  245. /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
  246. * 0xd. Failure to do so will result in spurious interrupts being
  247. * generated on the port when a cable is not attached.
  248. */
  249. if (IS_G4X(dev) && !IS_GM45(dev)) {
  250. u32 temp = I915_READ(PEG_BAND_GAP_DATA);
  251. I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
  252. }
  253. return;
  254. err_connector:
  255. drm_connector_cleanup(connector);
  256. kfree(intel_encoder);
  257. kfree(intel_connector);
  258. return;
  259. }