Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/i915/dp: s/intel_connector/connector/
Use the contemporary naming convention of struct intel_connector
*connector. Avoid struct drm_connector use altogether. In a few cases
add local struct drm_display_info and struct intel_display pointers to
help move away from struct drm_connector usage.
Reviewed-by: Luca Coelho <luciano.coelho@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/2951b76d7476adcffb6d16079ab52207d1aab92d.1734083244.git.jani.nikula@intel.com
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
+99
-103
+99
-103
drivers/gpu/drm/i915/display/intel_dp.c
+99
-103
drivers/gpu/drm/i915/display/intel_dp.c
···
1673
1673
bool respect_downstream_limits)
1674
1674
{
1675
1675
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
1676
-
struct intel_connector *intel_connector = intel_dp->attached_connector;
1676
+
struct intel_connector *connector = intel_dp->attached_connector;
1677
1677
int bpp, bpc;
1678
1678
1679
1679
bpc = crtc_state->pipe_bpp / 3;
···
1695
1695
bpp = bpc * 3;
1696
1696
if (intel_dp_is_edp(intel_dp)) {
1697
1697
/* Get bpp from vbt only for panels that dont have bpp in edid */
1698
-
if (intel_connector->base.display_info.bpc == 0 &&
1699
-
intel_connector->panel.vbt.edp.bpp &&
1700
-
intel_connector->panel.vbt.edp.bpp < bpp) {
1698
+
if (connector->base.display_info.bpc == 0 &&
1699
+
connector->panel.vbt.edp.bpp &&
1700
+
connector->panel.vbt.edp.bpp < bpp) {
1701
1701
drm_dbg_kms(&dev_priv->drm,
1702
1702
"clamping bpp for eDP panel to BIOS-provided %i\n",
1703
-
intel_connector->panel.vbt.edp.bpp);
1704
-
bpp = intel_connector->panel.vbt.edp.bpp;
1703
+
connector->panel.vbt.edp.bpp);
1704
+
bpp = connector->panel.vbt.edp.bpp;
1705
1705
}
1706
1706
}
1707
1707
···
3660
3660
3661
3661
static int intel_dp_hdmi_sink_max_frl(struct intel_dp *intel_dp)
3662
3662
{
3663
-
struct intel_connector *intel_connector = intel_dp->attached_connector;
3664
-
struct drm_connector *connector = &intel_connector->base;
3663
+
struct intel_connector *connector = intel_dp->attached_connector;
3664
+
const struct drm_display_info *info = &connector->base.display_info;
3665
3665
int max_frl_rate;
3666
3666
int max_lanes, rate_per_lane;
3667
3667
int max_dsc_lanes, dsc_rate_per_lane;
3668
3668
3669
-
max_lanes = connector->display_info.hdmi.max_lanes;
3670
-
rate_per_lane = connector->display_info.hdmi.max_frl_rate_per_lane;
3669
+
max_lanes = info->hdmi.max_lanes;
3670
+
rate_per_lane = info->hdmi.max_frl_rate_per_lane;
3671
3671
max_frl_rate = max_lanes * rate_per_lane;
3672
3672
3673
-
if (connector->display_info.hdmi.dsc_cap.v_1p2) {
3674
-
max_dsc_lanes = connector->display_info.hdmi.dsc_cap.max_lanes;
3675
-
dsc_rate_per_lane = connector->display_info.hdmi.dsc_cap.max_frl_rate_per_lane;
3673
+
if (info->hdmi.dsc_cap.v_1p2) {
3674
+
max_dsc_lanes = info->hdmi.dsc_cap.max_lanes;
3675
+
dsc_rate_per_lane = info->hdmi.dsc_cap.max_frl_rate_per_lane;
3676
3676
if (max_dsc_lanes && dsc_rate_per_lane)
3677
3677
max_frl_rate = min(max_frl_rate, max_dsc_lanes * dsc_rate_per_lane);
3678
3678
}
···
3831
3831
intel_dp_pcon_dsc_enc_slices(struct intel_dp *intel_dp,
3832
3832
const struct intel_crtc_state *crtc_state)
3833
3833
{
3834
-
struct intel_connector *intel_connector = intel_dp->attached_connector;
3835
-
struct drm_connector *connector = &intel_connector->base;
3836
-
int hdmi_throughput = connector->display_info.hdmi.dsc_cap.clk_per_slice;
3837
-
int hdmi_max_slices = connector->display_info.hdmi.dsc_cap.max_slices;
3834
+
struct intel_connector *connector = intel_dp->attached_connector;
3835
+
const struct drm_display_info *info = &connector->base.display_info;
3836
+
int hdmi_throughput = info->hdmi.dsc_cap.clk_per_slice;
3837
+
int hdmi_max_slices = info->hdmi.dsc_cap.max_slices;
3838
3838
int pcon_max_slices = drm_dp_pcon_dsc_max_slices(intel_dp->pcon_dsc_dpcd);
3839
3839
int pcon_max_slice_width = drm_dp_pcon_dsc_max_slice_width(intel_dp->pcon_dsc_dpcd);
3840
3840
···
3848
3848
const struct intel_crtc_state *crtc_state,
3849
3849
int num_slices, int slice_width)
3850
3850
{
3851
-
struct intel_connector *intel_connector = intel_dp->attached_connector;
3852
-
struct drm_connector *connector = &intel_connector->base;
3851
+
struct intel_connector *connector = intel_dp->attached_connector;
3852
+
const struct drm_display_info *info = &connector->base.display_info;
3853
3853
int output_format = crtc_state->output_format;
3854
-
bool hdmi_all_bpp = connector->display_info.hdmi.dsc_cap.all_bpp;
3854
+
bool hdmi_all_bpp = info->hdmi.dsc_cap.all_bpp;
3855
3855
int pcon_fractional_bpp = drm_dp_pcon_dsc_bpp_incr(intel_dp->pcon_dsc_dpcd);
3856
3856
int hdmi_max_chunk_bytes =
3857
-
connector->display_info.hdmi.dsc_cap.total_chunk_kbytes * 1024;
3857
+
info->hdmi.dsc_cap.total_chunk_kbytes * 1024;
3858
3858
3859
3859
return intel_hdmi_dsc_get_bpp(pcon_fractional_bpp, slice_width,
3860
3860
num_slices, output_format, hdmi_all_bpp,
···
3865
3865
intel_dp_pcon_dsc_configure(struct intel_dp *intel_dp,
3866
3866
const struct intel_crtc_state *crtc_state)
3867
3867
{
3868
+
struct intel_connector *connector = intel_dp->attached_connector;
3869
+
const struct drm_display_info *info;
3870
+
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3868
3871
u8 pps_param[6];
3869
3872
int slice_height;
3870
3873
int slice_width;
3871
3874
int num_slices;
3872
3875
int bits_per_pixel;
3873
3876
int ret;
3874
-
struct intel_connector *intel_connector = intel_dp->attached_connector;
3875
-
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3876
-
struct drm_connector *connector;
3877
3877
bool hdmi_is_dsc_1_2;
3878
3878
3879
3879
if (!intel_dp_is_hdmi_2_1_sink(intel_dp))
3880
3880
return;
3881
3881
3882
-
if (!intel_connector)
3882
+
if (!connector)
3883
3883
return;
3884
-
connector = &intel_connector->base;
3885
-
hdmi_is_dsc_1_2 = connector->display_info.hdmi.dsc_cap.v_1p2;
3884
+
3885
+
info = &connector->base.display_info;
3886
+
3887
+
hdmi_is_dsc_1_2 = info->hdmi.dsc_cap.v_1p2;
3886
3888
3887
3889
if (!drm_dp_pcon_enc_is_dsc_1_2(intel_dp->pcon_dsc_dpcd) ||
3888
3890
!hdmi_is_dsc_1_2)
···
5636
5634
}
5637
5635
5638
5636
static int
5639
-
intel_dp_detect(struct drm_connector *connector,
5637
+
intel_dp_detect(struct drm_connector *_connector,
5640
5638
struct drm_modeset_acquire_ctx *ctx,
5641
5639
bool force)
5642
5640
{
5643
-
struct intel_display *display = to_intel_display(connector->dev);
5644
-
struct drm_i915_private *dev_priv = to_i915(connector->dev);
5645
-
struct intel_connector *intel_connector =
5646
-
to_intel_connector(connector);
5647
-
struct intel_dp *intel_dp = intel_attached_dp(intel_connector);
5641
+
struct intel_display *display = to_intel_display(_connector->dev);
5642
+
struct drm_i915_private *dev_priv = to_i915(_connector->dev);
5643
+
struct intel_connector *connector = to_intel_connector(_connector);
5644
+
struct intel_dp *intel_dp = intel_attached_dp(connector);
5648
5645
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
5649
5646
struct intel_encoder *encoder = &dig_port->base;
5650
5647
enum drm_connector_status status;
5651
5648
int ret;
5652
5649
5653
5650
drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s]\n",
5654
-
connector->base.id, connector->name);
5651
+
connector->base.base.id, connector->base.name);
5655
5652
drm_WARN_ON(&dev_priv->drm,
5656
5653
!drm_modeset_is_locked(&dev_priv->drm.mode_config.connection_mutex));
5657
5654
···
5658
5657
return connector_status_disconnected;
5659
5658
5660
5659
if (!intel_display_driver_check_access(display))
5661
-
return connector->status;
5660
+
return connector->base.status;
5662
5661
5663
-
intel_dp_flush_connector_commits(intel_connector);
5662
+
intel_dp_flush_connector_commits(connector);
5664
5663
5665
5664
intel_pps_vdd_on(intel_dp);
5666
5665
···
5686
5685
5687
5686
if (status == connector_status_disconnected) {
5688
5687
intel_dp_test_reset(intel_dp);
5689
-
memset(intel_connector->dp.dsc_dpcd, 0, sizeof(intel_connector->dp.dsc_dpcd));
5688
+
memset(connector->dp.dsc_dpcd, 0, sizeof(connector->dp.dsc_dpcd));
5690
5689
intel_dp->psr.sink_panel_replay_support = false;
5691
5690
intel_dp->psr.sink_panel_replay_su_support = false;
5692
5691
···
5707
5706
}
5708
5707
5709
5708
if (ret == 1)
5710
-
intel_connector->base.epoch_counter++;
5709
+
connector->base.epoch_counter++;
5711
5710
5712
5711
if (!intel_dp_is_edp(intel_dp))
5713
5712
intel_psr_init_dpcd(intel_dp);
5714
5713
5715
-
intel_dp_detect_dsc_caps(intel_dp, intel_connector);
5714
+
intel_dp_detect_dsc_caps(intel_dp, connector);
5716
5715
5717
5716
intel_dp_detect_sdp_caps(intel_dp);
5718
5717
···
5755
5754
intel_dp->aux.i2c_defer_count = 0;
5756
5755
5757
5756
intel_dp_set_edid(intel_dp);
5758
-
if (intel_dp_is_edp(intel_dp) ||
5759
-
to_intel_connector(connector)->detect_edid)
5757
+
if (intel_dp_is_edp(intel_dp) || connector->detect_edid)
5760
5758
status = connector_status_connected;
5761
5759
5762
5760
intel_dp_check_device_service_irq(intel_dp);
···
5765
5765
intel_dp_unset_edid(intel_dp);
5766
5766
5767
5767
if (!intel_dp_is_edp(intel_dp))
5768
-
drm_dp_set_subconnector_property(connector,
5768
+
drm_dp_set_subconnector_property(&connector->base,
5769
5769
status,
5770
5770
intel_dp->dpcd,
5771
5771
intel_dp->downstream_ports);
···
5798
5798
intel_dp_set_edid(intel_dp);
5799
5799
}
5800
5800
5801
-
static int intel_dp_get_modes(struct drm_connector *connector)
5801
+
static int intel_dp_get_modes(struct drm_connector *_connector)
5802
5802
{
5803
-
struct intel_connector *intel_connector = to_intel_connector(connector);
5803
+
struct intel_display *display = to_intel_display(_connector->dev);
5804
+
struct intel_connector *connector = to_intel_connector(_connector);
5805
+
struct intel_dp *intel_dp = intel_attached_dp(connector);
5804
5806
int num_modes;
5805
5807
5806
5808
/* drm_edid_connector_update() done in ->detect() or ->force() */
5807
-
num_modes = drm_edid_connector_add_modes(connector);
5809
+
num_modes = drm_edid_connector_add_modes(&connector->base);
5808
5810
5809
5811
/* Also add fixed mode, which may or may not be present in EDID */
5810
-
if (intel_dp_is_edp(intel_attached_dp(intel_connector)))
5811
-
num_modes += intel_panel_get_modes(intel_connector);
5812
+
if (intel_dp_is_edp(intel_dp))
5813
+
num_modes += intel_panel_get_modes(connector);
5812
5814
5813
5815
if (num_modes)
5814
5816
return num_modes;
5815
5817
5816
-
if (!intel_connector->detect_edid) {
5817
-
struct intel_dp *intel_dp = intel_attached_dp(intel_connector);
5818
+
if (!connector->detect_edid) {
5818
5819
struct drm_display_mode *mode;
5819
5820
5820
-
mode = drm_dp_downstream_mode(connector->dev,
5821
+
mode = drm_dp_downstream_mode(display->drm,
5821
5822
intel_dp->dpcd,
5822
5823
intel_dp->downstream_ports);
5823
5824
if (mode) {
5824
-
drm_mode_probed_add(connector, mode);
5825
+
drm_mode_probed_add(&connector->base, mode);
5825
5826
num_modes++;
5826
5827
}
5827
5828
}
···
6292
6291
}
6293
6292
6294
6293
static bool intel_edp_init_connector(struct intel_dp *intel_dp,
6295
-
struct intel_connector *intel_connector)
6294
+
struct intel_connector *connector)
6296
6295
{
6297
6296
struct intel_display *display = to_intel_display(intel_dp);
6298
6297
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
6299
-
struct drm_connector *connector = &intel_connector->base;
6300
6298
struct drm_display_mode *fixed_mode;
6301
6299
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
6302
6300
bool has_dpcd;
···
6319
6319
return false;
6320
6320
}
6321
6321
6322
-
intel_bios_init_panel_early(display, &intel_connector->panel,
6322
+
intel_bios_init_panel_early(display, &connector->panel,
6323
6323
encoder->devdata);
6324
6324
6325
6325
if (!intel_pps_init(intel_dp)) {
···
6346
6346
intel_alpm_init_dpcd(intel_dp);
6347
6347
6348
6348
/* Cache DPCD and EDID for edp. */
6349
-
has_dpcd = intel_edp_init_dpcd(intel_dp, intel_connector);
6349
+
has_dpcd = intel_edp_init_dpcd(intel_dp, connector);
6350
6350
6351
6351
if (!has_dpcd) {
6352
6352
/* if this fails, presume the device is a ghost */
···
6396
6396
}
6397
6397
6398
6398
mutex_lock(&dev_priv->drm.mode_config.mutex);
6399
-
drm_edid = drm_edid_read_ddc(connector, connector->ddc);
6399
+
drm_edid = drm_edid_read_ddc(&connector->base, connector->base.ddc);
6400
6400
if (!drm_edid) {
6401
6401
/* Fallback to EDID from ACPI OpRegion, if any */
6402
-
drm_edid = intel_opregion_get_edid(intel_connector);
6402
+
drm_edid = intel_opregion_get_edid(connector);
6403
6403
if (drm_edid)
6404
6404
drm_dbg_kms(&dev_priv->drm,
6405
6405
"[CONNECTOR:%d:%s] Using OpRegion EDID\n",
6406
-
connector->base.id, connector->name);
6406
+
connector->base.base.id, connector->base.name);
6407
6407
}
6408
6408
if (drm_edid) {
6409
-
if (drm_edid_connector_update(connector, drm_edid) ||
6410
-
!drm_edid_connector_add_modes(connector)) {
6411
-
drm_edid_connector_update(connector, NULL);
6409
+
if (drm_edid_connector_update(&connector->base, drm_edid) ||
6410
+
!drm_edid_connector_add_modes(&connector->base)) {
6411
+
drm_edid_connector_update(&connector->base, NULL);
6412
6412
drm_edid_free(drm_edid);
6413
6413
drm_edid = ERR_PTR(-EINVAL);
6414
6414
}
···
6416
6416
drm_edid = ERR_PTR(-ENOENT);
6417
6417
}
6418
6418
6419
-
intel_bios_init_panel_late(display, &intel_connector->panel, encoder->devdata,
6419
+
intel_bios_init_panel_late(display, &connector->panel, encoder->devdata,
6420
6420
IS_ERR(drm_edid) ? NULL : drm_edid);
6421
6421
6422
-
intel_panel_add_edid_fixed_modes(intel_connector, true);
6422
+
intel_panel_add_edid_fixed_modes(connector, true);
6423
6423
6424
6424
/* MSO requires information from the EDID */
6425
6425
intel_edp_mso_init(intel_dp);
6426
6426
6427
6427
/* multiply the mode clock and horizontal timings for MSO */
6428
-
list_for_each_entry(fixed_mode, &intel_connector->panel.fixed_modes, head)
6429
-
intel_edp_mso_mode_fixup(intel_connector, fixed_mode);
6428
+
list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head)
6429
+
intel_edp_mso_mode_fixup(connector, fixed_mode);
6430
6430
6431
6431
/* fallback to VBT if available for eDP */
6432
-
if (!intel_panel_preferred_fixed_mode(intel_connector))
6433
-
intel_panel_add_vbt_lfp_fixed_mode(intel_connector);
6432
+
if (!intel_panel_preferred_fixed_mode(connector))
6433
+
intel_panel_add_vbt_lfp_fixed_mode(connector);
6434
6434
6435
6435
mutex_unlock(&dev_priv->drm.mode_config.mutex);
6436
6436
6437
-
if (!intel_panel_preferred_fixed_mode(intel_connector)) {
6437
+
if (!intel_panel_preferred_fixed_mode(connector)) {
6438
6438
drm_info(&dev_priv->drm,
6439
6439
"[ENCODER:%d:%s] failed to find fixed mode for the panel, disabling eDP\n",
6440
6440
encoder->base.base.id, encoder->base.name);
6441
6441
goto out_vdd_off;
6442
6442
}
6443
6443
6444
-
intel_panel_init(intel_connector, drm_edid);
6444
+
intel_panel_init(connector, drm_edid);
6445
6445
6446
-
intel_edp_backlight_setup(intel_dp, intel_connector);
6446
+
intel_edp_backlight_setup(intel_dp, connector);
6447
6447
6448
6448
intel_edp_add_properties(intel_dp);
6449
6449
···
6453
6453
6454
6454
out_vdd_off:
6455
6455
intel_pps_vdd_off_sync(intel_dp);
6456
-
intel_bios_fini_panel(&intel_connector->panel);
6456
+
intel_bios_fini_panel(&connector->panel);
6457
6457
6458
6458
return false;
6459
6459
}
6460
6460
6461
6461
static void intel_dp_modeset_retry_work_fn(struct work_struct *work)
6462
6462
{
6463
-
struct intel_connector *intel_connector;
6464
-
struct drm_connector *connector;
6463
+
struct intel_connector *connector = container_of(work, typeof(*connector),
6464
+
modeset_retry_work);
6465
+
struct intel_display *display = to_intel_display(connector);
6465
6466
6466
-
intel_connector = container_of(work, typeof(*intel_connector),
6467
-
modeset_retry_work);
6468
-
connector = &intel_connector->base;
6469
-
drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s]\n", connector->base.id,
6470
-
connector->name);
6467
+
drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s]\n", connector->base.base.id,
6468
+
connector->base.name);
6471
6469
6472
6470
/* Grab the locks before changing connector property*/
6473
-
mutex_lock(&connector->dev->mode_config.mutex);
6471
+
mutex_lock(&display->drm->mode_config.mutex);
6474
6472
/* Set connector link status to BAD and send a Uevent to notify
6475
6473
* userspace to do a modeset.
6476
6474
*/
6477
-
drm_connector_set_link_status_property(connector,
6475
+
drm_connector_set_link_status_property(&connector->base,
6478
6476
DRM_MODE_LINK_STATUS_BAD);
6479
-
mutex_unlock(&connector->dev->mode_config.mutex);
6477
+
mutex_unlock(&display->drm->mode_config.mutex);
6480
6478
/* Send Hotplug uevent so userspace can reprobe */
6481
-
drm_kms_helper_connector_hotplug_event(connector);
6479
+
drm_kms_helper_connector_hotplug_event(&connector->base);
6482
6480
6483
-
drm_connector_put(connector);
6481
+
drm_connector_put(&connector->base);
6484
6482
}
6485
6483
6486
6484
void intel_dp_init_modeset_retry_work(struct intel_connector *connector)
···
6489
6491
6490
6492
bool
6491
6493
intel_dp_init_connector(struct intel_digital_port *dig_port,
6492
-
struct intel_connector *intel_connector)
6494
+
struct intel_connector *connector)
6493
6495
{
6494
6496
struct intel_display *display = to_intel_display(dig_port);
6495
-
struct drm_connector *connector = &intel_connector->base;
6496
6497
struct intel_dp *intel_dp = &dig_port->dp;
6497
6498
struct intel_encoder *encoder = &dig_port->base;
6498
6499
struct drm_device *dev = encoder->base.dev;
···
6500
6503
int type;
6501
6504
6502
6505
/* Initialize the work for modeset in case of link train failure */
6503
-
intel_dp_init_modeset_retry_work(intel_connector);
6506
+
intel_dp_init_modeset_retry_work(connector);
6504
6507
6505
6508
if (drm_WARN(dev, dig_port->max_lanes < 1,
6506
6509
"Not enough lanes (%d) for DP on [ENCODER:%d:%s]\n",
···
6512
6515
6513
6516
/* Preserve the current hw state. */
6514
6517
intel_dp->DP = intel_de_read(dev_priv, intel_dp->output_reg);
6515
-
intel_dp->attached_connector = intel_connector;
6518
+
intel_dp->attached_connector = connector;
6516
6519
6517
6520
if (_intel_dp_is_port_edp(dev_priv, encoder->devdata, port)) {
6518
6521
/*
···
6540
6543
vlv_pps_pipe_init(intel_dp);
6541
6544
6542
6545
intel_dp_aux_init(intel_dp);
6543
-
intel_connector->dp.dsc_decompression_aux = &intel_dp->aux;
6546
+
connector->dp.dsc_decompression_aux = &intel_dp->aux;
6544
6547
6545
6548
drm_dbg_kms(&dev_priv->drm,
6546
6549
"Adding %s connector on [ENCODER:%d:%s]\n",
6547
6550
type == DRM_MODE_CONNECTOR_eDP ? "eDP" : "DP",
6548
6551
encoder->base.base.id, encoder->base.name);
6549
6552
6550
-
drm_connector_init_with_ddc(dev, connector, &intel_dp_connector_funcs,
6553
+
drm_connector_init_with_ddc(dev, &connector->base, &intel_dp_connector_funcs,
6551
6554
type, &intel_dp->aux.ddc);
6552
-
drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
6555
+
drm_connector_helper_add(&connector->base, &intel_dp_connector_helper_funcs);
6553
6556
6554
6557
if (!HAS_GMCH(dev_priv) && DISPLAY_VER(dev_priv) < 12)
6555
-
connector->interlace_allowed = true;
6558
+
connector->base.interlace_allowed = true;
6556
6559
6557
6560
if (type != DRM_MODE_CONNECTOR_eDP)
6558
-
intel_connector->polled = DRM_CONNECTOR_POLL_HPD;
6559
-
intel_connector->base.polled = intel_connector->polled;
6561
+
connector->polled = DRM_CONNECTOR_POLL_HPD;
6562
+
connector->base.polled = connector->polled;
6560
6563
6561
-
intel_connector_attach_encoder(intel_connector, encoder);
6564
+
intel_connector_attach_encoder(connector, encoder);
6562
6565
6563
6566
if (HAS_DDI(dev_priv))
6564
-
intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
6567
+
connector->get_hw_state = intel_ddi_connector_get_hw_state;
6565
6568
else
6566
-
intel_connector->get_hw_state = intel_connector_get_hw_state;
6567
-
intel_connector->sync_state = intel_dp_connector_sync_state;
6569
+
connector->get_hw_state = intel_connector_get_hw_state;
6570
+
connector->sync_state = intel_dp_connector_sync_state;
6568
6571
6569
-
if (!intel_edp_init_connector(intel_dp, intel_connector)) {
6572
+
if (!intel_edp_init_connector(intel_dp, connector)) {
6570
6573
intel_dp_aux_fini(intel_dp);
6571
6574
goto fail;
6572
6575
}
···
6576
6579
intel_dp_reset_link_params(intel_dp);
6577
6580
6578
6581
/* init MST on ports that can support it */
6579
-
intel_dp_mst_encoder_init(dig_port,
6580
-
intel_connector->base.base.id);
6582
+
intel_dp_mst_encoder_init(dig_port, connector->base.base.id);
6581
6583
6582
-
intel_dp_add_properties(intel_dp, connector);
6584
+
intel_dp_add_properties(intel_dp, &connector->base);
6583
6585
6584
6586
if (is_hdcp_supported(display, port) && !intel_dp_is_edp(intel_dp)) {
6585
-
int ret = intel_dp_hdcp_init(dig_port, intel_connector);
6587
+
int ret = intel_dp_hdcp_init(dig_port, connector);
6586
6588
if (ret)
6587
6589
drm_dbg_kms(&dev_priv->drm,
6588
6590
"HDCP init failed, skipping.\n");
···
6596
6600
6597
6601
fail:
6598
6602
intel_display_power_flush_work(dev_priv);
6599
-
drm_connector_cleanup(connector);
6603
+
drm_connector_cleanup(&connector->base);
6600
6604
6601
6605
return false;
6602
6606
}