drivers/gpu/drm/xilinx/xilinx_drm_dp.c

   1 /*
   2  * Xilinx DRM DisplayPort encoder driver for Xilinx
   3  *
   4  *  Copyright (C) 2014 Xilinx, Inc.
   5  *
   6  *  Author: Hyun Woo Kwon <hyunk@xilinx.com>
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <drm/drmP.h>
  19 #include <drm/drm_crtc.h>
  20 #include <drm/drm_crtc_helper.h>
  21 #include <drm/drm_dp_helper.h>
  22 #include <drm/drm_encoder_slave.h>
  23
  24 #include <linux/clk.h>
  25 #include <linux/debugfs.h>
  26 #include <linux/delay.h>
  27 #include <linux/device.h>
  28 #include <linux/module.h>
  29 #include <linux/mutex.h>
  30 #include <linux/phy/phy.h>
  31 #include <linux/phy/phy-zynqmp.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/pm_runtime.h>
  34 #include <linux/uaccess.h>
  35
  36 #include "xilinx_drm_dp_sub.h"
  37 #include "xilinx_drm_drv.h"
  38
  39 static uint xilinx_drm_dp_aux_timeout_ms = 50;
  40 module_param_named(aux_timeout_ms, xilinx_drm_dp_aux_timeout_ms, uint, 0444);
  41 MODULE_PARM_DESC(aux_timeout_ms,
  42                  "DP aux timeout value in msec (default: 50)");
  43
  44 static uint xilinx_drm_dp_power_on_delay_ms = 4;
  45 module_param_named(power_on_delay_ms, xilinx_drm_dp_power_on_delay_ms, uint,
  46                    0644);
  47 MODULE_PARM_DESC(power_on_delay,
  48                  "Delay after power on request in msec (default: 4)");
  49
  50 /* Link configuration registers */
  51 #define XILINX_DP_TX_LINK_BW_SET                        0x0
  52 #define XILINX_DP_TX_LANE_CNT_SET                       0x4
  53 #define XILINX_DP_TX_ENHANCED_FRAME_EN                  0x8
  54 #define XILINX_DP_TX_TRAINING_PATTERN_SET               0xc
  55 #define XILINX_DP_TX_SCRAMBLING_DISABLE                 0x14
  56 #define XILINX_DP_TX_DOWNSPREAD_CTL                     0x18
  57 #define XILINX_DP_TX_SW_RESET                           0x1c
  58 #define XILINX_DP_TX_SW_RESET_STREAM1                   BIT(0)
  59 #define XILINX_DP_TX_SW_RESET_STREAM2                   BIT(1)
  60 #define XILINX_DP_TX_SW_RESET_STREAM3                   BIT(2)
  61 #define XILINX_DP_TX_SW_RESET_STREAM4                   BIT(3)
  62 #define XILINX_DP_TX_SW_RESET_AUX                       BIT(7)
  63 #define XILINX_DP_TX_SW_RESET_ALL                       (XILINX_DP_TX_SW_RESET_STREAM1 | \
  64                                                          XILINX_DP_TX_SW_RESET_STREAM2 | \
  65                                                          XILINX_DP_TX_SW_RESET_STREAM3 | \
  66                                                          XILINX_DP_TX_SW_RESET_STREAM4 | \
  67                                                          XILINX_DP_TX_SW_RESET_AUX)
  68
  69 /* Core enable registers */
  70 #define XILINX_DP_TX_ENABLE                             0x80
  71 #define XILINX_DP_TX_ENABLE_MAIN_STREAM                 0x84
  72 #define XILINX_DP_TX_FORCE_SCRAMBLER_RESET              0xc0
  73 #define XILINX_DP_TX_VERSION                            0xf8
  74 #define XILINX_DP_TX_VERSION_MAJOR_MASK                 (0xff << 24)
  75 #define XILINX_DP_TX_VERSION_MAJOR_SHIFT                24
  76 #define XILINX_DP_TX_VERSION_MINOR_MASK                 (0xff << 16)
  77 #define XILINX_DP_TX_VERSION_MINOR_SHIFT                16
  78 #define XILINX_DP_TX_VERSION_REVISION_MASK              (0xf << 12)
  79 #define XILINX_DP_TX_VERSION_REVISION_SHIFT             12
  80 #define XILINX_DP_TX_VERSION_PATCH_MASK                 (0xf << 8)
  81 #define XILINX_DP_TX_VERSION_PATCH_SHIFT                8
  82 #define XILINX_DP_TX_VERSION_INTERNAL_MASK              (0xff << 0)
  83 #define XILINX_DP_TX_VERSION_INTERNAL_SHIFT             0
  84
  85 /* Core ID registers */
  86 #define XILINX_DP_TX_CORE_ID                            0xfc
  87 #define XILINX_DP_TX_CORE_ID_MAJOR_MASK                 (0xff << 24)
  88 #define XILINX_DP_TX_CORE_ID_MAJOR_SHIFT                24
  89 #define XILINX_DP_TX_CORE_ID_MINOR_MASK                 (0xff << 16)
  90 #define XILINX_DP_TX_CORE_ID_MINOR_SHIFT                16
  91 #define XILINX_DP_TX_CORE_ID_REVISION_MASK              (0xff << 8)
  92 #define XILINX_DP_TX_CORE_ID_REVISION_SHIFT             8
  93 #define XILINX_DP_TX_CORE_ID_DIRECTION                  BIT(0)
  94
  95 /* AUX channel interface registers */
  96 #define XILINX_DP_TX_AUX_COMMAND                        0x100
  97 #define XILINX_DP_TX_AUX_COMMAND_CMD_SHIFT              8
  98 #define XILINX_DP_TX_AUX_COMMAND_ADDRESS_ONLY           BIT(12)
  99 #define XILINX_DP_TX_AUX_COMMAND_BYTES_SHIFT            0
 100 #define XILINX_DP_TX_AUX_WRITE_FIFO                     0x104
 101 #define XILINX_DP_TX_AUX_ADDRESS                        0x108
 102 #define XILINX_DP_TX_CLK_DIVIDER                        0x10c
 103 #define XILINX_DP_TX_CLK_DIVIDER_MHZ                    1000000
 104 #define XILINX_DP_TX_CLK_DIVIDER_AUX_FILTER_SHIFT       8
 105 #define XILINX_DP_TX_INTR_SIGNAL_STATE                  0x130
 106 #define XILINX_DP_TX_INTR_SIGNAL_STATE_HPD              BIT(0)
 107 #define XILINX_DP_TX_INTR_SIGNAL_STATE_REQUEST          BIT(1)
 108 #define XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY            BIT(2)
 109 #define XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY_TIMEOUT    BIT(3)
 110 #define XILINX_DP_TX_AUX_REPLY_DATA                     0x134
 111 #define XILINX_DP_TX_AUX_REPLY_CODE                     0x138
 112 #define XILINX_DP_TX_AUX_REPLY_CODE_AUX_ACK             (0)
 113 #define XILINX_DP_TX_AUX_REPLY_CODE_AUX_NACK            BIT(0)
 114 #define XILINX_DP_TX_AUX_REPLY_CODE_AUX_DEFER           BIT(1)
 115 #define XILINX_DP_TX_AUX_REPLY_CODE_I2C_ACK             (0)
 116 #define XILINX_DP_TX_AUX_REPLY_CODE_I2C_NACK            BIT(2)
 117 #define XILINX_DP_TX_AUX_REPLY_CODE_I2C_DEFER           BIT(3)
 118 #define XILINX_DP_TX_AUX_REPLY_CNT                      0x13c
 119 #define XILINX_DP_TX_AUX_REPLY_CNT_MASK                 0xff
 120 #define XILINX_DP_TX_INTR_STATUS                        0x140
 121 #define XILINX_DP_TX_INTR_MASK                          0x144
 122 #define XILINX_DP_TX_INTR_HPD_IRQ                       BIT(0)
 123 #define XILINX_DP_TX_INTR_HPD_EVENT                     BIT(1)
 124 #define XILINX_DP_TX_INTR_REPLY_RECV                    BIT(2)
 125 #define XILINX_DP_TX_INTR_REPLY_TIMEOUT                 BIT(3)
 126 #define XILINX_DP_TX_INTR_HPD_PULSE                     BIT(4)
 127 #define XILINX_DP_TX_INTR_EXT_PKT_TXD                   BIT(5)
 128 #define XILINX_DP_TX_INTR_LIV_ABUF_UNDRFLW              BIT(12)
 129 #define XILINX_DP_TX_INTR_VBLANK_START                  BIT(13)
 130 #define XILINX_DP_TX_INTR_PIXEL0_MATCH                  BIT(14)
 131 #define XILINX_DP_TX_INTR_PIXEL1_MATCH                  BIT(15)
 132 #define XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK           0x3f0000
 133 #define XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK            0xfc00000
 134 #define XILINX_DP_TX_INTR_CUST_TS_2                     BIT(28)
 135 #define XILINX_DP_TX_INTR_CUST_TS                       BIT(29)
 136 #define XILINX_DP_TX_INTR_EXT_VSYNC_TS                  BIT(30)
 137 #define XILINX_DP_TX_INTR_VSYNC_TS                      BIT(31)
 138 #define XILINX_DP_TX_INTR_ALL                           (XILINX_DP_TX_INTR_HPD_IRQ | \
 139                                                          XILINX_DP_TX_INTR_HPD_EVENT | \
 140                                                          XILINX_DP_TX_INTR_REPLY_RECV | \
 141                                                          XILINX_DP_TX_INTR_REPLY_TIMEOUT | \
 142                                                          XILINX_DP_TX_INTR_HPD_PULSE | \
 143                                                          XILINX_DP_TX_INTR_EXT_PKT_TXD | \
 144                                                          XILINX_DP_TX_INTR_LIV_ABUF_UNDRFLW | \
 145                                                          XILINX_DP_TX_INTR_VBLANK_START | \
 146                                                          XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK | \
 147                                                          XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK)
 148 #define XILINX_DP_TX_REPLY_DATA_CNT                     0x148
 149 #define XILINX_DP_SUB_TX_INTR_STATUS                    0x3a0
 150 #define XILINX_DP_SUB_TX_INTR_MASK                      0x3a4
 151 #define XILINX_DP_SUB_TX_INTR_EN                        0x3a8
 152 #define XILINX_DP_SUB_TX_INTR_DS                        0x3ac
 153
 154 /* Main stream attribute registers */
 155 #define XILINX_DP_TX_MAIN_STREAM_HTOTAL                 0x180
 156 #define XILINX_DP_TX_MAIN_STREAM_VTOTAL                 0x184
 157 #define XILINX_DP_TX_MAIN_STREAM_POLARITY               0x188
 158 #define XILINX_DP_TX_MAIN_STREAM_POLARITY_HSYNC_SHIFT   0
 159 #define XILINX_DP_TX_MAIN_STREAM_POLARITY_VSYNC_SHIFT   1
 160 #define XILINX_DP_TX_MAIN_STREAM_HSWIDTH                0x18c
 161 #define XILINX_DP_TX_MAIN_STREAM_VSWIDTH                0x190
 162 #define XILINX_DP_TX_MAIN_STREAM_HRES                   0x194
 163 #define XILINX_DP_TX_MAIN_STREAM_VRES                   0x198
 164 #define XILINX_DP_TX_MAIN_STREAM_HSTART                 0x19c
 165 #define XILINX_DP_TX_MAIN_STREAM_VSTART                 0x1a0
 166 #define XILINX_DP_TX_MAIN_STREAM_MISC0                  0x1a4
 167 #define XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC             BIT(0)
 168 #define XILINX_DP_TX_MAIN_STREAM_MISC0_FORMAT_SHIFT     1
 169 #define XILINX_DP_TX_MAIN_STREAM_MISC0_DYNAMIC_RANGE    BIT(3)
 170 #define XILINX_DP_TX_MAIN_STREAM_MISC0_YCBCR_COLRIMETRY BIT(4)
 171 #define XILINX_DP_TX_MAIN_STREAM_MISC0_BPC_SHIFT        5
 172 #define XILINX_DP_TX_MAIN_STREAM_MISC1                  0x1a8
 173 #define XILINX_DP_TX_MAIN_STREAM_MISC0_INTERLACED_VERT  BIT(0)
 174 #define XILINX_DP_TX_MAIN_STREAM_MISC0_STEREO_VID_SHIFT 1
 175 #define XILINX_DP_TX_M_VID                              0x1ac
 176 #define XILINX_DP_TX_TRANSFER_UNIT_SIZE                 0x1b0
 177 #define XILINX_DP_TX_DEF_TRANSFER_UNIT_SIZE             64
 178 #define XILINX_DP_TX_N_VID                              0x1b4
 179 #define XILINX_DP_TX_USER_PIXEL_WIDTH                   0x1b8
 180 #define XILINX_DP_TX_USER_DATA_CNT_PER_LANE             0x1bc
 181 #define XILINX_DP_TX_MIN_BYTES_PER_TU                   0x1c4
 182 #define XILINX_DP_TX_FRAC_BYTES_PER_TU                  0x1c8
 183 #define XILINX_DP_TX_INIT_WAIT                          0x1cc
 184
 185 /* PHY configuration and status registers */
 186 #define XILINX_DP_TX_PHY_CONFIG                         0x200
 187 #define XILINX_DP_TX_PHY_CONFIG_PHY_RESET               BIT(0)
 188 #define XILINX_DP_TX_PHY_CONFIG_GTTX_RESET              BIT(1)
 189 #define XILINX_DP_TX_PHY_CONFIG_PHY_PMA_RESET           BIT(8)
 190 #define XILINX_DP_TX_PHY_CONFIG_PHY_PCS_RESET           BIT(9)
 191 #define XILINX_DP_TX_PHY_CONFIG_ALL_RESET               (XILINX_DP_TX_PHY_CONFIG_PHY_RESET | \
 192                                                          XILINX_DP_TX_PHY_CONFIG_GTTX_RESET | \
 193                                                          XILINX_DP_TX_PHY_CONFIG_PHY_PMA_RESET | \
 194                                                          XILINX_DP_TX_PHY_CONFIG_PHY_PCS_RESET)
 195 #define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_0             0x210
 196 #define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_1             0x214
 197 #define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_2             0x218
 198 #define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_3             0x21c
 199 #define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_0            0x220
 200 #define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_1            0x224
 201 #define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_2            0x228
 202 #define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_3            0x22c
 203 #define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING         0x234
 204 #define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_162     0x1
 205 #define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_270     0x3
 206 #define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_540     0x5
 207 #define XILINX_DP_TX_PHY_POWER_DOWN                     0x238
 208 #define XILINX_DP_TX_PHY_POWER_DOWN_LANE_0              BIT(0)
 209 #define XILINX_DP_TX_PHY_POWER_DOWN_LANE_1              BIT(1)
 210 #define XILINX_DP_TX_PHY_POWER_DOWN_LANE_2              BIT(2)
 211 #define XILINX_DP_TX_PHY_POWER_DOWN_LANE_3              BIT(3)
 212 #define XILINX_DP_TX_PHY_POWER_DOWN_ALL                 0xf
 213 #define XILINX_DP_TX_PHY_PRECURSOR_LANE_0               0x23c
 214 #define XILINX_DP_TX_PHY_PRECURSOR_LANE_1               0x240
 215 #define XILINX_DP_TX_PHY_PRECURSOR_LANE_2               0x244
 216 #define XILINX_DP_TX_PHY_PRECURSOR_LANE_3               0x248
 217 #define XILINX_DP_TX_PHY_POSTCURSOR_LANE_0              0x24c
 218 #define XILINX_DP_TX_PHY_POSTCURSOR_LANE_1              0x250
 219 #define XILINX_DP_TX_PHY_POSTCURSOR_LANE_2              0x254
 220 #define XILINX_DP_TX_PHY_POSTCURSOR_LANE_3              0x258
 221 #define XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_0           0x24c
 222 #define XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_1           0x250
 223 #define XILINX_DP_TX_PHY_STATUS                         0x280
 224 #define XILINX_DP_TX_PHY_STATUS_PLL_LOCKED_SHIFT        4
 225 #define XILINX_DP_TX_PHY_STATUS_FPGA_PLL_LOCKED         BIT(6)
 226
 227 /* Audio registers */
 228 #define XILINX_DP_TX_AUDIO_CONTROL                      0x300
 229 #define XILINX_DP_TX_AUDIO_CHANNELS                     0x304
 230 #define XILINX_DP_TX_AUDIO_INFO_DATA                    0x308
 231 #define XILINX_DP_TX_AUDIO_M_AUD                        0x328
 232 #define XILINX_DP_TX_AUDIO_N_AUD                        0x32c
 233 #define XILINX_DP_TX_AUDIO_EXT_DATA                     0x330
 234
 235 #define XILINX_DP_MISC0_RGB                             (0)
 236 #define XILINX_DP_MISC0_YCRCB_422                       (5 << 1)
 237 #define XILINX_DP_MISC0_YCRCB_444                       (6 << 1)
 238 #define XILINX_DP_MISC0_FORMAT_MASK                     0xe
 239 #define XILINX_DP_MISC0_BPC_6                           (0 << 5)
 240 #define XILINX_DP_MISC0_BPC_8                           (1 << 5)
 241 #define XILINX_DP_MISC0_BPC_10                          (2 << 5)
 242 #define XILINX_DP_MISC0_BPC_12                          (3 << 5)
 243 #define XILINX_DP_MISC0_BPC_16                          (4 << 5)
 244 #define XILINX_DP_MISC0_BPC_MASK                        0xe0
 245 #define XILINX_DP_MISC1_Y_ONLY                          (1 << 7)
 246
 247 #define DP_REDUCED_BIT_RATE                             162000
 248 #define DP_HIGH_BIT_RATE                                270000
 249 #define DP_HIGH_BIT_RATE2                               540000
 250 #define DP_MAX_TRAINING_TRIES                           5
 251 #define DP_MAX_LANES                                    4
 252
 253 enum dp_version {
 254         DP_V1_1A = 0x11,
 255         DP_V1_2 = 0x12
 256 };
 257
 258 /**
 259  * struct xilinx_drm_dp_link_config - Common link config between source and sink
 260  * @max_rate: maximum link rate
 261  * @max_lanes: maximum number of lanes
 262  */
 263 struct xilinx_drm_dp_link_config {
 264         int max_rate;
 265         u8 max_lanes;
 266 };
 267
 268 /**
 269  * struct xilinx_drm_dp_mode - Configured mode of DisplayPort
 270  * @bw_code: code for bandwidth(link rate)
 271  * @lane_cnt: number of lanes
 272  * @pclock: pixel clock frequency of current mode
 273  */
 274 struct xilinx_drm_dp_mode {
 275         u8 bw_code;
 276         u8 lane_cnt;
 277         int pclock;
 278 };
 279
 280 /**
 281  * struct xilinx_drm_dp_config - Configuration of DisplayPort from DTS
 282  * @dp_version: DisplayPort protocol version
 283  * @max_lanes: max number of lanes
 284  * @max_link_rate: max link rate
 285  * @max_bpc: maximum bits-per-color
 286  * @max_pclock: maximum pixel clock rate
 287  * @enable_yonly: enable yonly color space logic
 288  * @enable_ycrcb: enable ycrcb color space logic
 289  * @misc0: misc0 configuration (per DP v1.2 spec)
 290  * @misc1: misc1 configuration (per DP v1.2 spec)
 291  * @bpp: bits per pixel
 292  */
 293 struct xilinx_drm_dp_config {
 294         enum dp_version dp_version;
 295         u32 max_lanes;
 296         u32 max_link_rate;
 297         u32 max_bpc;
 298         u32 max_pclock;
 299         bool enable_yonly;
 300         bool enable_ycrcb;
 301
 302         u8 misc0;
 303         u8 misc1;
 304         u8 bpp;
 305 };
 306
 307 /**
 308  * struct xilinx_drm_dp - Xilinx DisplayPort core
 309  * @encoder: pointer to the drm encoder structure
 310  * @dev: device structure
 311  * @iomem: device I/O memory for register access
 312  * @config: IP core configuration from DTS
 313  * @aux: aux channel
 314  * @dp_sub: DisplayPort subsystem
 315  * @phy: PHY handles for DP lanes
 316  * @aclk: clock source device for internal axi4-lite clock
 317  * @aud_clk: clock source device for audio clock
 318  * @aud_clk_enabled: if audio clock is enabled
 319  * @dpms: current dpms state
 320  * @status: the connection status
 321  * @dpcd: DP configuration data from currently connected sink device
 322  * @link_config: common link configuration between IP core and sink device
 323  * @mode: current mode between IP core and sink device
 324  * @train_set: set of training data
 325  */
 326 struct xilinx_drm_dp {
 327         struct drm_encoder *encoder;
 328         struct device *dev;
 329         void __iomem *iomem;
 330
 331         struct xilinx_drm_dp_config config;
 332         struct drm_dp_aux aux;
 333         struct xilinx_drm_dp_sub *dp_sub;
 334         struct phy *phy[DP_MAX_LANES];
 335         struct clk *aclk;
 336         struct clk *aud_clk;
 337         bool aud_clk_enabled;
 338
 339         int dpms;
 340         enum drm_connector_status status;
 341         u8 dpcd[DP_RECEIVER_CAP_SIZE];
 342         struct xilinx_drm_dp_link_config link_config;
 343         struct xilinx_drm_dp_mode mode;
 344         u8 train_set[DP_MAX_LANES];
 345 };
 346
 347 static inline struct xilinx_drm_dp *to_dp(struct drm_encoder *encoder)
 348 {
 349         return to_encoder_slave(encoder)->slave_priv;
 350 }
 351
 352 #define AUX_READ_BIT    0x1
 353
 354 #ifdef CONFIG_DRM_XILINX_DP_DEBUG_FS
 355 #define XILINX_DP_DEBUGFS_READ_MAX_SIZE 32
 356 #define XILINX_DP_DEBUGFS_UINT8_MAX_STR "255"
 357 #define IN_RANGE(x, min, max) ({        \
 358                 typeof(x) _x = (x);     \
 359                 _x >= (min) && _x <= (max); })
 360
 361 /* Match xilinx_dp_testcases vs dp_debugfs_reqs[] entry */
 362 enum xilinx_dp_testcases {
 363         DP_TC_LINK_RATE,
 364         DP_TC_LANE_COUNT,
 365         DP_TC_OUTPUT_FMT,
 366         DP_TC_NONE
 367 };
 368
 369 struct xilinx_dp_debugfs {
 370         enum xilinx_dp_testcases testcase;
 371         u8 link_rate;
 372         u8 lane_cnt;
 373         u8 old_output_fmt;
 374         struct xilinx_drm_dp *dp;
 375 };
 376
 377 struct xilinx_dp_debugfs dp_debugfs;
 378 struct xilinx_dp_debugfs_request {
 379         const char *req;
 380         enum xilinx_dp_testcases tc;
 381         ssize_t (*read_handler)(char **kern_buff);
 382         ssize_t (*write_handler)(char **cmd);
 383 };
 384
 385 static s64 xilinx_dp_debugfs_argument_value(char *arg)
 386 {
 387         s64 value;
 388
 389         if (!arg)
 390                 return -1;
 391
 392         if (!kstrtos64(arg, 0, &value))
 393                 return value;
 394
 395         return -1;
 396 }
 397
 398 static int xilinx_dp_update_output_format(u8 output_fmt, u32 num_colors)
 399 {
 400         struct xilinx_drm_dp *dp = dp_debugfs.dp;
 401         struct xilinx_drm_dp_config *config = &dp->config;
 402         u32 bpc;
 403         u8 bpc_bits = (config->misc0 & XILINX_DP_MISC0_BPC_MASK);
 404         bool misc1 = output_fmt & XILINX_DP_MISC1_Y_ONLY ? true : false;
 405
 406         switch (bpc_bits) {
 407         case XILINX_DP_MISC0_BPC_6:
 408                 bpc = 6;
 409                 break;
 410         case XILINX_DP_MISC0_BPC_8:
 411                 bpc = 8;
 412                 break;
 413         case XILINX_DP_MISC0_BPC_10:
 414                 bpc = 10;
 415                 break;
 416         case XILINX_DP_MISC0_BPC_12:
 417                 bpc = 12;
 418                 break;
 419         case XILINX_DP_MISC0_BPC_16:
 420                 bpc = 16;
 421                 break;
 422         default:
 423                 dev_err(dp->dev, "Invalid bpc count for misc0\n");
 424                 return -EINVAL;
 425         }
 426
 427         /* clear old format */
 428         config->misc0 &= ~XILINX_DP_MISC0_FORMAT_MASK;
 429         config->misc1 &= ~XILINX_DP_MISC1_Y_ONLY;
 430
 431         if (misc1) {
 432                 config->misc1 |= output_fmt;
 433                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC1,
 434                                   config->misc1);
 435         } else {
 436                 config->misc0 |= output_fmt;
 437                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC0,
 438                                   config->misc0);
 439         }
 440         config->bpp = num_colors * bpc;
 441
 442         return 0;
 443 }
 444
 445 static ssize_t xilinx_dp_debugfs_max_linkrate_write(char **dp_test_arg)
 446 {
 447         char *link_rate_arg;
 448         s64 link_rate;
 449
 450         link_rate_arg = strsep(dp_test_arg, " ");
 451         link_rate = xilinx_dp_debugfs_argument_value(link_rate_arg);
 452         if (link_rate < 0 || (link_rate != DP_HIGH_BIT_RATE2 &&
 453                               link_rate != DP_HIGH_BIT_RATE &&
 454                               link_rate != DP_REDUCED_BIT_RATE))
 455                 return -EINVAL;
 456
 457         dp_debugfs.link_rate = drm_dp_link_rate_to_bw_code(link_rate);
 458         dp_debugfs.testcase = DP_TC_LINK_RATE;
 459
 460         return 0;
 461 }
 462
 463 static ssize_t xilinx_dp_debugfs_max_lanecnt_write(char **dp_test_arg)
 464 {
 465         char *lane_cnt_arg;
 466         s64 lane_count;
 467
 468         lane_cnt_arg = strsep(dp_test_arg, " ");
 469         lane_count = xilinx_dp_debugfs_argument_value(lane_cnt_arg);
 470         if (lane_count < 0 || !IN_RANGE(lane_count, 1,
 471                                         dp_debugfs.dp->config.max_lanes))
 472                 return -EINVAL;
 473
 474         dp_debugfs.lane_cnt = lane_count;
 475         dp_debugfs.testcase = DP_TC_LANE_COUNT;
 476
 477         return 0;
 478 }
 479
 480 static ssize_t xilinx_dp_debugfs_output_display_format_write(char **dp_test_arg)
 481 {
 482         int ret;
 483         struct xilinx_drm_dp *dp = dp_debugfs.dp;
 484         char *output_format;
 485         u8 output_fmt;
 486         u32 num_colors;
 487
 488         /* Read the value from an user value */
 489         output_format = strsep(dp_test_arg, " ");
 490
 491         if (strncmp(output_format, "rgb", 3) == 0) {
 492                 output_fmt = XILINX_DP_MISC0_RGB;
 493                 num_colors = 3;
 494         } else if (strncmp(output_format, "ycbcr422", 8) == 0) {
 495                 output_fmt = XILINX_DP_MISC0_YCRCB_422;
 496                 num_colors = 2;
 497         } else if (strncmp(output_format, "ycbcr444", 8) == 0) {
 498                 output_fmt = XILINX_DP_MISC0_YCRCB_444;
 499                 num_colors = 3;
 500         } else if (strncmp(output_format, "yonly", 5) == 0) {
 501                 output_fmt = XILINX_DP_MISC1_Y_ONLY;
 502                 num_colors = 1;
 503         } else {
 504                 dev_err(dp->dev, "Invalid output format\n");
 505                 return -EINVAL;
 506         }
 507
 508         if (dp->config.misc1 & XILINX_DP_MISC1_Y_ONLY)
 509                 dp_debugfs.old_output_fmt = XILINX_DP_MISC1_Y_ONLY;
 510         else
 511                 dp_debugfs.old_output_fmt = dp->config.misc0 &
 512                                             XILINX_DP_MISC0_FORMAT_MASK;
 513
 514         ret = xilinx_dp_update_output_format(output_fmt, num_colors);
 515         if (!ret)
 516                 dp_debugfs.testcase = DP_TC_OUTPUT_FMT;
 517         return ret;
 518 }
 519
 520 static ssize_t xilinx_dp_debugfs_max_linkrate_read(char **kern_buff)
 521 {
 522         struct xilinx_drm_dp *dp = dp_debugfs.dp;
 523         size_t output_str_len;
 524         u8 dpcd_link_bw;
 525         int ret;
 526
 527         dp_debugfs.testcase = DP_TC_NONE;
 528         dp_debugfs.link_rate = 0;
 529
 530         /* Getting Sink Side Link Rate */
 531         ret = drm_dp_dpcd_readb(&dp->aux, DP_LINK_BW_SET, &dpcd_link_bw);
 532         if (ret < 0) {
 533                 dev_err(dp->dev, "Failed to read link rate via AUX.\n");
 534                 kfree(*kern_buff);
 535                 return ret;
 536         }
 537
 538         output_str_len = strlen(XILINX_DP_DEBUGFS_UINT8_MAX_STR);
 539         output_str_len = min_t(size_t, XILINX_DP_DEBUGFS_READ_MAX_SIZE,
 540                                output_str_len);
 541         snprintf(*kern_buff, output_str_len, "%u", dpcd_link_bw);
 542
 543         return 0;
 544 }
 545
 546 static ssize_t xilinx_dp_debugfs_max_lanecnt_read(char **kern_buff)
 547 {
 548         struct xilinx_drm_dp *dp = dp_debugfs.dp;
 549         size_t output_str_len;
 550         u8 dpcd_lane_cnt;
 551         int ret;
 552
 553         dp_debugfs.testcase = DP_TC_NONE;
 554         dp_debugfs.lane_cnt = 0;
 555
 556         /* Getting Sink Side Lane Count */
 557         ret = drm_dp_dpcd_readb(&dp->aux, DP_LANE_COUNT_SET, &dpcd_lane_cnt);
 558         if (ret < 0) {
 559                 dev_err(dp->dev, "Failed to read link rate via AUX.\n");
 560                 kfree(*kern_buff);
 561                 return ret;
 562         }
 563
 564         dpcd_lane_cnt &= DP_LANE_COUNT_MASK;
 565         output_str_len = strlen(XILINX_DP_DEBUGFS_UINT8_MAX_STR);
 566         output_str_len = min_t(size_t, XILINX_DP_DEBUGFS_READ_MAX_SIZE,
 567                                output_str_len);
 568         snprintf(*kern_buff, output_str_len, "%u", dpcd_lane_cnt);
 569
 570         return 0;
 571 }
 572
 573 static ssize_t
 574 xilinx_dp_debugfs_output_display_format_read(char **kern_buff)
 575 {
 576         int ret;
 577         struct xilinx_drm_dp *dp = dp_debugfs.dp;
 578         u8 old_output_fmt = dp_debugfs.old_output_fmt;
 579         size_t output_str_len;
 580         u32 num_colors;
 581
 582         dp_debugfs.testcase = DP_TC_NONE;
 583
 584         if (old_output_fmt == XILINX_DP_MISC0_RGB) {
 585                 num_colors = 3;
 586         } else if (old_output_fmt == XILINX_DP_MISC0_YCRCB_422) {
 587                 num_colors = 2;
 588         } else if (old_output_fmt == XILINX_DP_MISC0_YCRCB_444) {
 589                 num_colors = 3;
 590         } else if (old_output_fmt == XILINX_DP_MISC1_Y_ONLY) {
 591                 num_colors = 1;
 592         } else {
 593                 dev_err(dp->dev, "Invalid output format in misc0\n");
 594                 return -EINVAL;
 595         }
 596
 597         ret = xilinx_dp_update_output_format(old_output_fmt, num_colors);
 598         if (ret)
 599                 return ret;
 600
 601         output_str_len = strlen("Success");
 602         output_str_len = min_t(size_t, XILINX_DP_DEBUGFS_READ_MAX_SIZE,
 603                                output_str_len);
 604         snprintf(*kern_buff, output_str_len, "%s", "Success");
 605
 606         return 0;
 607 }
 608
 609 /* Match xilinx_dp_testcases vs dp_debugfs_reqs[] entry */
 610 struct xilinx_dp_debugfs_request dp_debugfs_reqs[] = {
 611         {"LINK_RATE", DP_TC_LINK_RATE,
 612                         xilinx_dp_debugfs_max_linkrate_read,
 613                         xilinx_dp_debugfs_max_linkrate_write},
 614         {"LANE_COUNT", DP_TC_LANE_COUNT,
 615                         xilinx_dp_debugfs_max_lanecnt_read,
 616                         xilinx_dp_debugfs_max_lanecnt_write},
 617         {"OUTPUT_DISPLAY_FORMAT", DP_TC_OUTPUT_FMT,
 618                         xilinx_dp_debugfs_output_display_format_read,
 619                         xilinx_dp_debugfs_output_display_format_write},
 620 };
 621
 622 static ssize_t xilinx_dp_debugfs_read(struct file *f, char __user *buf,
 623                                       size_t size, loff_t *pos)
 624 {
 625         char *kern_buff = NULL;
 626         size_t kern_buff_len, out_str_len;
 627         int ret;
 628
 629         if (size <= 0)
 630                 return -EINVAL;
 631
 632         if (*pos != 0)
 633                 return 0;
 634
 635         kern_buff = kzalloc(XILINX_DP_DEBUGFS_READ_MAX_SIZE, GFP_KERNEL);
 636         if (!kern_buff) {
 637                 dp_debugfs.testcase = DP_TC_NONE;
 638                 return -ENOMEM;
 639         }
 640
 641         if (dp_debugfs.testcase == DP_TC_NONE) {
 642                 out_str_len = strlen("No testcase executed");
 643                 out_str_len = min_t(size_t, XILINX_DP_DEBUGFS_READ_MAX_SIZE,
 644                                     out_str_len);
 645                 snprintf(kern_buff, out_str_len, "%s", "No testcase executed");
 646         } else {
 647                 ret = dp_debugfs_reqs[dp_debugfs.testcase].read_handler(
 648                                 &kern_buff);
 649                 if (ret) {
 650                         kfree(kern_buff);
 651                         return ret;
 652                 }
 653         }
 654
 655         kern_buff_len = strlen(kern_buff);
 656         size = min(size, kern_buff_len);
 657
 658         ret = copy_to_user(buf, kern_buff, size);
 659
 660         kfree(kern_buff);
 661         if (ret)
 662                 return ret;
 663
 664         *pos = size + 1;
 665         return size;
 666 }
 667
 668 static ssize_t
 669 xilinx_dp_debugfs_write(struct file *f, const char __user *buf,
 670                         size_t size, loff_t *pos)
 671 {
 672         char *kern_buff, *kern_buff_start;
 673         char *dp_test_req;
 674         int ret;
 675         int i;
 676
 677         if (*pos != 0 || size <= 0)
 678                 return -EINVAL;
 679
 680         if (dp_debugfs.testcase != DP_TC_NONE)
 681                 return -EBUSY;
 682
 683         kern_buff = kzalloc(size, GFP_KERNEL);
 684         if (!kern_buff)
 685                 return -ENOMEM;
 686         kern_buff_start = kern_buff;
 687
 688         ret = strncpy_from_user(kern_buff, buf, size);
 689         if (ret < 0) {
 690                 kfree(kern_buff_start);
 691                 return ret;
 692         }
 693
 694         /* Read the testcase name and argument from an user request */
 695         dp_test_req = strsep(&kern_buff, " ");
 696
 697         for (i = 0; i < ARRAY_SIZE(dp_debugfs_reqs); i++) {
 698                 if (!strcasecmp(dp_test_req, dp_debugfs_reqs[i].req))
 699                         if (!dp_debugfs_reqs[i].write_handler(&kern_buff)) {
 700                                 kfree(kern_buff_start);
 701                                 return size;
 702                         }
 703         }
 704
 705         kfree(kern_buff_start);
 706         return -EINVAL;
 707 }
 708
 709 static const struct file_operations fops_xilinx_dp_dbgfs = {
 710         .owner = THIS_MODULE,
 711         .read = xilinx_dp_debugfs_read,
 712         .write = xilinx_dp_debugfs_write,
 713 };
 714
 715 static int xilinx_dp_debugfs_init(struct xilinx_drm_dp *dp)
 716 {
 717         int err;
 718         struct dentry *xilinx_dp_debugfs_dir, *xilinx_dp_debugfs_file;
 719
 720         dp_debugfs.testcase = DP_TC_NONE;
 721         dp_debugfs.dp = dp;
 722
 723         xilinx_dp_debugfs_dir = debugfs_create_dir("dp", NULL);
 724         if (!xilinx_dp_debugfs_dir) {
 725                 dev_err(dp->dev, "debugfs_create_dir failed\n");
 726                 return -ENODEV;
 727         }
 728
 729         xilinx_dp_debugfs_file =
 730                 debugfs_create_file("testcase", 0444, xilinx_dp_debugfs_dir,
 731                                     NULL, &fops_xilinx_dp_dbgfs);
 732         if (!xilinx_dp_debugfs_file) {
 733                 dev_err(dp->dev, "debugfs_create_file testcase failed\n");
 734                 err = -ENODEV;
 735                 goto err_dbgfs;
 736         }
 737         return 0;
 738
 739 err_dbgfs:
 740         debugfs_remove_recursive(xilinx_dp_debugfs_dir);
 741         xilinx_dp_debugfs_dir = NULL;
 742         return err;
 743 }
 744
 745 static void xilinx_dp_debugfs_mode_config(struct xilinx_drm_dp *dp)
 746 {
 747         dp->mode.bw_code =
 748                 dp_debugfs.link_rate ? dp_debugfs.link_rate : dp->mode.bw_code;
 749         dp->mode.lane_cnt =
 750                 dp_debugfs.lane_cnt ? dp_debugfs.lane_cnt : dp->mode.lane_cnt;
 751 }
 752 #else
 753 static int xilinx_dp_debugfs_init(struct xilinx_drm_dp *dp)
 754 {
 755         return 0;
 756 }
 757
 758 static void xilinx_dp_debugfs_mode_config(struct xilinx_drm_dp *dp)
 759 {
 760 }
 761 #endif /* DRM_XILINX_DP_DEBUG_FS */
 762
 763 /**
 764  * xilinx_drm_dp_aux_cmd_submit - Submit aux command
 765  * @dp: DisplayPort IP core structure
 766  * @cmd: aux command
 767  * @addr: aux address
 768  * @buf: buffer for command data
 769  * @bytes: number of bytes for @buf
 770  * @reply: reply code to be returned
 771  *
 772  * Submit an aux command. All aux related commands, native or i2c aux
 773  * read/write, are submitted through this function. The function is mapped to
 774  * the transfer function of struct drm_dp_aux. This function involves in
 775  * multiple register reads/writes, thus synchronization is needed, and it is
 776  * done by drm_dp_helper using @hw_mutex. The calling thread goes into sleep
 777  * if there's no immediate reply to the command submission. The reply code is
 778  * returned at @reply if @reply != NULL.
 779  *
 780  * Return: 0 if the command is submitted properly, or corresponding error code:
 781  * -EBUSY when there is any request already being processed
 782  * -ETIMEDOUT when receiving reply is timed out
 783  * -EIO when received bytes are less than requested
 784  */
 785 static int xilinx_drm_dp_aux_cmd_submit(struct xilinx_drm_dp *dp, u32 cmd,
 786                                         u16 addr, u8 *buf, u8 bytes, u8 *reply)
 787 {
 788         bool is_read = (cmd & AUX_READ_BIT) ? true : false;
 789         void __iomem *iomem = dp->iomem;
 790         u32 reg, i;
 791
 792         reg = xilinx_drm_readl(iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
 793         if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REQUEST)
 794                 return -EBUSY;
 795
 796         xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_ADDRESS, addr);
 797
 798         if (!is_read)
 799                 for (i = 0; i < bytes; i++)
 800                         xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_WRITE_FIFO,
 801                                           buf[i]);
 802
 803         reg = cmd << XILINX_DP_TX_AUX_COMMAND_CMD_SHIFT;
 804         if (!buf || !bytes)
 805                 reg |= XILINX_DP_TX_AUX_COMMAND_ADDRESS_ONLY;
 806         else
 807                 reg |= (bytes - 1) << XILINX_DP_TX_AUX_COMMAND_BYTES_SHIFT;
 808         xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_COMMAND, reg);
 809
 810         /* Wait for reply to be delivered upto 2ms */
 811         for (i = 0; ; i++) {
 812                 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
 813
 814                 if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY)
 815                         break;
 816
 817                 if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY_TIMEOUT ||
 818                     i == 2)
 819                         return -ETIMEDOUT;
 820
 821                 usleep_range(1000, 1100);
 822         }
 823
 824         reg = xilinx_drm_readl(iomem, XILINX_DP_TX_AUX_REPLY_CODE);
 825         if (reply)
 826                 *reply = reg;
 827
 828         if (is_read &&
 829             (reg == XILINX_DP_TX_AUX_REPLY_CODE_AUX_ACK ||
 830              reg == XILINX_DP_TX_AUX_REPLY_CODE_I2C_ACK)) {
 831                 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_REPLY_DATA_CNT);
 832                 if ((reg & XILINX_DP_TX_AUX_REPLY_CNT_MASK) != bytes)
 833                         return -EIO;
 834
 835                 for (i = 0; i < bytes; i++)
 836                         buf[i] = xilinx_drm_readl(iomem,
 837                                                   XILINX_DP_TX_AUX_REPLY_DATA);
 838         }
 839
 840         return 0;
 841 }
 842
 843 /**
 844  * xilinx_drm_dp_phy_ready - Check if PHY is ready
 845  * @dp: DisplayPort IP core structure
 846  *
 847  * Check if PHY is ready. If PHY is not ready, wait 1ms to check for 100 times.
 848  * This amount of delay was suggested by IP designer.
 849  *
 850  * Return: 0 if PHY is ready, or -ENODEV if PHY is not ready.
 851  */
 852 static int xilinx_drm_dp_phy_ready(struct xilinx_drm_dp *dp)
 853 {
 854         u32 i, reg, ready, lane;
 855
 856         lane = dp->config.max_lanes;
 857         ready = (1 << lane) - 1;
 858         if (!dp->dp_sub)
 859                 ready |= XILINX_DP_TX_PHY_STATUS_FPGA_PLL_LOCKED;
 860
 861         /* Wait for 100 * 1ms. This should be enough time for PHY to be ready */
 862         for (i = 0; ; i++) {
 863                 reg = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_PHY_STATUS);
 864                 if ((reg & ready) == ready)
 865                         return 0;
 866
 867                 if (i == 100) {
 868                         DRM_ERROR("PHY isn't ready\n");
 869                         return -ENODEV;
 870                 }
 871
 872                 usleep_range(1000, 1100);
 873         }
 874
 875         return 0;
 876 }
 877
 878 /**
 879  * xilinx_drm_dp_max_rate - Calculate and return available max pixel clock
 880  * @link_rate: link rate (Kilo-bytes / sec)
 881  * @lane_num: number of lanes
 882  * @bpp: bits per pixel
 883  *
 884  * Return: max pixel clock (KHz) supported by current link config.
 885  */
 886 static inline int xilinx_drm_dp_max_rate(int link_rate, u8 lane_num, u8 bpp)
 887 {
 888         return link_rate * lane_num * 8 / bpp;
 889 }
 890
 891 /**
 892  * xilinx_drm_dp_mode_configure - Configure the link values
 893  * @dp: DisplayPort IP core structure
 894  * @pclock: pixel clock for requested display mode
 895  * @current_bw: current link rate
 896  *
 897  * Find the link configuration values, rate and lane count for requested pixel
 898  * clock @pclock. The @pclock is stored in the mode to be used in other
 899  * functions later. The returned rate is downshifted from the current rate
 900  * @current_bw.
 901  *
 902  * Return: Current link rate code, or -EINVAL.
 903  */
 904 static int xilinx_drm_dp_mode_configure(struct xilinx_drm_dp *dp, int pclock,
 905                                         u8 current_bw)
 906 {
 907         int max_rate = dp->link_config.max_rate;
 908         u8 bws[3] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7, DP_LINK_BW_5_4 };
 909         u8 max_lanes = dp->link_config.max_lanes;
 910         u8 max_link_rate_code = drm_dp_link_rate_to_bw_code(max_rate);
 911         u8 bpp = dp->config.bpp;
 912         u8 lane_cnt;
 913         s8 i;
 914
 915         for (i = ARRAY_SIZE(bws) - 1; i >= 0; i--) {
 916                 if (current_bw && bws[i] >= current_bw)
 917                         continue;
 918
 919                 if (bws[i] <= max_link_rate_code)
 920                         break;
 921         }
 922
 923         for (lane_cnt = 1; lane_cnt <= max_lanes; lane_cnt <<= 1) {
 924                 int bw;
 925                 u32 rate;
 926
 927                 bw = drm_dp_bw_code_to_link_rate(bws[i]);
 928                 rate = xilinx_drm_dp_max_rate(bw, lane_cnt, bpp);
 929                 if (pclock <= rate) {
 930                         dp->mode.bw_code = bws[i];
 931                         dp->mode.lane_cnt = lane_cnt;
 932                         dp->mode.pclock = pclock;
 933                         xilinx_dp_debugfs_mode_config(dp);
 934                         return dp->mode.bw_code;
 935                 }
 936         }
 937
 938         dev_dbg(dp->dev, "failed to configure link values\n");
 939
 940         return -EINVAL;
 941 }
 942
 943 /**
 944  * xilinx_drm_dp_adjust_train - Adjust train values
 945  * @dp: DisplayPort IP core structure
 946  * @link_status: link status from sink which contains requested training values
 947  */
 948 static void xilinx_drm_dp_adjust_train(struct xilinx_drm_dp *dp,
 949                                        u8 link_status[DP_LINK_STATUS_SIZE])
 950 {
 951         u8 *train_set = dp->train_set;
 952         u8 voltage = 0, preemphasis = 0;
 953         u8 max_preemphasis;
 954         u8 i;
 955
 956         for (i = 0; i < dp->mode.lane_cnt; i++) {
 957                 u8 v = drm_dp_get_adjust_request_voltage(link_status, i);
 958                 u8 p = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
 959
 960                 if (v > voltage)
 961                         voltage = v;
 962
 963                 if (p > preemphasis)
 964                         preemphasis = p;
 965         }
 966
 967         if (voltage >= DP_TRAIN_VOLTAGE_SWING_LEVEL_3)
 968                 voltage |= DP_TRAIN_MAX_SWING_REACHED;
 969
 970         max_preemphasis = (dp->dp_sub) ? DP_TRAIN_PRE_EMPH_LEVEL_2 :
 971                                          DP_TRAIN_PRE_EMPH_LEVEL_3;
 972
 973         if (preemphasis >= max_preemphasis)
 974                 preemphasis |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
 975
 976         for (i = 0; i < dp->mode.lane_cnt; i++)
 977                 train_set[i] = voltage | preemphasis;
 978 }
 979
 980 /**
 981  * xilinx_drm_dp_update_vs_emph - Update the training values
 982  * @dp: DisplayPort IP core structure
 983  *
 984  * Update the training values based on the request from sink. The mapped values
 985  * are predefined, and values(vs, pe, pc) are from the device manual.
 986  *
 987  * Return: 0 if vs and emph are updated successfully, or the error code returned
 988  * by drm_dp_dpcd_write().
 989  */
 990 static int xilinx_drm_dp_update_vs_emph(struct xilinx_drm_dp *dp)
 991 {
 992         u8 *train_set = dp->train_set;
 993         u8 i, v_level, p_level;
 994         int ret;
 995         static u8 vs[4][4] = { { 0x2a, 0x27, 0x24, 0x20 },
 996                                { 0x27, 0x23, 0x20, 0xff },
 997                                { 0x24, 0x20, 0xff, 0xff },
 998                                { 0xff, 0xff, 0xff, 0xff } };
 999         static u8 pe[4][4] = { { 0x2, 0x2, 0x2, 0x2 },
1000                                { 0x1, 0x1, 0x1, 0xff },
1001                                { 0x0, 0x0, 0xff, 0xff },
1002                                { 0xff, 0xff, 0xff, 0xff } };
1003
1004         ret = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, train_set,
1005                                 dp->mode.lane_cnt);
1006         if (ret < 0)
1007                 return ret;
1008
1009         for (i = 0; i < dp->mode.lane_cnt; i++) {
1010                 v_level = (train_set[i] & DP_TRAIN_VOLTAGE_SWING_MASK) >>
1011                           DP_TRAIN_VOLTAGE_SWING_SHIFT;
1012                 p_level = (train_set[i] & DP_TRAIN_PRE_EMPHASIS_MASK) >>
1013                           DP_TRAIN_PRE_EMPHASIS_SHIFT;
1014
1015                 if (dp->phy[i]) {
1016                         u32 reg = XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_0 + i * 4;
1017
1018                         xpsgtr_margining_factor(dp->phy[i], p_level, v_level);
1019                         xpsgtr_override_deemph(dp->phy[i], p_level, v_level);
1020                         xilinx_drm_writel(dp->iomem, reg, 0x2);
1021                 } else {
1022                         u32 reg;
1023
1024                         reg = XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_0 + i + 4;
1025                         xilinx_drm_writel(dp->iomem, reg, vs[p_level][v_level]);
1026                         reg = XILINX_DP_TX_PHY_PRECURSOR_LANE_0 + i + 4;
1027                         xilinx_drm_writel(dp->iomem, reg, pe[p_level][v_level]);
1028                         reg = XILINX_DP_TX_PHY_POSTCURSOR_LANE_0 + i + 4;
1029                         xilinx_drm_writel(dp->iomem, reg, 0);
1030                 }
1031         }
1032
1033         return 0;
1034 }
1035
1036 /**
1037  * xilinx_drm_dp_link_train_cr - Train clock recovery
1038  * @dp: DisplayPort IP core structure
1039  *
1040  * Return: 0 if clock recovery train is done successfully, or corresponding
1041  * error code.
1042  */
1043 static int xilinx_drm_dp_link_train_cr(struct xilinx_drm_dp *dp)
1044 {
1045         u8 link_status[DP_LINK_STATUS_SIZE];
1046         u8 lane_cnt = dp->mode.lane_cnt;
1047         u8 vs = 0, tries = 0;
1048         u16 max_tries, i;
1049         bool cr_done;
1050         int ret;
1051
1052         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET,
1053                           DP_TRAINING_PATTERN_1);
1054         ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
1055                                  DP_TRAINING_PATTERN_1 |
1056                                  DP_LINK_SCRAMBLING_DISABLE);
1057         if (ret < 0)
1058                 return ret;
1059
1060         /* 256 loops should be maximum iterations for 4 lanes and 4 values.
1061          * So, This loop should exit before 512 iterations
1062          */
1063         for (max_tries = 0; max_tries < 512; max_tries++) {
1064                 ret = xilinx_drm_dp_update_vs_emph(dp);
1065                 if (ret)
1066                         return ret;
1067
1068                 drm_dp_link_train_clock_recovery_delay(dp->dpcd);
1069
1070                 ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
1071                 if (ret < 0)
1072                         return ret;
1073
1074                 cr_done = drm_dp_clock_recovery_ok(link_status, lane_cnt);
1075                 if (cr_done)
1076                         break;
1077
1078                 for (i = 0; i < lane_cnt; i++)
1079                         if (!(dp->train_set[i] & DP_TRAIN_MAX_SWING_REACHED))
1080                                 break;
1081
1082                 if (i == lane_cnt)
1083                         break;
1084
1085                 if ((dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == vs)
1086                         tries++;
1087                 else
1088                         tries = 0;
1089
1090                 if (tries == DP_MAX_TRAINING_TRIES)
1091                         break;
1092
1093                 vs = dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
1094
1095                 xilinx_drm_dp_adjust_train(dp, link_status);
1096         }
1097
1098         if (!cr_done)
1099                 return -EIO;
1100
1101         return 0;
1102 }
1103
1104 /**
1105  * xilinx_drm_dp_link_train_ce - Train channel equalization
1106  * @dp: DisplayPort IP core structure
1107  *
1108  * Return: 0 if channel equalization train is done successfully, or
1109  * corresponding error code.
1110  */
1111 static int xilinx_drm_dp_link_train_ce(struct xilinx_drm_dp *dp)
1112 {
1113         u8 link_status[DP_LINK_STATUS_SIZE];
1114         u8 lane_cnt = dp->mode.lane_cnt;
1115         u32 pat, tries;
1116         int ret;
1117         bool ce_done;
1118
1119         if (dp->config.dp_version == DP_V1_2 &&
1120             dp->dpcd[DP_DPCD_REV] >= DP_V1_2 &&
1121             dp->dpcd[DP_MAX_LANE_COUNT] & DP_TPS3_SUPPORTED)
1122                 pat = DP_TRAINING_PATTERN_3;
1123         else
1124                 pat = DP_TRAINING_PATTERN_2;
1125         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET, pat);
1126         ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
1127                                  pat | DP_LINK_SCRAMBLING_DISABLE);
1128         if (ret < 0)
1129                 return ret;
1130
1131         for (tries = 0; tries < DP_MAX_TRAINING_TRIES; tries++) {
1132                 ret = xilinx_drm_dp_update_vs_emph(dp);
1133                 if (ret)
1134                         return ret;
1135
1136                 drm_dp_link_train_channel_eq_delay(dp->dpcd);
1137
1138                 ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
1139                 if (ret < 0)
1140                         return ret;
1141
1142                 ce_done = drm_dp_channel_eq_ok(link_status, lane_cnt);
1143                 if (ce_done)
1144                         break;
1145
1146                 xilinx_drm_dp_adjust_train(dp, link_status);
1147         }
1148
1149         if (!ce_done)
1150                 return -EIO;
1151
1152         return 0;
1153 }
1154
1155 /**
1156  * xilinx_drm_dp_link_train - Train the link
1157  * @dp: DisplayPort IP core structure
1158  *
1159  * Return: 0 if all trains are done successfully, or corresponding error code.
1160  */
1161 static int xilinx_drm_dp_train(struct xilinx_drm_dp *dp)
1162 {
1163         u32 reg;
1164         u8 bw_code = dp->mode.bw_code;
1165         u8 lane_cnt = dp->mode.lane_cnt;
1166         u8 aux_lane_cnt = lane_cnt;
1167         bool enhanced;
1168         int ret;
1169
1170         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_LANE_CNT_SET, lane_cnt);
1171
1172         enhanced = drm_dp_enhanced_frame_cap(dp->dpcd);
1173         if (enhanced) {
1174                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENHANCED_FRAME_EN, 1);
1175                 aux_lane_cnt |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
1176         }
1177
1178         if (dp->dpcd[3] & 0x1) {
1179                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_DOWNSPREAD_CTL, 1);
1180                 drm_dp_dpcd_writeb(&dp->aux, DP_DOWNSPREAD_CTRL,
1181                                    DP_SPREAD_AMP_0_5);
1182         } else {
1183                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_DOWNSPREAD_CTL, 0);
1184                 drm_dp_dpcd_writeb(&dp->aux, DP_DOWNSPREAD_CTRL, 0);
1185         }
1186
1187         ret = drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, aux_lane_cnt);
1188         if (ret < 0) {
1189                 DRM_ERROR("failed to set lane count\n");
1190                 return ret;
1191         }
1192
1193         ret = drm_dp_dpcd_writeb(&dp->aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
1194                                  DP_SET_ANSI_8B10B);
1195         if (ret < 0) {
1196                 DRM_ERROR("failed to set ANSI 8B/10B encoding\n");
1197                 return ret;
1198         }
1199
1200         ret = drm_dp_dpcd_writeb(&dp->aux, DP_LINK_BW_SET, bw_code);
1201         if (ret < 0) {
1202                 DRM_ERROR("failed to set DP bandwidth\n");
1203                 return ret;
1204         }
1205
1206         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_LINK_BW_SET, bw_code);
1207
1208         switch (bw_code) {
1209         case DP_LINK_BW_1_62:
1210                 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_162;
1211                 break;
1212         case DP_LINK_BW_2_7:
1213                 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_270;
1214                 break;
1215         case DP_LINK_BW_5_4:
1216         default:
1217                 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_540;
1218                 break;
1219         }
1220
1221         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING,
1222                           reg);
1223         ret = xilinx_drm_dp_phy_ready(dp);
1224         if (ret < 0)
1225                 return ret;
1226
1227         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SCRAMBLING_DISABLE, 1);
1228
1229         memset(dp->train_set, 0, 4);
1230
1231         ret = xilinx_drm_dp_link_train_cr(dp);
1232         if (ret)
1233                 return ret;
1234
1235         ret = xilinx_drm_dp_link_train_ce(dp);
1236         if (ret)
1237                 return ret;
1238
1239         ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
1240                                  DP_TRAINING_PATTERN_DISABLE);
1241         if (ret < 0) {
1242                 DRM_ERROR("failed to disable training pattern\n");
1243                 return ret;
1244         }
1245         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET,
1246                           DP_TRAINING_PATTERN_DISABLE);
1247
1248         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SCRAMBLING_DISABLE, 0);
1249
1250         return 0;
1251 }
1252
1253 /**
1254  * xilinx_drm_dp_train_loop - Downshift the link rate during training
1255  * @dp: DisplayPort IP core structure
1256  *
1257  * Train the link by downshifting the link rate if training is not successful.
1258  */
1259 static void xilinx_drm_dp_train_loop(struct xilinx_drm_dp *dp)
1260 {
1261         struct xilinx_drm_dp_mode *mode = &dp->mode;
1262         u8 bw = mode->bw_code;
1263         int ret;
1264
1265         do {
1266                 if (dp->status == connector_status_disconnected)
1267                         return;
1268
1269                 ret = xilinx_drm_dp_train(dp);
1270                 if (!ret)
1271                         return;
1272
1273                 ret = xilinx_drm_dp_mode_configure(dp, mode->pclock, bw);
1274                 if (ret < 0)
1275                         return;
1276                 bw = ret;
1277         } while (bw >= DP_LINK_BW_1_62);
1278
1279         DRM_ERROR("failed to train the DP link\n");
1280 }
1281
1282 /**
1283  * xilinx_drm_dp_init_aux - Initialize the DP aux
1284  * @dp: DisplayPort IP core structure
1285  *
1286  * Initialize the DP aux. The aux clock is derived from the axi clock, so
1287  * this function gets the axi clock frequency and calculates the filter
1288  * value. Additionally, the interrupts and transmitter are enabled.
1289  *
1290  * Return: 0 on success, error value otherwise
1291  */
1292 static int xilinx_drm_dp_init_aux(struct xilinx_drm_dp *dp)
1293 {
1294         int clock_rate;
1295         u32 reg, w;
1296
1297         clock_rate = clk_get_rate(dp->aclk);
1298         if (clock_rate < XILINX_DP_TX_CLK_DIVIDER_MHZ) {
1299                 DRM_ERROR("aclk should be higher than 1MHz\n");
1300                 return -EINVAL;
1301         }
1302
1303         /* Allowable values for this register are: 8, 16, 24, 32, 40, 48 */
1304         for (w = 8; w <= 48; w += 8) {
1305                 /* AUX pulse width should be between 0.4 to 0.6 usec */
1306                 if (w >= (4 * clock_rate / 10000000) &&
1307                     w <= (6 * clock_rate / 10000000))
1308                         break;
1309         }
1310
1311         if (w > 48) {
1312                 DRM_ERROR("aclk frequency too high\n");
1313                 return -EINVAL;
1314         }
1315         reg = w << XILINX_DP_TX_CLK_DIVIDER_AUX_FILTER_SHIFT;
1316
1317         reg |= clock_rate / XILINX_DP_TX_CLK_DIVIDER_MHZ;
1318         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_CLK_DIVIDER, reg);
1319
1320         if (dp->dp_sub)
1321                 xilinx_drm_writel(dp->iomem, XILINX_DP_SUB_TX_INTR_EN,
1322                                   XILINX_DP_TX_INTR_ALL);
1323         else
1324                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INTR_MASK,
1325                                   (u32)~XILINX_DP_TX_INTR_ALL);
1326         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 1);
1327
1328         return 0;
1329 }
1330
1331 /**
1332  * xilinx_drm_dp_init_phy - Initialize the phy
1333  * @dp: DisplayPort IP core structure
1334  *
1335  * Initialize the phy.
1336  *
1337  * Return: 0 if the phy instances are initialized correctly, or the error code
1338  * returned from the callee functions.
1339  */
1340 static int xilinx_drm_dp_init_phy(struct xilinx_drm_dp *dp)
1341 {
1342         unsigned int i;
1343         int ret;
1344
1345         for (i = 0; i < dp->config.max_lanes; i++) {
1346                 ret = phy_init(dp->phy[i]);
1347                 if (ret) {
1348                         dev_err(dp->dev, "failed to init phy lane %d\n", i);
1349                         return ret;
1350                 }
1351         }
1352
1353         if (dp->dp_sub)
1354                 xilinx_drm_writel(dp->iomem, XILINX_DP_SUB_TX_INTR_DS,
1355                                   XILINX_DP_TX_INTR_ALL);
1356         else
1357                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INTR_MASK,
1358                                   XILINX_DP_TX_INTR_ALL);
1359
1360         xilinx_drm_clr(dp->iomem, XILINX_DP_TX_PHY_CONFIG,
1361                        XILINX_DP_TX_PHY_CONFIG_ALL_RESET);
1362
1363         /* Wait for PLL to be locked for the primary (1st) */
1364         if (dp->phy[0]) {
1365                 ret = xpsgtr_wait_pll_lock(dp->phy[0]);
1366                 if (ret) {
1367                         dev_err(dp->dev, "failed to lock pll\n");
1368                         return ret;
1369                 }
1370         }
1371
1372         return 0;
1373 }
1374
1375 /**
1376  * xilinx_drm_dp_exit_phy - Exit the phy
1377  * @dp: DisplayPort IP core structure
1378  *
1379  * Exit the phy.
1380  */
1381 static void xilinx_drm_dp_exit_phy(struct xilinx_drm_dp *dp)
1382 {
1383         unsigned int i;
1384         int ret;
1385
1386         for (i = 0; i < dp->config.max_lanes; i++) {
1387                 ret = phy_exit(dp->phy[i]);
1388                 if (ret) {
1389                         dev_err(dp->dev,
1390                                 "failed to exit phy (%d) %d\n", i, ret);
1391                 }
1392         }
1393 }
1394
1395 static void xilinx_drm_dp_dpms(struct drm_encoder *encoder, int dpms)
1396 {
1397         struct xilinx_drm_dp *dp = to_dp(encoder);
1398         void __iomem *iomem = dp->iomem;
1399         unsigned int i;
1400         int ret;
1401
1402         if (dp->dpms == dpms)
1403                 return;
1404
1405         dp->dpms = dpms;
1406
1407         switch (dpms) {
1408         case DRM_MODE_DPMS_ON:
1409                 pm_runtime_get_sync(dp->dev);
1410
1411                 if (dp->aud_clk && !dp->aud_clk_enabled) {
1412                         ret = clk_prepare_enable(dp->aud_clk);
1413                         if (ret) {
1414                                 dev_err(dp->dev, "failed to enable aud_clk\n");
1415                         } else {
1416                                 xilinx_drm_writel(iomem,
1417                                                   XILINX_DP_TX_AUDIO_CONTROL,
1418                                                   1);
1419                                 dp->aud_clk_enabled = true;
1420                         }
1421                 }
1422                 xilinx_drm_writel(iomem, XILINX_DP_TX_PHY_POWER_DOWN, 0);
1423
1424                 if (dp->status == connector_status_connected) {
1425                         for (i = 0; i < 3; i++) {
1426                                 ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER,
1427                                                          DP_SET_POWER_D0);
1428                                 if (ret == 1)
1429                                         break;
1430                                 usleep_range(300, 500);
1431                         }
1432                         /* Some monitors take time to wake up properly */
1433                         msleep(xilinx_drm_dp_power_on_delay_ms);
1434                         if (ret != 1)
1435                                 dev_dbg(dp->dev, "DP aux failed\n");
1436                         else
1437                                 xilinx_drm_dp_train_loop(dp);
1438                 }
1439                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SW_RESET,
1440                                   XILINX_DP_TX_SW_RESET_ALL);
1441                 xilinx_drm_writel(iomem, XILINX_DP_TX_ENABLE_MAIN_STREAM, 1);
1442
1443                 return;
1444         default:
1445                 xilinx_drm_writel(iomem, XILINX_DP_TX_ENABLE_MAIN_STREAM, 0);
1446                 if (dp->status == connector_status_connected) {
1447                         drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER,
1448                                            DP_SET_POWER_D3);
1449                 }
1450                 xilinx_drm_writel(iomem, XILINX_DP_TX_PHY_POWER_DOWN,
1451                                   XILINX_DP_TX_PHY_POWER_DOWN_ALL);
1452                 if (dp->aud_clk && dp->aud_clk_enabled) {
1453                         xilinx_drm_writel(iomem, XILINX_DP_TX_AUDIO_CONTROL, 0);
1454                         clk_disable_unprepare(dp->aud_clk);
1455                         dp->aud_clk_enabled = false;
1456                 }
1457                 pm_runtime_put_sync(dp->dev);
1458
1459                 return;
1460         }
1461 }
1462
1463 static void xilinx_drm_dp_save(struct drm_encoder *encoder)
1464 {
1465         /* no op */
1466 }
1467
1468 static void xilinx_drm_dp_restore(struct drm_encoder *encoder)
1469 {
1470         /* no op */
1471 }
1472
1473 #define XILINX_DP_SUB_TX_MIN_H_BACKPORCH        20
1474
1475 static bool xilinx_drm_dp_mode_fixup(struct drm_encoder *encoder,
1476                                      const struct drm_display_mode *mode,
1477                                      struct drm_display_mode *adjusted_mode)
1478 {
1479         struct xilinx_drm_dp *dp = to_dp(encoder);
1480         int diff = mode->htotal - mode->hsync_end;
1481
1482         /*
1483          * ZynqMP DP requires horizontal backporch to be greater than 12.
1484          * This limitation may conflict with the sink device.
1485          */
1486         if (dp->dp_sub && diff < XILINX_DP_SUB_TX_MIN_H_BACKPORCH) {
1487                 int vrefresh = (adjusted_mode->clock * 1000) /
1488                                (adjusted_mode->vtotal * adjusted_mode->htotal);
1489
1490                 diff = XILINX_DP_SUB_TX_MIN_H_BACKPORCH - diff;
1491                 adjusted_mode->htotal += diff;
1492                 adjusted_mode->clock = adjusted_mode->vtotal *
1493                                        adjusted_mode->htotal * vrefresh / 1000;
1494         }
1495
1496         return true;
1497 }
1498
1499 static int xilinx_drm_dp_mode_valid(struct drm_encoder *encoder,
1500                                     struct drm_display_mode *mode)
1501 {
1502         struct xilinx_drm_dp *dp = to_dp(encoder);
1503         u8 max_lanes = dp->link_config.max_lanes;
1504         u8 bpp = dp->config.bpp;
1505         u32 max_pclock = dp->config.max_pclock;
1506         int max_rate = dp->link_config.max_rate;
1507         int rate;
1508
1509         if (max_pclock && mode->clock > max_pclock)
1510                 return MODE_CLOCK_HIGH;
1511
1512         rate = xilinx_drm_dp_max_rate(max_rate, max_lanes, bpp);
1513         if (mode->clock > rate)
1514                 return MODE_CLOCK_HIGH;
1515
1516         return MODE_OK;
1517 }
1518
1519 /**
1520  * xilinx_drm_dp_mode_set_transfer_unit - Set the transfer unit values
1521  * @dp: DisplayPort IP core structure
1522  * @mode: requested display mode
1523  *
1524  * Set the transfer unit, and caculate all transfer unit size related values.
1525  * Calculation is based on DP and IP core specification.
1526  */
1527 static void xilinx_drm_dp_mode_set_transfer_unit(struct xilinx_drm_dp *dp,
1528                                                  struct drm_display_mode *mode)
1529 {
1530         u32 tu = XILINX_DP_TX_DEF_TRANSFER_UNIT_SIZE;
1531         u32 bw, vid_kbytes, avg_bytes_per_tu, init_wait;
1532
1533         /* Use the max transfer unit size (default) */
1534         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRANSFER_UNIT_SIZE, tu);
1535
1536         vid_kbytes = mode->clock * (dp->config.bpp / 8);
1537         bw = drm_dp_bw_code_to_link_rate(dp->mode.bw_code);
1538         avg_bytes_per_tu = vid_kbytes * tu / (dp->mode.lane_cnt * bw / 1000);
1539
1540         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MIN_BYTES_PER_TU,
1541                           avg_bytes_per_tu / 1000);
1542         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_FRAC_BYTES_PER_TU,
1543                           avg_bytes_per_tu % 1000);
1544
1545         /* Configure the initial wait cycle based on transfer unit size */
1546         if (tu < (avg_bytes_per_tu / 1000))
1547                 init_wait = 0;
1548         else if ((avg_bytes_per_tu / 1000) <= 4)
1549                 init_wait = tu;
1550         else
1551                 init_wait = tu - avg_bytes_per_tu / 1000;
1552
1553         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INIT_WAIT, init_wait);
1554 }
1555
1556 /**
1557  * xilinx_drm_dp_mode_set_stream - Configure the main stream
1558  * @dp: DisplayPort IP core structure
1559  * @mode: requested display mode
1560  *
1561  * Configure the main stream based on the requested mode @mode. Calculation is
1562  * based on IP core specification.
1563  */
1564 static void xilinx_drm_dp_mode_set_stream(struct xilinx_drm_dp *dp,
1565                                           struct drm_display_mode *mode)
1566 {
1567         u8 lane_cnt = dp->mode.lane_cnt;
1568         u32 reg, wpl;
1569
1570         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HTOTAL,
1571                           mode->htotal);
1572         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VTOTAL,
1573                           mode->vtotal);
1574
1575         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_POLARITY,
1576                           (!!(mode->flags & DRM_MODE_FLAG_PVSYNC) <<
1577                            XILINX_DP_TX_MAIN_STREAM_POLARITY_VSYNC_SHIFT) |
1578                           (!!(mode->flags & DRM_MODE_FLAG_PHSYNC) <<
1579                            XILINX_DP_TX_MAIN_STREAM_POLARITY_HSYNC_SHIFT));
1580
1581         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HSWIDTH,
1582                           mode->hsync_end - mode->hsync_start);
1583         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VSWIDTH,
1584                           mode->vsync_end - mode->vsync_start);
1585
1586         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HRES,
1587                           mode->hdisplay);
1588         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VRES,
1589                           mode->vdisplay);
1590
1591         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HSTART,
1592                           mode->htotal - mode->hsync_start);
1593         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VSTART,
1594                           mode->vtotal - mode->vsync_start);
1595
1596         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC0,
1597                           dp->config.misc0);
1598         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC1,
1599                           dp->config.misc1);
1600
1601         /* In synchronous mode, set the diviers */
1602         if (dp->config.misc0 & XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC) {
1603                 reg = drm_dp_bw_code_to_link_rate(dp->mode.bw_code);
1604                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_N_VID, reg);
1605                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_M_VID, mode->clock);
1606                 if (dp->aud_clk) {
1607                         int aud_rate = clk_get_rate(dp->aud_clk);
1608
1609                         dev_dbg(dp->dev, "Audio rate: %d\n", aud_rate / 512);
1610
1611                         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_N_AUD,
1612                                           reg);
1613                         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_M_AUD,
1614                                           aud_rate / 1000);
1615                 }
1616         }
1617
1618         /* Only 2 channel is supported now */
1619         if (dp->aud_clk)
1620                 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_CHANNELS, 1);
1621
1622         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_USER_PIXEL_WIDTH, 1);
1623
1624         /* Translate to the native 16 bit datapath based on IP core spec */
1625         wpl = (mode->hdisplay * dp->config.bpp + 15) / 16;
1626         reg = wpl + wpl % lane_cnt - lane_cnt;
1627         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_USER_DATA_CNT_PER_LANE, reg);
1628 }
1629
1630 static void xilinx_drm_dp_mode_set(struct drm_encoder *encoder,
1631                                    struct drm_display_mode *mode,
1632                                    struct drm_display_mode *adjusted_mode)
1633 {
1634         struct xilinx_drm_dp *dp = to_dp(encoder);
1635         int ret;
1636
1637         ret = xilinx_drm_dp_mode_configure(dp, adjusted_mode->clock, 0);
1638         if (ret < 0)
1639                 return;
1640
1641         xilinx_drm_dp_mode_set_stream(dp, adjusted_mode);
1642         xilinx_drm_dp_mode_set_transfer_unit(dp, adjusted_mode);
1643 }
1644
1645 static enum drm_connector_status
1646 xilinx_drm_dp_detect(struct drm_encoder *encoder,
1647                      struct drm_connector *connector)
1648 {
1649         struct xilinx_drm_dp *dp = to_dp(encoder);
1650         struct xilinx_drm_dp_link_config *link_config = &dp->link_config;
1651         u32 state;
1652         int ret;
1653
1654         state = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
1655         if (state & XILINX_DP_TX_INTR_SIGNAL_STATE_HPD) {
1656                 dp->status = connector_status_connected;
1657                 ret = drm_dp_dpcd_read(&dp->aux, 0x0, dp->dpcd,
1658                                        sizeof(dp->dpcd));
1659                 if (ret < 0)
1660                         goto disconnected;
1661
1662                 link_config->max_rate = min_t(int,
1663                                               drm_dp_max_link_rate(dp->dpcd),
1664                                               dp->config.max_link_rate);
1665                 link_config->max_lanes = min_t(u8,
1666                                                drm_dp_max_lane_count(dp->dpcd),
1667                                                dp->config.max_lanes);
1668                 return dp->status;
1669         }
1670
1671 disconnected:
1672         dp->status = connector_status_disconnected;
1673         return dp->status;
1674 }
1675
1676 static int xilinx_drm_dp_get_modes(struct drm_encoder *encoder,
1677                                    struct drm_connector *connector)
1678 {
1679         struct xilinx_drm_dp *dp = to_dp(encoder);
1680         struct edid *edid;
1681         int ret;
1682
1683         edid = drm_get_edid(connector, &dp->aux.ddc);
1684         if (!edid)
1685                 return 0;
1686
1687         drm_mode_connector_update_edid_property(connector, edid);
1688         ret = drm_add_edid_modes(connector, edid);
1689
1690         kfree(edid);
1691
1692         return ret;
1693 }
1694
1695 static struct drm_encoder_slave_funcs xilinx_drm_dp_encoder_funcs = {
1696         .dpms                   = xilinx_drm_dp_dpms,
1697         .save                   = xilinx_drm_dp_save,
1698         .restore                = xilinx_drm_dp_restore,
1699         .mode_fixup             = xilinx_drm_dp_mode_fixup,
1700         .mode_valid             = xilinx_drm_dp_mode_valid,
1701         .mode_set               = xilinx_drm_dp_mode_set,
1702         .detect                 = xilinx_drm_dp_detect,
1703         .get_modes              = xilinx_drm_dp_get_modes,
1704 };
1705
1706 static int xilinx_drm_dp_encoder_init(struct platform_device *pdev,
1707                                       struct drm_device *dev,
1708                                       struct drm_encoder_slave *encoder)
1709 {
1710         struct xilinx_drm_dp *dp = platform_get_drvdata(pdev);
1711
1712         encoder->slave_priv = dp;
1713         encoder->slave_funcs = &xilinx_drm_dp_encoder_funcs;
1714
1715         dp->encoder = &encoder->base;
1716
1717         return xilinx_drm_dp_init_aux(dp);
1718 }
1719
1720 static irqreturn_t xilinx_drm_dp_irq_handler(int irq, void *data)
1721 {
1722         struct xilinx_drm_dp *dp = (struct xilinx_drm_dp *)data;
1723         u32 reg, status;
1724
1725         reg = dp->dp_sub ?
1726               XILINX_DP_SUB_TX_INTR_STATUS : XILINX_DP_TX_INTR_STATUS;
1727         status = xilinx_drm_readl(dp->iomem, reg);
1728         if (!status)
1729                 return IRQ_NONE;
1730
1731         if (status & XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK)
1732                 dev_dbg(dp->dev, "underflow interrupt\n");
1733         if (status & XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK)
1734                 dev_dbg(dp->dev, "overflow interrupt\n");
1735
1736         xilinx_drm_writel(dp->iomem, reg, status);
1737
1738         if (status & XILINX_DP_TX_INTR_VBLANK_START)
1739                 xilinx_drm_dp_sub_handle_vblank(dp->dp_sub);
1740
1741         if (status & XILINX_DP_TX_INTR_HPD_EVENT)
1742                 drm_helper_hpd_irq_event(dp->encoder->dev);
1743
1744         if (status & XILINX_DP_TX_INTR_HPD_IRQ) {
1745                 u8 status[DP_LINK_STATUS_SIZE + 2];
1746                 int ret;
1747
1748                 ret = drm_dp_dpcd_read(&dp->aux, DP_SINK_COUNT, status,
1749                                        DP_LINK_STATUS_SIZE + 2);
1750                 if (ret < 0)
1751                         goto handled;
1752
1753                 if (status[4] & DP_LINK_STATUS_UPDATED ||
1754                     !drm_dp_clock_recovery_ok(&status[2], dp->mode.lane_cnt) ||
1755                     !drm_dp_channel_eq_ok(&status[2], dp->mode.lane_cnt))
1756                         xilinx_drm_dp_train_loop(dp);
1757         }
1758
1759 handled:
1760         return IRQ_HANDLED;
1761 }
1762
1763 static ssize_t
1764 xilinx_drm_dp_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
1765 {
1766         struct xilinx_drm_dp *dp = container_of(aux, struct xilinx_drm_dp, aux);
1767         int ret;
1768         unsigned int i, iter;
1769
1770         /* Number of loops = timeout in msec / aux delay (400 usec) */
1771         iter = xilinx_drm_dp_aux_timeout_ms * 1000 / 400;
1772         iter = iter ? iter : 1;
1773
1774         for (i = 0; i < iter; i++) {
1775                 ret = xilinx_drm_dp_aux_cmd_submit(dp, msg->request,
1776                                                    msg->address, msg->buffer,
1777                                                    msg->size, &msg->reply);
1778                 if (!ret) {
1779                         dev_dbg(dp->dev, "aux %d retries\n", i);
1780                         return msg->size;
1781                 }
1782
1783                 if (dp->status == connector_status_disconnected) {
1784                         dev_dbg(dp->dev, "no aux dev\n");
1785                         return -ENODEV;
1786                 }
1787
1788                 usleep_range(400, 500);
1789         }
1790
1791         dev_dbg(dp->dev, "failed to do aux transfer (%d)\n", ret);
1792
1793         return ret;
1794 }
1795
1796 static int xilinx_drm_dp_parse_of(struct xilinx_drm_dp *dp)
1797 {
1798         struct device_node *node = dp->dev->of_node;
1799         struct xilinx_drm_dp_config *config = &dp->config;
1800         const char *string;
1801         u32 num_colors, bpc;
1802         bool sync;
1803         int ret;
1804
1805         ret = of_property_read_string(node, "xlnx,dp-version", &string);
1806         if (ret < 0) {
1807                 dev_err(dp->dev, "No DP version in DT\n");
1808                 return ret;
1809         }
1810
1811         if (strcmp(string, "v1.1a") == 0) {
1812                 config->dp_version = DP_V1_1A;
1813         } else if (strcmp(string, "v1.2") == 0) {
1814                 config->dp_version = DP_V1_2;
1815         } else {
1816                 dev_err(dp->dev, "Invalid DP version in DT\n");
1817                 return -EINVAL;
1818         }
1819
1820         ret = of_property_read_u32(node, "xlnx,max-lanes", &config->max_lanes);
1821         if (ret < 0) {
1822                 dev_err(dp->dev, "No lane count in DT\n");
1823                 return ret;
1824         }
1825
1826         if (config->max_lanes != 1 && config->max_lanes != 2 &&
1827             config->max_lanes != 4) {
1828                 dev_err(dp->dev, "Invalid max lanes in DT\n");
1829                 return -EINVAL;
1830         }
1831
1832         ret = of_property_read_u32(node, "xlnx,max-link-rate",
1833                                    &config->max_link_rate);
1834         if (ret < 0) {
1835                 dev_err(dp->dev, "No link rate in DT\n");
1836                 return ret;
1837         }
1838
1839         if (config->max_link_rate != DP_REDUCED_BIT_RATE &&
1840             config->max_link_rate != DP_HIGH_BIT_RATE &&
1841             config->max_link_rate != DP_HIGH_BIT_RATE2) {
1842                 dev_err(dp->dev, "Invalid link rate in DT\n");
1843                 return -EINVAL;
1844         }
1845
1846         config->enable_yonly = of_property_read_bool(node, "xlnx,enable-yonly");
1847         config->enable_ycrcb = of_property_read_bool(node, "xlnx,enable-ycrcb");
1848
1849         sync = of_property_read_bool(node, "xlnx,sync");
1850         if (sync)
1851                 config->misc0 |= XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC;
1852
1853         ret = of_property_read_string(node, "xlnx,colormetry", &string);
1854         if (ret < 0) {
1855                 dev_err(dp->dev, "No colormetry in DT\n");
1856                 return ret;
1857         }
1858
1859         if (strcmp(string, "rgb") == 0) {
1860                 config->misc0 |= XILINX_DP_MISC0_RGB;
1861                 num_colors = 3;
1862         } else if (config->enable_ycrcb && strcmp(string, "ycrcb422") == 0) {
1863                 config->misc0 |= XILINX_DP_MISC0_YCRCB_422;
1864                 num_colors = 2;
1865         } else if (config->enable_ycrcb && strcmp(string, "ycrcb444") == 0) {
1866                 config->misc0 |= XILINX_DP_MISC0_YCRCB_444;
1867                 num_colors = 3;
1868         } else if (config->enable_yonly && strcmp(string, "yonly") == 0) {
1869                 config->misc1 |= XILINX_DP_MISC1_Y_ONLY;
1870                 num_colors = 1;
1871         } else {
1872                 dev_err(dp->dev, "Invalid colormetry in DT\n");
1873                 return -EINVAL;
1874         }
1875
1876         ret = of_property_read_u32(node, "xlnx,max-bpc", &config->max_bpc);
1877         if (ret < 0) {
1878                 dev_err(dp->dev, "No max bpc in DT\n");
1879                 return ret;
1880         }
1881
1882         if (config->max_bpc != 8 && config->max_bpc != 10 &&
1883             config->max_bpc != 12 && config->max_bpc != 16) {
1884                 dev_err(dp->dev, "Invalid max bpc in DT\n");
1885                 return -EINVAL;
1886         }
1887
1888         ret = of_property_read_u32(node, "xlnx,bpc", &bpc);
1889         if (ret < 0) {
1890                 dev_err(dp->dev, "No color depth(bpc) in DT\n");
1891                 return ret;
1892         }
1893
1894         if (bpc > config->max_bpc) {
1895                 dev_err(dp->dev, "Invalid color depth(bpc) in DT\n");
1896                 return -EINVAL;
1897         }
1898
1899         switch (bpc) {
1900         case 6:
1901                 config->misc0 |= XILINX_DP_MISC0_BPC_6;
1902                 break;
1903         case 8:
1904                 config->misc0 |= XILINX_DP_MISC0_BPC_8;
1905                 break;
1906         case 10:
1907                 config->misc0 |= XILINX_DP_MISC0_BPC_10;
1908                 break;
1909         case 12:
1910                 config->misc0 |= XILINX_DP_MISC0_BPC_12;
1911                 break;
1912         case 16:
1913                 config->misc0 |= XILINX_DP_MISC0_BPC_16;
1914                 break;
1915         default:
1916                 dev_err(dp->dev, "Not supported color depth in DT\n");
1917                 return -EINVAL;
1918         }
1919
1920         config->bpp = num_colors * bpc;
1921
1922         of_property_read_u32(node, "xlnx,max-pclock-frequency",
1923                              &config->max_pclock);
1924
1925         return 0;
1926 }
1927
1928 static int __maybe_unused xilinx_drm_dp_pm_suspend(struct device *dev)
1929 {
1930         struct xilinx_drm_dp *dp = dev_get_drvdata(dev);
1931
1932         xilinx_drm_dp_exit_phy(dp);
1933
1934         return 0;
1935 }
1936
1937 static int __maybe_unused xilinx_drm_dp_pm_resume(struct device *dev)
1938 {
1939         struct xilinx_drm_dp *dp = dev_get_drvdata(dev);
1940
1941         xilinx_drm_dp_init_phy(dp);
1942         xilinx_drm_dp_init_aux(dp);
1943         drm_helper_hpd_irq_event(dp->encoder->dev);
1944
1945         return 0;
1946 }
1947
1948 static const struct dev_pm_ops xilinx_drm_dp_pm_ops = {
1949         SET_SYSTEM_SLEEP_PM_OPS(xilinx_drm_dp_pm_suspend,
1950                                 xilinx_drm_dp_pm_resume)
1951 };
1952
1953 static int xilinx_drm_dp_probe(struct platform_device *pdev)
1954 {
1955         struct xilinx_drm_dp *dp;
1956         struct resource *res;
1957         u32 version, i;
1958         int irq, ret;
1959
1960         dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
1961         if (!dp)
1962                 return -ENOMEM;
1963
1964         dp->dpms = DRM_MODE_DPMS_OFF;
1965         dp->status = connector_status_disconnected;
1966         dp->dev = &pdev->dev;
1967
1968         ret = xilinx_drm_dp_parse_of(dp);
1969         if (ret < 0)
1970                 return ret;
1971
1972         dp->aclk = devm_clk_get(dp->dev, "aclk");
1973         if (IS_ERR(dp->aclk))
1974                 return PTR_ERR(dp->aclk);
1975
1976         ret = clk_prepare_enable(dp->aclk);
1977         if (ret) {
1978                 dev_err(dp->dev, "failed to enable the aclk\n");
1979                 return ret;
1980         }
1981
1982         dp->aud_clk = devm_clk_get(dp->dev, "aud_clk");
1983         if (IS_ERR(dp->aud_clk)) {
1984                 ret = PTR_ERR(dp->aud_clk);
1985                 if (ret == -EPROBE_DEFER)
1986                         goto error_aclk;
1987                 dp->aud_clk = NULL;
1988                 dev_dbg(dp->dev, "failed to get the aud_clk:\n");
1989         }
1990
1991         dp->dp_sub = xilinx_drm_dp_sub_of_get(pdev->dev.of_node);
1992         if (IS_ERR(dp->dp_sub)) {
1993                 ret = PTR_ERR(dp->dp_sub);
1994                 goto error_aclk;
1995         }
1996
1997         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1998         dp->iomem = devm_ioremap_resource(dp->dev, res);
1999         if (IS_ERR(dp->iomem)) {
2000                 ret = PTR_ERR(dp->iomem);
2001                 goto error_dp_sub;
2002         }
2003
2004         platform_set_drvdata(pdev, dp);
2005
2006         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN,
2007                           XILINX_DP_TX_PHY_POWER_DOWN_ALL);
2008         xilinx_drm_set(dp->iomem, XILINX_DP_TX_PHY_CONFIG,
2009                        XILINX_DP_TX_PHY_CONFIG_ALL_RESET);
2010         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_FORCE_SCRAMBLER_RESET, 1);
2011         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 0);
2012
2013         if (dp->dp_sub) {
2014                 for (i = 0; i < dp->config.max_lanes; i++) {
2015                         char phy_name[16];
2016
2017                         snprintf(phy_name, sizeof(phy_name), "dp-phy%d", i);
2018                         dp->phy[i] = devm_phy_get(dp->dev, phy_name);
2019                         if (IS_ERR(dp->phy[i])) {
2020                                 dev_err(dp->dev, "failed to get phy lane\n");
2021                                 ret = PTR_ERR(dp->phy[i]);
2022                                 dp->phy[i] = NULL;
2023                                 goto error_dp_sub;
2024                         }
2025                 }
2026         }
2027
2028         ret = xilinx_drm_dp_init_phy(dp);
2029         if (ret)
2030                 goto error_phy;
2031
2032         dp->aux.name = "Xilinx DP AUX";
2033         dp->aux.dev = dp->dev;
2034         dp->aux.transfer = xilinx_drm_dp_aux_transfer;
2035         ret = drm_dp_aux_register(&dp->aux);
2036         if (ret < 0) {
2037                 dev_err(dp->dev, "failed to initialize DP aux\n");
2038                 goto error;
2039         }
2040
2041         irq = platform_get_irq(pdev, 0);
2042         if (irq < 0) {
2043                 ret = irq;
2044                 goto error;
2045         }
2046
2047         ret = devm_request_threaded_irq(dp->dev, irq, NULL,
2048                                         xilinx_drm_dp_irq_handler, IRQF_ONESHOT,
2049                                         dev_name(dp->dev), dp);
2050         if (ret < 0)
2051                 goto error;
2052
2053         version = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_VERSION);
2054
2055         dev_info(dp->dev, "device found, version %u.%02x%x\n",
2056                  ((version & XILINX_DP_TX_VERSION_MAJOR_MASK) >>
2057                   XILINX_DP_TX_VERSION_MAJOR_SHIFT),
2058                  ((version & XILINX_DP_TX_VERSION_MINOR_MASK) >>
2059                   XILINX_DP_TX_VERSION_MINOR_SHIFT),
2060                  ((version & XILINX_DP_TX_VERSION_REVISION_MASK) >>
2061                   XILINX_DP_TX_VERSION_REVISION_SHIFT));
2062
2063         version = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_CORE_ID);
2064         if (version & XILINX_DP_TX_CORE_ID_DIRECTION) {
2065                 dev_err(dp->dev, "Receiver is not supported\n");
2066                 ret = -ENODEV;
2067                 goto error;
2068         }
2069
2070         dev_info(dp->dev, "Display Port, version %u.%02x%02x (tx)\n",
2071                  ((version & XILINX_DP_TX_CORE_ID_MAJOR_MASK) >>
2072                   XILINX_DP_TX_CORE_ID_MAJOR_SHIFT),
2073                  ((version & XILINX_DP_TX_CORE_ID_MINOR_MASK) >>
2074                   XILINX_DP_TX_CORE_ID_MINOR_SHIFT),
2075                  ((version & XILINX_DP_TX_CORE_ID_REVISION_MASK) >>
2076                   XILINX_DP_TX_CORE_ID_REVISION_SHIFT));
2077
2078         pm_runtime_enable(dp->dev);
2079
2080         xilinx_dp_debugfs_init(dp);
2081
2082         return 0;
2083
2084 error:
2085         drm_dp_aux_unregister(&dp->aux);
2086 error_dp_sub:
2087         xilinx_drm_dp_sub_put(dp->dp_sub);
2088 error_phy:
2089         xilinx_drm_dp_exit_phy(dp);
2090 error_aclk:
2091         clk_disable_unprepare(dp->aclk);
2092         return ret;
2093 }
2094
2095 static int xilinx_drm_dp_remove(struct platform_device *pdev)
2096 {
2097         struct xilinx_drm_dp *dp = platform_get_drvdata(pdev);
2098
2099         pm_runtime_disable(dp->dev);
2100         xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 0);
2101
2102         drm_dp_aux_unregister(&dp->aux);
2103         xilinx_drm_dp_exit_phy(dp);
2104         xilinx_drm_dp_sub_put(dp->dp_sub);
2105
2106         if (dp->aud_clk && dp->aud_clk_enabled)
2107                 clk_disable_unprepare(dp->aud_clk);
2108         clk_disable_unprepare(dp->aclk);
2109
2110         return 0;
2111 }
2112
2113 static const struct of_device_id xilinx_drm_dp_of_match[] = {
2114         { .compatible = "xlnx,v-dp", },
2115         { /* end of table */ },
2116 };
2117 MODULE_DEVICE_TABLE(of, xilinx_drm_dp_of_match);
2118
2119 static struct drm_platform_encoder_driver xilinx_drm_dp_driver = {
2120         .platform_driver = {
2121                 .probe                  = xilinx_drm_dp_probe,
2122                 .remove                 = xilinx_drm_dp_remove,
2123                 .driver                 = {
2124                         .owner          = THIS_MODULE,
2125                         .name           = "xilinx-drm-dp",
2126                         .of_match_table = xilinx_drm_dp_of_match,
2127                         .pm             = &xilinx_drm_dp_pm_ops,
2128                 },
2129         },
2130
2131         .encoder_init = xilinx_drm_dp_encoder_init,
2132 };
2133
2134 static int __init xilinx_drm_dp_init(void)
2135 {
2136         return platform_driver_register(&xilinx_drm_dp_driver.platform_driver);
2137 }
2138
2139 static void __exit xilinx_drm_dp_exit(void)
2140 {
2141         platform_driver_unregister(&xilinx_drm_dp_driver.platform_driver);
2142 }
2143
2144 module_init(xilinx_drm_dp_init);
2145 module_exit(xilinx_drm_dp_exit);
2146
2147 MODULE_AUTHOR("Xilinx, Inc.");
2148 MODULE_DESCRIPTION("Xilinx DRM KMS DiplayPort Driver");
2149 MODULE_LICENSE("GPL v2");