Lines Matching refs:connector
475 * connector, etc., rather than just a single range.
3800 struct drm_connector *connector;
3823 list_for_each_entry(connector, struct drm_connector, &dev->mode_config.connector_list, head) {
3824 if (!connector->encoder || !connector->encoder->crtc)
3827 if (connector->encoder->crtc != crtc)
3830 connector->dpms = DRM_MODE_DPMS_OFF;
3831 to_intel_encoder(connector->encoder)->connectors_active = false;
3853 /* Simple dpms helper for encodres with just one connector, no cloning and only
3871 static void intel_connector_check_state(struct intel_connector *connector)
3873 if (connector->get_hw_state(connector)) {
3874 struct intel_encoder *encoder = connector->encoder;
3880 connector->base.base.id,
3881 drm_get_connector_name(&connector->base));
3883 if (connector->base.dpms == DRM_MODE_DPMS_OFF)
3884 DRM_ERROR("wrong connector dpms state\n");
3885 if (connector->base.encoder != &encoder->base)
3886 DRM_ERROR("active connector not linked to encoder\n");
3911 void intel_connector_dpms(struct drm_connector *connector, int mode)
3913 struct intel_encoder *encoder = intel_attached_encoder(connector);
3919 if (mode == connector->dpms)
3922 connector->dpms = mode;
3931 intel_modeset_check_state(connector->dev);
3934 /* Simple connector->get_hw_state implementation for encoders that support only
3935 * one connector and no cloning and hence the encoder state determines the state
3936 * of the connector. */
3937 bool intel_connector_get_hw_state(struct intel_connector *connector)
3940 struct intel_encoder *encoder = connector->encoder;
6102 static bool intel_eld_uptodate(struct drm_connector *connector,
6107 struct drm_i915_private *dev_priv = connector->dev->dev_private;
6108 uint8_t *eld = connector->eld;
6131 static void g4x_write_eld(struct drm_connector *connector,
6134 struct drm_i915_private *dev_priv = connector->dev->dev_private;
6135 uint8_t *eld = connector->eld;
6147 if (intel_eld_uptodate(connector,
6171 static void haswell_write_eld(struct drm_connector *connector,
6174 struct drm_i915_private *dev_priv = connector->dev->dev_private;
6175 uint8_t *eld = connector->eld;
6228 if (intel_eld_uptodate(connector,
6258 static void ironlake_write_eld(struct drm_connector *connector,
6261 struct drm_i915_private *dev_priv = connector->dev->dev_private;
6262 uint8_t *eld = connector->eld;
6272 if (HAS_PCH_IBX(connector->dev)) {
6306 if (intel_eld_uptodate(connector,
6337 struct drm_connector *connector;
6341 connector = drm_select_eld(encoder, mode);
6342 if (!connector)
6346 connector->base.id,
6347 drm_get_connector_name(connector),
6348 connector->encoder->base.id,
6349 drm_get_encoder_name(connector->encoder));
6351 connector->eld[6] = drm_av_sync_delay(connector, mode) / 2;
6354 dev_priv->display.write_eld(connector, crtc);
6799 bool intel_get_load_detect_pipe(struct drm_connector *connector,
6805 intel_attached_encoder(connector);
6814 connector->base.id, drm_get_connector_name(connector),
6820 * - if the connector already has an assigned crtc, use it (but make
6823 * - try to find the first unused crtc that can drive this connector,
6827 /* See if we already have a CRTC for this connector */
6833 /* Make sure the crtc and connector are running */
6834 old->dpms_mode = connector->dpms;
6837 /* Make sure the crtc and connector are running */
6838 if (connector->dpms != DRM_MODE_DPMS_ON)
6839 connector->funcs->dpms(connector, DRM_MODE_DPMS_ON);
6865 to_intel_connector(connector)->new_encoder = intel_encoder;
6868 old->dpms_mode = connector->dpms;
6903 /* let the connector get through one full cycle before testing */
6908 void intel_release_load_detect_pipe(struct drm_connector *connector,
6912 intel_attached_encoder(connector);
6917 connector->base.id, drm_get_connector_name(connector),
6921 to_intel_connector(connector)->new_encoder = NULL;
6936 connector->funcs->dpms(connector, old->dpms_mode);
7023 * i830PllIsValid() because it relies on the xf86_config connector
7667 struct intel_connector *connector;
7669 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
7671 connector->new_encoder =
7672 to_intel_encoder(connector->base.encoder);
7690 struct intel_connector *connector;
7692 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
7694 connector->base.encoder = &connector->new_encoder->base;
7704 connected_sink_compute_bpp(struct intel_connector * connector,
7710 connector->base.base.id,
7711 drm_get_connector_name(&connector->base));
7714 if (connector->base.display_info.bpc &&
7715 connector->base.display_info.bpc * 3 < bpp) {
7717 bpp, connector->base.display_info.bpc*3);
7718 pipe_config->pipe_bpp = connector->base.display_info.bpc*3;
7722 if (connector->base.display_info.bpc == 0 && bpp > 24) {
7735 struct intel_connector *connector;
7777 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
7779 if (!connector->new_encoder ||
7780 connector->new_encoder->new_crtc != crtc)
7783 connected_sink_compute_bpp(connector, pipe_config);
7879 * adjust it according to limitations or connector properties, and also
7948 struct intel_connector *connector;
7957 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
7959 if (connector->base.encoder == &connector->new_encoder->base)
7962 if (connector->base.encoder) {
7963 tmp_crtc = connector->base.encoder->crtc;
7968 if (connector->new_encoder)
7970 1 << connector->new_encoder->new_crtc->pipe;
8054 struct drm_connector *connector;
8075 list_for_each_entry(connector, struct drm_connector, &dev->mode_config.connector_list, head) {
8076 if (!connector->encoder || !connector->encoder->crtc)
8079 intel_crtc = to_intel_crtc(connector->encoder->crtc);
8085 connector->dpms = DRM_MODE_DPMS_ON;
8086 drm_object_property_set_value(&connector->base,
8090 intel_encoder = to_intel_encoder(connector->encoder);
8208 struct intel_connector *connector;
8210 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
8212 /* This also checks the encoder/connector hw state with the
8214 intel_connector_check_state(connector);
8216 if (&connector->new_encoder->base != connector->base.encoder)
8217 DRM_ERROR("connector's staged encoder doesn't match current encoder\n");
8225 struct intel_connector *connector;
8242 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
8244 if (connector->base.encoder != &encoder->base)
8247 if (connector->base.dpms != DRM_MODE_DPMS_OFF)
8546 struct drm_connector *connector;
8571 list_for_each_entry(connector, struct drm_connector, &dev->mode_config.connector_list, head) {
8572 config->save_connector_encoders[count++] = connector->encoder;
8582 struct intel_connector *connector;
8592 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list, base.head) {
8593 connector->new_encoder =
8659 struct intel_connector *connector;
8670 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
8672 /* Otherwise traverse passed in connector list and get encoders
8675 if (set->connectors[ro] == &connector->base) {
8676 connector->new_encoder = connector->encoder;
8682 * the connector is on the changing crtc but not on the new
8683 * connector list, disable it. */
8685 connector->base.encoder &&
8686 connector->base.encoder->crtc == set->crtc) {
8687 connector->new_encoder = NULL;
8690 connector->base.base.id,
8691 drm_get_connector_name(&connector->base));
8695 if (&connector->new_encoder->base != connector->base.encoder) {
8700 /* connector->new_encoder is now updated for all connectors. */
8704 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
8706 if (!connector->new_encoder)
8709 new_crtc = connector->new_encoder->base.crtc;
8712 if (set->connectors[ro] == &connector->base)
8717 if (!intel_encoder_crtc_ok(&connector->new_encoder->base,
8721 connector->encoder->new_crtc = to_intel_crtc(new_crtc);
8724 connector->base.base.id,
8725 drm_get_connector_name(&connector->base),
8732 list_for_each_entry(connector, struct intel_connector,
8735 if (connector->new_encoder == encoder) {
8736 WARN_ON(!connector->new_encoder->new_crtc);
9671 intel_connector_break_all_links(struct intel_connector *connector)
9673 connector->base.dpms = DRM_MODE_DPMS_OFF;
9674 connector->base.encoder = NULL;
9675 connector->encoder->connectors_active = false;
9676 connector->encoder->base.crtc = NULL;
9681 struct intel_connector *connector;
9688 list_for_each_entry(connector, struct intel_connector,
9691 if (connector->encoder->type == INTEL_OUTPUT_ANALOG) {
9692 crt = &connector->base;
9740 struct intel_connector *connector;
9755 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
9757 if (connector->encoder->base.crtc != &crtc->base)
9760 intel_connector_break_all_links(connector);
9793 /* Because we only establish the connector -> encoder ->
9795 * crtc is now deactivated. Break the links. connector
9809 struct intel_connector *connector;
9837 list_for_each_entry(connector, struct intel_connector,
9840 if (connector->encoder != encoder)
9843 intel_connector_break_all_links(connector);
9867 struct intel_connector *connector;
9925 list_for_each_entry(connector, struct intel_connector, &dev->mode_config.connector_list,
9927 if (connector->get_hw_state(connector)) {
9928 connector->base.dpms = DRM_MODE_DPMS_ON;
9929 connector->encoder->connectors_active = true;
9930 connector->base.encoder = &connector->encoder->base;
9932 connector->base.dpms = DRM_MODE_DPMS_OFF;
9933 connector->base.encoder = NULL;
9936 connector->base.base.id,
9937 drm_get_connector_name(&connector->base),
9938 connector->base.encoder ? "enabled" : "disabled");
10066 always give back the encoder for the connector
10068 struct drm_encoder *intel_best_encoder(struct drm_connector *connector)
10070 return &intel_attached_encoder(connector)->base;
10073 void intel_connector_attach_encoder(struct intel_connector *connector,
10076 connector->encoder = encoder;
10077 (void) drm_mode_connector_attach_encoder(&connector->base,