Lines Matching defs:connector
102 static struct intel_encoder *intel_find_encoder(struct intel_connector *connector, int pipe)
104 if (!connector->mst_port)
105 return connector->encoder;
107 return &connector->mst_port->mst_encoders[pipe]->base;
572 * connector, etc., rather than just a single range.
5079 struct drm_connector *connector;
5101 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
5102 if (!connector->encoder || !connector->encoder->crtc)
5105 if (connector->encoder->crtc != crtc)
5108 connector->dpms = DRM_MODE_DPMS_OFF;
5109 to_intel_encoder(connector->encoder)->connectors_active = false;
5121 /* Simple dpms helper for encoders with just one connector, no cloning and only
5139 static void intel_connector_check_state(struct intel_connector *connector)
5141 if (connector->get_hw_state(connector)) {
5142 struct intel_encoder *encoder = connector->encoder;
5148 connector->base.base.id,
5149 connector->base.name);
5152 if (connector->mst_port)
5155 WARN(connector->base.dpms == DRM_MODE_DPMS_OFF,
5156 "wrong connector dpms state\n");
5157 WARN(connector->base.encoder != &encoder->base,
5158 "active connector not linked to encoder\n");
5181 void intel_connector_dpms(struct drm_connector *connector, int mode)
5187 if (mode == connector->dpms)
5190 connector->dpms = mode;
5193 if (connector->encoder)
5194 intel_encoder_dpms(to_intel_encoder(connector->encoder), mode);
5196 intel_modeset_check_state(connector->dev);
5199 /* Simple connector->get_hw_state implementation for encoders that support only
5200 * one connector and no cloning and hence the encoder state determines the state
5201 * of the connector. */
5202 bool intel_connector_get_hw_state(struct intel_connector *connector)
5205 struct intel_encoder *encoder = connector->encoder;
7941 static bool intel_eld_uptodate(struct drm_connector *connector,
7946 struct drm_i915_private *dev_priv = connector->dev->dev_private;
7947 uint8_t *eld = connector->eld;
7970 static void g4x_write_eld(struct drm_connector *connector,
7974 struct drm_i915_private *dev_priv = connector->dev->dev_private;
7975 uint8_t *eld = connector->eld;
7987 if (intel_eld_uptodate(connector,
8011 static void haswell_write_eld(struct drm_connector *connector,
8015 struct drm_i915_private *dev_priv = connector->dev->dev_private;
8016 uint8_t *eld = connector->eld;
8064 if (intel_eld_uptodate(connector,
8094 static void ironlake_write_eld(struct drm_connector *connector,
8098 struct drm_i915_private *dev_priv = connector->dev->dev_private;
8099 uint8_t *eld = connector->eld;
8109 if (HAS_PCH_IBX(connector->dev)) {
8114 } else if (IS_VALLEYVIEW(connector->dev)) {
8128 if (IS_VALLEYVIEW(connector->dev)) {
8132 intel_encoder = intel_attached_encoder(connector);
8160 if (intel_eld_uptodate(connector,
8191 struct drm_connector *connector;
8195 connector = drm_select_eld(encoder, mode);
8196 if (!connector)
8200 connector->base.id,
8201 connector->name,
8202 connector->encoder->base.id,
8203 connector->encoder->name);
8205 connector->eld[6] = drm_av_sync_delay(connector, mode) / 2;
8208 dev_priv->display.write_eld(connector, crtc, mode);
8663 bool intel_get_load_detect_pipe(struct drm_connector *connector,
8670 intel_attached_encoder(connector);
8680 connector->base.id, connector->name,
8691 * - if the connector already has an assigned crtc, use it (but make
8694 * - try to find the first unused crtc that can drive this connector,
8698 /* See if we already have a CRTC for this connector */
8706 old->dpms_mode = connector->dpms;
8709 /* Make sure the crtc and connector are running */
8710 if (connector->dpms != DRM_MODE_DPMS_ON)
8711 connector->funcs->dpms(connector, DRM_MODE_DPMS_ON);
8743 to_intel_connector(connector)->new_encoder = intel_encoder;
8748 old->dpms_mode = connector->dpms;
8781 /* let the connector get through one full cycle before testing */
8800 void intel_release_load_detect_pipe(struct drm_connector *connector,
8804 intel_attached_encoder(connector);
8810 connector->base.id, connector->name,
8814 to_intel_connector(connector)->new_encoder = NULL;
8830 connector->funcs->dpms(connector, old->dpms_mode);
10117 struct intel_connector *connector;
10119 list_for_each_entry(connector, &dev->mode_config.connector_list,
10121 connector->new_encoder =
10122 to_intel_encoder(connector->base.encoder);
10149 struct intel_connector *connector;
10151 list_for_each_entry(connector, &dev->mode_config.connector_list,
10153 connector->base.encoder = &connector->new_encoder->base;
10166 connected_sink_compute_bpp(struct intel_connector *connector,
10172 connector->base.base.id,
10173 connector->base.name);
10176 if (connector->base.display_info.bpc &&
10177 connector->base.display_info.bpc * 3 < bpp) {
10179 bpp, connector->base.display_info.bpc*3);
10180 pipe_config->pipe_bpp = connector->base.display_info.bpc*3;
10184 if (connector->base.display_info.bpc == 0 && bpp > 24) {
10197 struct intel_connector *connector;
10239 list_for_each_entry(connector, &dev->mode_config.connector_list,
10241 if (!connector->new_encoder ||
10242 connector->new_encoder->new_crtc != crtc)
10245 connected_sink_compute_bpp(connector, pipe_config);
10423 * adjust it according to limitations or connector properties, and also
10479 struct intel_connector *connector;
10488 list_for_each_entry(connector, &dev->mode_config.connector_list,
10490 if (connector->base.encoder == &connector->new_encoder->base)
10493 if (connector->base.encoder) {
10494 tmp_crtc = connector->base.encoder->crtc;
10499 if (connector->new_encoder)
10501 1 << connector->new_encoder->new_crtc->pipe;
10576 struct drm_connector *connector;
10598 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
10599 if (!connector->encoder || !connector->encoder->crtc)
10602 intel_crtc = to_intel_crtc(connector->encoder->crtc);
10608 connector->dpms = DRM_MODE_DPMS_ON;
10609 drm_object_property_set_value(&connector->base,
10613 intel_encoder = to_intel_encoder(connector->encoder);
10833 struct intel_connector *connector;
10835 list_for_each_entry(connector, &dev->mode_config.connector_list,
10837 /* This also checks the encoder/connector hw state with the
10839 intel_connector_check_state(connector);
10841 WARN(&connector->new_encoder->base != connector->base.encoder,
10842 "connector's staged encoder doesn't match current encoder\n");
10850 struct intel_connector *connector;
10866 list_for_each_entry(connector, &dev->mode_config.connector_list,
10868 if (connector->base.encoder != &encoder->base)
10871 if (connector->base.dpms != DRM_MODE_DPMS_OFF)
10875 * for MST connectors if we unplug the connector is gone
11260 struct drm_connector *connector;
11296 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
11297 config->save_connector_encoders[count++] = connector->encoder;
11308 struct intel_connector *connector;
11328 list_for_each_entry(connector, &dev->mode_config.connector_list, base.head) {
11329 connector->new_encoder =
11410 struct intel_connector *connector;
11420 list_for_each_entry(connector, &dev->mode_config.connector_list,
11422 /* Otherwise traverse passed in connector list and get encoders
11425 if (set->connectors[ro] == &connector->base) {
11426 connector->new_encoder = intel_find_encoder(connector, to_intel_crtc(set->crtc)->pipe);
11432 * the connector is on the changing crtc but not on the new
11433 * connector list, disable it. */
11435 connector->base.encoder &&
11436 connector->base.encoder->crtc == set->crtc) {
11437 connector->new_encoder = NULL;
11440 connector->base.base.id,
11441 connector->base.name);
11445 if (&connector->new_encoder->base != connector->base.encoder) {
11450 /* connector->new_encoder is now updated for all connectors. */
11453 list_for_each_entry(connector, &dev->mode_config.connector_list,
11457 if (!connector->new_encoder)
11460 new_crtc = connector->new_encoder->base.crtc;
11463 if (set->connectors[ro] == &connector->base)
11468 if (!drm_encoder_crtc_ok(&connector->new_encoder->base,
11472 connector->new_encoder->new_crtc = to_intel_crtc(new_crtc);
11475 connector->base.base.id,
11476 connector->base.name,
11483 list_for_each_entry(connector,
11486 if (connector->new_encoder == encoder) {
11487 WARN_ON(!connector->new_encoder->new_crtc);
11505 list_for_each_entry(connector, &dev->mode_config.connector_list,
11507 if (connector->new_encoder)
11508 if (connector->new_encoder != connector->encoder)
11509 connector->encoder = connector->new_encoder;
11540 struct intel_connector *connector;
11545 list_for_each_entry(connector, &dev->mode_config.connector_list, base.head) {
11546 if (connector->new_encoder &&
11547 connector->new_encoder->new_crtc == crtc)
11548 connector->new_encoder = NULL;
12194 enum pipe intel_get_pipe_from_connector(struct intel_connector *connector)
12196 struct drm_encoder *encoder = connector->base.encoder;
12197 struct drm_device *dev = connector->base.dev;
13067 struct intel_connector *connector;
13075 list_for_each_entry(connector,
13078 if (connector->encoder->type == INTEL_OUTPUT_ANALOG) {
13079 crt = &connector->base;
13132 struct intel_connector *connector;
13148 list_for_each_entry(connector, &dev->mode_config.connector_list,
13150 if (connector->encoder->base.crtc != &crtc->base)
13153 connector->base.dpms = DRM_MODE_DPMS_OFF;
13154 connector->base.encoder = NULL;
13158 list_for_each_entry(connector, &dev->mode_config.connector_list,
13160 if (connector->encoder->base.crtc == &crtc->base) {
13161 connector->encoder->base.crtc = NULL;
13162 connector->encoder->connectors_active = false;
13195 /* Because we only establish the connector -> encoder ->
13197 * crtc is now deactivated. Break the links. connector
13229 struct intel_connector *connector;
13261 list_for_each_entry(connector,
13264 if (connector->encoder != encoder)
13266 connector->base.dpms = DRM_MODE_DPMS_OFF;
13267 connector->base.encoder = NULL;
13318 struct intel_connector *connector;
13374 list_for_each_entry(connector, &dev->mode_config.connector_list,
13376 if (connector->get_hw_state(connector)) {
13377 connector->base.dpms = DRM_MODE_DPMS_ON;
13378 connector->encoder->connectors_active = true;
13379 connector->base.encoder = &connector->encoder->base;
13381 connector->base.dpms = DRM_MODE_DPMS_OFF;
13382 connector->base.encoder = NULL;
13385 connector->base.base.id,
13386 connector->base.name,
13387 connector->base.encoder ? "enabled" : "disabled");
13501 struct drm_connector *connector = &intel_connector->base;
13503 intel_panel_destroy_backlight(connector);
13504 drm_connector_unregister(connector);
13510 struct drm_connector *connector;
13543 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
13546 intel_connector = to_intel_connector(connector);
13560 * Return which encoder is currently attached for connector.
13562 struct drm_encoder *intel_best_encoder(struct drm_connector *connector)
13564 return &intel_attached_encoder(connector)->base;
13567 void intel_connector_attach_encoder(struct intel_connector *connector,
13570 connector->encoder = encoder;
13571 drm_mode_connector_attach_encoder(&connector->base,