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