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