1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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/delay.h>
26#include <linux/device.h>
27#include <linux/module.h>
28#include <linux/mutex.h>
29#include <linux/phy/phy.h>
30#include <linux/phy/phy-zynqmp.h>
31#include <linux/platform_device.h>
32#include <linux/pm.h>
33
34#include "xilinx_drm_dp_sub.h"
35#include "xilinx_drm_drv.h"
36
37
38#define XILINX_DP_TX_LINK_BW_SET 0x0
39#define XILINX_DP_TX_LANE_CNT_SET 0x4
40#define XILINX_DP_TX_ENHANCED_FRAME_EN 0x8
41#define XILINX_DP_TX_TRAINING_PATTERN_SET 0xc
42#define XILINX_DP_TX_SCRAMBLING_DISABLE 0x14
43#define XILINX_DP_TX_DOWNSPREAD_CTL 0x18
44#define XILINX_DP_TX_SW_RESET 0x1c
45#define XILINX_DP_TX_SW_RESET_STREAM1 (1 << 0)
46#define XILINX_DP_TX_SW_RESET_STREAM2 (1 << 1)
47#define XILINX_DP_TX_SW_RESET_STREAM3 (1 << 2)
48#define XILINX_DP_TX_SW_RESET_STREAM4 (1 << 3)
49#define XILINX_DP_TX_SW_RESET_AUX (1 << 7)
50#define XILINX_DP_TX_SW_RESET_ALL (XILINX_DP_TX_SW_RESET_STREAM1 | \
51 XILINX_DP_TX_SW_RESET_STREAM2 | \
52 XILINX_DP_TX_SW_RESET_STREAM3 | \
53 XILINX_DP_TX_SW_RESET_STREAM4 | \
54 XILINX_DP_TX_SW_RESET_AUX)
55
56
57#define XILINX_DP_TX_ENABLE 0x80
58#define XILINX_DP_TX_ENABLE_MAIN_STREAM 0x84
59#define XILINX_DP_TX_FORCE_SCRAMBLER_RESET 0xc0
60#define XILINX_DP_TX_VERSION 0xf8
61#define XILINX_DP_TX_VERSION_MAJOR_MASK (0xff << 24)
62#define XILINX_DP_TX_VERSION_MAJOR_SHIFT 24
63#define XILINX_DP_TX_VERSION_MINOR_MASK (0xff << 16)
64#define XILINX_DP_TX_VERSION_MINOR_SHIFT 16
65#define XILINX_DP_TX_VERSION_REVISION_MASK (0xf << 12)
66#define XILINX_DP_TX_VERSION_REVISION_SHIFT 12
67#define XILINX_DP_TX_VERSION_PATCH_MASK (0xf << 8)
68#define XILINX_DP_TX_VERSION_PATCH_SHIFT 8
69#define XILINX_DP_TX_VERSION_INTERNAL_MASK (0xff << 0)
70#define XILINX_DP_TX_VERSION_INTERNAL_SHIFT 0
71
72
73#define XILINX_DP_TX_CORE_ID 0xfc
74#define XILINX_DP_TX_CORE_ID_MAJOR_MASK (0xff << 24)
75#define XILINX_DP_TX_CORE_ID_MAJOR_SHIFT 24
76#define XILINX_DP_TX_CORE_ID_MINOR_MASK (0xff << 16)
77#define XILINX_DP_TX_CORE_ID_MINOR_SHIFT 16
78#define XILINX_DP_TX_CORE_ID_REVISION_MASK (0xff << 8)
79#define XILINX_DP_TX_CORE_ID_REVISION_SHIFT 8
80#define XILINX_DP_TX_CORE_ID_DIRECTION (1 << 0)
81
82
83#define XILINX_DP_TX_AUX_COMMAND 0x100
84#define XILINX_DP_TX_AUX_COMMAND_CMD_SHIFT 8
85#define XILINX_DP_TX_AUX_COMMAND_ADDRESS_ONLY BIT(12)
86#define XILINX_DP_TX_AUX_COMMAND_BYTES_SHIFT 0
87#define XILINX_DP_TX_AUX_WRITE_FIFO 0x104
88#define XILINX_DP_TX_AUX_ADDRESS 0x108
89#define XILINX_DP_TX_CLK_DIVIDER 0x10c
90#define XILINX_DP_TX_CLK_DIVIDER_MHZ 1000000
91#define XILINX_DP_TX_CLK_DIVIDER_AUX_FILTER_SHIFT 8
92#define XILINX_DP_TX_INTR_SIGNAL_STATE 0x130
93#define XILINX_DP_TX_INTR_SIGNAL_STATE_HPD (1 << 0)
94#define XILINX_DP_TX_INTR_SIGNAL_STATE_REQUEST (1 << 1)
95#define XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY (1 << 2)
96#define XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY_TIMEOUT (1 << 3)
97#define XILINX_DP_TX_AUX_REPLY_DATA 0x134
98#define XILINX_DP_TX_AUX_REPLY_CODE 0x138
99#define XILINX_DP_TX_AUX_REPLY_CODE_AUX_ACK (0)
100#define XILINX_DP_TX_AUX_REPLY_CODE_AUX_NACK (1 << 0)
101#define XILINX_DP_TX_AUX_REPLY_CODE_AUX_DEFER (1 << 1)
102#define XILINX_DP_TX_AUX_REPLY_CODE_I2C_ACK (0)
103#define XILINX_DP_TX_AUX_REPLY_CODE_I2C_NACK (1 << 2)
104#define XILINX_DP_TX_AUX_REPLY_CODE_I2C_DEFER (1 << 3)
105#define XILINX_DP_TX_AUX_REPLY_CNT 0x13c
106#define XILINX_DP_TX_AUX_REPLY_CNT_MASK 0xff
107#define XILINX_DP_TX_INTR_STATUS 0x140
108#define XILINX_DP_TX_INTR_MASK 0x144
109#define XILINX_DP_TX_INTR_HPD_IRQ (1 << 0)
110#define XILINX_DP_TX_INTR_HPD_EVENT (1 << 1)
111#define XILINX_DP_TX_INTR_REPLY_RECV (1 << 2)
112#define XILINX_DP_TX_INTR_REPLY_TIMEOUT (1 << 3)
113#define XILINX_DP_TX_INTR_HPD_PULSE (1 << 4)
114#define XILINX_DP_TX_INTR_EXT_PKT_TXD (1 << 5)
115#define XILINX_DP_TX_INTR_LIV_ABUF_UNDRFLW (1 << 12)
116#define XILINX_DP_TX_INTR_VBLANK_START (1 << 13)
117#define XILINX_DP_TX_INTR_PIXEL0_MATCH (1 << 14)
118#define XILINX_DP_TX_INTR_PIXEL1_MATCH (1 << 15)
119#define XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK 0x3f0000
120#define XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK 0xfc00000
121#define XILINX_DP_TX_INTR_CUST_TS_2 (1 << 28)
122#define XILINX_DP_TX_INTR_CUST_TS (1 << 29)
123#define XILINX_DP_TX_INTR_EXT_VSYNC_TS (1 << 30)
124#define XILINX_DP_TX_INTR_VSYNC_TS (1 << 31)
125#define XILINX_DP_TX_INTR_ALL (XILINX_DP_TX_INTR_HPD_IRQ | \
126 XILINX_DP_TX_INTR_HPD_EVENT | \
127 XILINX_DP_TX_INTR_REPLY_RECV | \
128 XILINX_DP_TX_INTR_REPLY_TIMEOUT | \
129 XILINX_DP_TX_INTR_HPD_PULSE | \
130 XILINX_DP_TX_INTR_EXT_PKT_TXD | \
131 XILINX_DP_TX_INTR_LIV_ABUF_UNDRFLW | \
132 XILINX_DP_TX_INTR_VBLANK_START | \
133 XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK | \
134 XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK)
135#define XILINX_DP_TX_REPLY_DATA_CNT 0x148
136#define XILINX_DP_SUB_TX_INTR_STATUS 0x3a0
137#define XILINX_DP_SUB_TX_INTR_MASK 0x3a4
138#define XILINX_DP_SUB_TX_INTR_EN 0x3a8
139#define XILINX_DP_SUB_TX_INTR_DS 0x3ac
140
141
142#define XILINX_DP_TX_MAIN_STREAM_HTOTAL 0x180
143#define XILINX_DP_TX_MAIN_STREAM_VTOTAL 0x184
144#define XILINX_DP_TX_MAIN_STREAM_POLARITY 0x188
145#define XILINX_DP_TX_MAIN_STREAM_POLARITY_HSYNC_SHIFT 0
146#define XILINX_DP_TX_MAIN_STREAM_POLARITY_VSYNC_SHIFT 1
147#define XILINX_DP_TX_MAIN_STREAM_HSWIDTH 0x18c
148#define XILINX_DP_TX_MAIN_STREAM_VSWIDTH 0x190
149#define XILINX_DP_TX_MAIN_STREAM_HRES 0x194
150#define XILINX_DP_TX_MAIN_STREAM_VRES 0x198
151#define XILINX_DP_TX_MAIN_STREAM_HSTART 0x19c
152#define XILINX_DP_TX_MAIN_STREAM_VSTART 0x1a0
153#define XILINX_DP_TX_MAIN_STREAM_MISC0 0x1a4
154#define XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC (1 << 0)
155#define XILINX_DP_TX_MAIN_STREAM_MISC0_FORMAT_SHIFT 1
156#define XILINX_DP_TX_MAIN_STREAM_MISC0_DYNAMIC_RANGE (1 << 3)
157#define XILINX_DP_TX_MAIN_STREAM_MISC0_YCBCR_COLRIMETRY (1 << 4)
158#define XILINX_DP_TX_MAIN_STREAM_MISC0_BPC_SHIFT 5
159#define XILINX_DP_TX_MAIN_STREAM_MISC1 0x1a8
160#define XILINX_DP_TX_MAIN_STREAM_MISC0_INTERLACED_VERT (1 << 0)
161#define XILINX_DP_TX_MAIN_STREAM_MISC0_STEREO_VID_SHIFT 1
162#define XILINX_DP_TX_M_VID 0x1ac
163#define XILINX_DP_TX_TRANSFER_UNIT_SIZE 0x1b0
164#define XILINX_DP_TX_DEF_TRANSFER_UNIT_SIZE 64
165#define XILINX_DP_TX_N_VID 0x1b4
166#define XILINX_DP_TX_USER_PIXEL_WIDTH 0x1b8
167#define XILINX_DP_TX_USER_DATA_CNT_PER_LANE 0x1bc
168#define XILINX_DP_TX_MIN_BYTES_PER_TU 0x1c4
169#define XILINX_DP_TX_FRAC_BYTES_PER_TU 0x1c8
170#define XILINX_DP_TX_INIT_WAIT 0x1cc
171
172
173#define XILINX_DP_TX_PHY_CONFIG 0x200
174#define XILINX_DP_TX_PHY_CONFIG_PHY_RESET (1 << 0)
175#define XILINX_DP_TX_PHY_CONFIG_GTTX_RESET (1 << 1)
176#define XILINX_DP_TX_PHY_CONFIG_PHY_PMA_RESET (1 << 8)
177#define XILINX_DP_TX_PHY_CONFIG_PHY_PCS_RESET (1 << 9)
178#define XILINX_DP_TX_PHY_CONFIG_ALL_RESET (XILINX_DP_TX_PHY_CONFIG_PHY_RESET | \
179 XILINX_DP_TX_PHY_CONFIG_GTTX_RESET | \
180 XILINX_DP_TX_PHY_CONFIG_PHY_PMA_RESET | \
181 XILINX_DP_TX_PHY_CONFIG_PHY_PCS_RESET)
182#define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_0 0x210
183#define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_1 0x214
184#define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_2 0x218
185#define XILINX_DP_TX_PHY_PREEMPHASIS_LANE_3 0x21c
186#define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_0 0x220
187#define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_1 0x224
188#define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_2 0x228
189#define XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_3 0x22c
190#define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING 0x234
191#define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_162 0x1
192#define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_270 0x3
193#define XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_540 0x5
194#define XILINX_DP_TX_PHY_POWER_DOWN 0x238
195#define XILINX_DP_TX_PHY_POWER_DOWN_LANE_0 (1 << 0)
196#define XILINX_DP_TX_PHY_POWER_DOWN_LANE_1 (1 << 1)
197#define XILINX_DP_TX_PHY_POWER_DOWN_LANE_2 (1 << 2)
198#define XILINX_DP_TX_PHY_POWER_DOWN_LANE_3 (1 << 3)
199#define XILINX_DP_TX_PHY_POWER_DOWN_ALL 0xf
200#define XILINX_DP_TX_PHY_PRECURSOR_LANE_0 0x23c
201#define XILINX_DP_TX_PHY_PRECURSOR_LANE_1 0x240
202#define XILINX_DP_TX_PHY_PRECURSOR_LANE_2 0x244
203#define XILINX_DP_TX_PHY_PRECURSOR_LANE_3 0x248
204#define XILINX_DP_TX_PHY_POSTCURSOR_LANE_0 0x24c
205#define XILINX_DP_TX_PHY_POSTCURSOR_LANE_1 0x250
206#define XILINX_DP_TX_PHY_POSTCURSOR_LANE_2 0x254
207#define XILINX_DP_TX_PHY_POSTCURSOR_LANE_3 0x258
208#define XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_0 0x24c
209#define XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_1 0x250
210#define XILINX_DP_TX_PHY_STATUS 0x280
211#define XILINX_DP_TX_PHY_STATUS_PLL_LOCKED_SHIFT 4
212#define XILINX_DP_TX_PHY_STATUS_FPGA_PLL_LOCKED (1 << 6)
213
214
215#define XILINX_DP_TX_AUDIO_CONTROL 0x300
216#define XILINX_DP_TX_AUDIO_CHANNELS 0x304
217#define XILINX_DP_TX_AUDIO_INFO_DATA 0x308
218#define XILINX_DP_TX_AUDIO_M_AUD 0x328
219#define XILINX_DP_TX_AUDIO_N_AUD 0x32c
220#define XILINX_DP_TX_AUDIO_EXT_DATA 0x330
221
222#define XILINX_DP_MISC0_RGB (0)
223#define XILINX_DP_MISC0_YCRCB_422 (5 << 1)
224#define XILINX_DP_MISC0_YCRCB_444 (6 << 1)
225#define XILINX_DP_MISC0_BPC_6 (0 << 5)
226#define XILINX_DP_MISC0_BPC_8 (1 << 5)
227#define XILINX_DP_MISC0_BPC_10 (2 << 5)
228#define XILINX_DP_MISC0_BPC_12 (3 << 5)
229#define XILINX_DP_MISC0_BPC_16 (4 << 5)
230#define XILINX_DP_MISC1_Y_ONLY (1 << 7)
231
232#define DP_REDUCED_BIT_RATE 162000
233#define DP_HIGH_BIT_RATE 270000
234#define DP_HIGH_BIT_RATE2 540000
235#define DP_MAX_TRAINING_TRIES 5
236#define DP_MAX_LANES 4
237
238enum dp_version {
239 DP_V1_1A = 0x11,
240 DP_V1_2 = 0x12
241};
242
243
244
245
246
247
248struct xilinx_drm_dp_link_config {
249 int max_rate;
250 u8 max_lanes;
251};
252
253
254
255
256
257
258struct xilinx_drm_dp_mode {
259 u8 bw_code;
260 u8 lane_cnt;
261};
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276struct xilinx_drm_dp_config {
277 enum dp_version dp_version;
278 u32 max_lanes;
279 u32 max_link_rate;
280 u32 max_bpc;
281 u32 max_pclock;
282 bool enable_yonly;
283 bool enable_ycrcb;
284
285 u8 misc0;
286 u8 misc1;
287 u8 bpp;
288};
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307struct xilinx_drm_dp {
308 struct drm_encoder *encoder;
309 struct device *dev;
310 void __iomem *iomem;
311
312 struct xilinx_drm_dp_config config;
313 struct drm_dp_aux aux;
314 struct xilinx_drm_dp_sub *dp_sub;
315 struct phy *phy[DP_MAX_LANES];
316 struct clk *aclk;
317 struct clk *aud_clk;
318
319 int dpms;
320 u8 dpcd[DP_RECEIVER_CAP_SIZE];
321 struct xilinx_drm_dp_link_config link_config;
322 struct xilinx_drm_dp_mode mode;
323 u8 train_set[DP_MAX_LANES];
324};
325
326static inline struct xilinx_drm_dp *to_dp(struct drm_encoder *encoder)
327{
328 return to_encoder_slave(encoder)->slave_priv;
329}
330
331#define AUX_READ_BIT 0x1
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355static int xilinx_drm_dp_aux_cmd_submit(struct xilinx_drm_dp *dp, u32 cmd,
356 u16 addr, u8 *buf, u8 bytes, u8 *reply)
357{
358 bool is_read = (cmd & AUX_READ_BIT) ? true : false;
359 void __iomem *iomem = dp->iomem;
360 u32 reg, i;
361
362 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
363 if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REQUEST)
364 return -EBUSY;
365
366 xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_ADDRESS, addr);
367
368 if (!is_read)
369 for (i = 0; i < bytes; i++)
370 xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_WRITE_FIFO,
371 buf[i]);
372
373 reg = cmd << XILINX_DP_TX_AUX_COMMAND_CMD_SHIFT;
374 if (!buf || !bytes)
375 reg |= XILINX_DP_TX_AUX_COMMAND_ADDRESS_ONLY;
376 else
377 reg |= (bytes - 1) << XILINX_DP_TX_AUX_COMMAND_BYTES_SHIFT;
378 xilinx_drm_writel(iomem, XILINX_DP_TX_AUX_COMMAND, reg);
379
380
381 for (i = 0; ; i++) {
382 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
383
384 if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY)
385 break;
386
387 if (reg & XILINX_DP_TX_INTR_SIGNAL_STATE_REPLY_TIMEOUT ||
388 i == 2)
389 return -ETIMEDOUT;
390
391 usleep_range(1000, 1100);
392 }
393
394 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_AUX_REPLY_CODE);
395 if (reply)
396 *reply = reg;
397
398 if (is_read &&
399 (reg == XILINX_DP_TX_AUX_REPLY_CODE_AUX_ACK ||
400 reg == XILINX_DP_TX_AUX_REPLY_CODE_I2C_ACK)) {
401 reg = xilinx_drm_readl(iomem, XILINX_DP_TX_REPLY_DATA_CNT);
402 if ((reg & XILINX_DP_TX_AUX_REPLY_CNT_MASK) != bytes)
403 return -EIO;
404
405 for (i = 0; i < bytes; i++)
406 buf[i] = xilinx_drm_readl(iomem,
407 XILINX_DP_TX_AUX_REPLY_DATA);
408 }
409
410 return 0;
411}
412
413
414
415
416
417
418
419
420
421
422static int xilinx_drm_dp_phy_ready(struct xilinx_drm_dp *dp)
423{
424 u32 i, reg, ready, lane;
425
426 lane = dp->config.max_lanes;
427 ready = (1 << lane) - 1;
428 if (!dp->dp_sub)
429 ready |= XILINX_DP_TX_PHY_STATUS_FPGA_PLL_LOCKED;
430
431
432 for (i = 0; ; i++) {
433 reg = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_PHY_STATUS);
434 if ((reg & ready) == ready)
435 return 0;
436
437 if (i == 100) {
438 DRM_ERROR("PHY isn't ready\n");
439 return -ENODEV;
440 }
441
442 usleep_range(1000, 1100);
443 }
444
445 return 0;
446}
447
448
449
450
451
452
453static void xilinx_drm_dp_adjust_train(struct xilinx_drm_dp *dp,
454 u8 link_status[DP_LINK_STATUS_SIZE])
455{
456 u8 *train_set = dp->train_set;
457 u8 voltage = 0, preemphasis = 0;
458 u8 max_preemphasis;
459 u8 i;
460
461 for (i = 0; i < dp->mode.lane_cnt; i++) {
462 u8 v = drm_dp_get_adjust_request_voltage(link_status, i);
463 u8 p = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
464
465 if (v > voltage)
466 voltage = v;
467
468 if (p > preemphasis)
469 preemphasis = p;
470 }
471
472 if (voltage >= DP_TRAIN_VOLTAGE_SWING_LEVEL_3)
473 voltage |= DP_TRAIN_MAX_SWING_REACHED;
474
475 max_preemphasis = (dp->dp_sub) ? DP_TRAIN_PRE_EMPH_LEVEL_2 :
476 DP_TRAIN_PRE_EMPH_LEVEL_3;
477
478 if (preemphasis >= max_preemphasis)
479 preemphasis |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
480
481 for (i = 0; i < dp->mode.lane_cnt; i++)
482 train_set[i] = voltage | preemphasis;
483}
484
485
486
487
488
489
490
491
492
493
494
495static int xilinx_drm_dp_update_vs_emph(struct xilinx_drm_dp *dp)
496{
497 u8 *train_set = dp->train_set;
498 u8 i, v_level, p_level;
499 int ret;
500 static u8 vs[4][4] = { { 0x2a, 0x27, 0x24, 0x20 },
501 { 0x27, 0x23, 0x20, 0xff },
502 { 0x24, 0x20, 0xff, 0xff },
503 { 0xff, 0xff, 0xff, 0xff } };
504 static u8 pe[4][4] = { { 0x2, 0x2, 0x2, 0x2 },
505 { 0x1, 0x1, 0x1, 0xff },
506 { 0x0, 0x0, 0xff, 0xff },
507 { 0xff, 0xff, 0xff, 0xff } };
508
509 ret = drm_dp_dpcd_write(&dp->aux, DP_TRAINING_LANE0_SET, train_set,
510 dp->mode.lane_cnt);
511 if (ret < 0)
512 return ret;
513
514 for (i = 0; i < dp->mode.lane_cnt; i++) {
515 v_level = (train_set[i] & DP_TRAIN_VOLTAGE_SWING_MASK) >>
516 DP_TRAIN_VOLTAGE_SWING_SHIFT;
517 p_level = (train_set[i] & DP_TRAIN_PRE_EMPHASIS_MASK) >>
518 DP_TRAIN_PRE_EMPHASIS_SHIFT;
519
520 if (dp->phy[i]) {
521 u32 reg = XILINX_DP_SUB_TX_PHY_PRECURSOR_LANE_0 + i * 4;
522
523 xpsgtr_margining_factor(dp->phy[i], p_level, v_level);
524 xpsgtr_override_deemph(dp->phy[i], p_level, v_level);
525 xilinx_drm_writel(dp->iomem, reg, 0x2);
526 } else {
527 u32 reg;
528
529 reg = XILINX_DP_TX_PHY_VOLTAGE_DIFF_LANE_0 + i + 4;
530 xilinx_drm_writel(dp->iomem, reg, vs[p_level][v_level]);
531 reg = XILINX_DP_TX_PHY_PRECURSOR_LANE_0 + i + 4;
532 xilinx_drm_writel(dp->iomem, reg, pe[p_level][v_level]);
533 reg = XILINX_DP_TX_PHY_POSTCURSOR_LANE_0 + i + 4;
534 xilinx_drm_writel(dp->iomem, reg, 0);
535 }
536 }
537
538 return 0;
539}
540
541
542
543
544
545
546
547
548static int xilinx_drm_dp_link_train_cr(struct xilinx_drm_dp *dp)
549{
550 u8 link_status[DP_LINK_STATUS_SIZE];
551 u8 lane_cnt = dp->mode.lane_cnt;
552 u8 vs = 0, tries = 0;
553 u16 max_tries, i;
554 bool cr_done;
555 int ret;
556
557 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
558 DP_TRAINING_PATTERN_1 |
559 DP_LINK_SCRAMBLING_DISABLE);
560 if (ret < 0)
561 return ret;
562
563 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET,
564 DP_TRAINING_PATTERN_1);
565
566
567
568 for (max_tries = 0; max_tries < 512; max_tries++) {
569 ret = xilinx_drm_dp_update_vs_emph(dp);
570 if (ret)
571 return ret;
572
573 drm_dp_link_train_clock_recovery_delay(dp->dpcd);
574
575 ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
576 if (ret < 0)
577 return ret;
578
579 cr_done = drm_dp_clock_recovery_ok(link_status, lane_cnt);
580 if (cr_done)
581 break;
582
583 for (i = 0; i < lane_cnt; i++)
584 if (!(dp->train_set[i] & DP_TRAIN_MAX_SWING_REACHED))
585 break;
586
587 if (i == lane_cnt)
588 break;
589
590 if ((dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == vs)
591 tries++;
592 else
593 tries = 0;
594
595 if (tries == DP_MAX_TRAINING_TRIES)
596 break;
597
598 vs = dp->train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
599
600 xilinx_drm_dp_adjust_train(dp, link_status);
601 }
602
603 if (!cr_done)
604 return -EIO;
605
606 return 0;
607}
608
609
610
611
612
613
614
615
616static int xilinx_drm_dp_link_train_ce(struct xilinx_drm_dp *dp)
617{
618 u8 link_status[DP_LINK_STATUS_SIZE];
619 u8 lane_cnt = dp->mode.lane_cnt;
620 u32 pat, tries;
621 int ret;
622 bool ce_done;
623
624 if (dp->config.dp_version == DP_V1_2 &&
625 dp->dpcd[DP_DPCD_REV] >= DP_V1_2 &&
626 dp->dpcd[DP_MAX_LANE_COUNT] & DP_TPS3_SUPPORTED)
627 pat = DP_TRAINING_PATTERN_3;
628 else
629 pat = DP_TRAINING_PATTERN_2;
630
631 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
632 pat | DP_LINK_SCRAMBLING_DISABLE);
633 if (ret < 0)
634 return ret;
635
636 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET, pat);
637
638 for (tries = 0; tries < DP_MAX_TRAINING_TRIES; tries++) {
639 ret = xilinx_drm_dp_update_vs_emph(dp);
640 if (ret)
641 return ret;
642
643 drm_dp_link_train_channel_eq_delay(dp->dpcd);
644
645 ret = drm_dp_dpcd_read_link_status(&dp->aux, link_status);
646 if (ret < 0)
647 return ret;
648
649 ce_done = drm_dp_channel_eq_ok(link_status, lane_cnt);
650 if (ce_done)
651 break;
652
653 xilinx_drm_dp_adjust_train(dp, link_status);
654 }
655
656 if (!ce_done)
657 return -EIO;
658
659 return 0;
660}
661
662
663
664
665
666
667
668static int xilinx_drm_dp_train(struct xilinx_drm_dp *dp)
669{
670 u32 reg;
671 u8 bw_code = dp->mode.bw_code;
672 u8 lane_cnt = dp->mode.lane_cnt;
673 u8 aux_lane_cnt = lane_cnt;
674 bool enhanced;
675 int ret;
676
677 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_LANE_CNT_SET, lane_cnt);
678
679 enhanced = drm_dp_enhanced_frame_cap(dp->dpcd);
680 if (enhanced) {
681 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENHANCED_FRAME_EN, 1);
682 aux_lane_cnt |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
683 }
684
685 if (dp->dpcd[3] & 0x1) {
686 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_DOWNSPREAD_CTL, 1);
687 drm_dp_dpcd_writeb(&dp->aux, DP_DOWNSPREAD_CTRL,
688 DP_SPREAD_AMP_0_5);
689 } else {
690 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_DOWNSPREAD_CTL, 0);
691 drm_dp_dpcd_writeb(&dp->aux, DP_DOWNSPREAD_CTRL, 0);
692 }
693
694 ret = drm_dp_dpcd_writeb(&dp->aux, DP_LANE_COUNT_SET, aux_lane_cnt);
695 if (ret < 0) {
696 DRM_ERROR("failed to set lane count\n");
697 return ret;
698 }
699
700 ret = drm_dp_dpcd_writeb(&dp->aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
701 DP_SET_ANSI_8B10B);
702 if (ret < 0) {
703 DRM_ERROR("failed to set ANSI 8B/10B encoding\n");
704 return ret;
705 }
706
707 ret = drm_dp_dpcd_writeb(&dp->aux, DP_LINK_BW_SET, bw_code);
708 if (ret < 0) {
709 DRM_ERROR("failed to set DP bandwidth\n");
710 return ret;
711 }
712
713 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_LINK_BW_SET, bw_code);
714
715 switch (bw_code) {
716 case DP_LINK_BW_1_62:
717 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_162;
718 break;
719 case DP_LINK_BW_2_7:
720 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_270;
721 break;
722 case DP_LINK_BW_5_4:
723 default:
724 reg = XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING_540;
725 break;
726 }
727
728 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_CLOCK_FEEDBACK_SETTING,
729 reg);
730 ret = xilinx_drm_dp_phy_ready(dp);
731 if (ret < 0)
732 return ret;
733
734 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SCRAMBLING_DISABLE, 1);
735
736 memset(dp->train_set, 0, 4);
737
738 ret = xilinx_drm_dp_link_train_cr(dp);
739 if (ret)
740 return ret;
741
742 ret = xilinx_drm_dp_link_train_ce(dp);
743 if (ret)
744 return ret;
745
746 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRAINING_PATTERN_SET,
747 DP_TRAINING_PATTERN_DISABLE);
748 ret = drm_dp_dpcd_writeb(&dp->aux, DP_TRAINING_PATTERN_SET,
749 DP_TRAINING_PATTERN_DISABLE);
750 if (ret < 0) {
751 DRM_ERROR("failed to disable training pattern\n");
752 return ret;
753 }
754
755 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SCRAMBLING_DISABLE, 0);
756
757 return 0;
758}
759
760static void xilinx_drm_dp_dpms(struct drm_encoder *encoder, int dpms)
761{
762 struct xilinx_drm_dp *dp = to_dp(encoder);
763 void __iomem *iomem = dp->iomem;
764 unsigned int i;
765 int ret;
766
767 if (dp->dpms == dpms)
768 return;
769
770 dp->dpms = dpms;
771
772 switch (dpms) {
773 case DRM_MODE_DPMS_ON:
774 if (dp->aud_clk)
775 xilinx_drm_writel(iomem, XILINX_DP_TX_AUDIO_CONTROL, 1);
776
777 xilinx_drm_writel(iomem, XILINX_DP_TX_PHY_POWER_DOWN, 0);
778 for (i = 0; i < 3; i++) {
779 ret = drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER,
780 DP_SET_POWER_D0);
781 if (ret == 1)
782 break;
783 usleep_range(300, 500);
784 }
785 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_SW_RESET,
786 XILINX_DP_TX_SW_RESET_ALL);
787 xilinx_drm_writel(iomem, XILINX_DP_TX_ENABLE_MAIN_STREAM, 1);
788
789 return;
790 default:
791 xilinx_drm_writel(iomem, XILINX_DP_TX_ENABLE_MAIN_STREAM, 0);
792 drm_dp_dpcd_writeb(&dp->aux, DP_SET_POWER, DP_SET_POWER_D3);
793 xilinx_drm_writel(iomem, XILINX_DP_TX_PHY_POWER_DOWN,
794 XILINX_DP_TX_PHY_POWER_DOWN_ALL);
795 if (dp->aud_clk)
796 xilinx_drm_writel(iomem, XILINX_DP_TX_AUDIO_CONTROL, 0);
797
798 return;
799 }
800}
801
802static void xilinx_drm_dp_save(struct drm_encoder *encoder)
803{
804
805}
806
807static void xilinx_drm_dp_restore(struct drm_encoder *encoder)
808{
809
810}
811
812#define XILINX_DP_SUB_TX_MIN_H_BACKPORCH 20
813
814static bool xilinx_drm_dp_mode_fixup(struct drm_encoder *encoder,
815 const struct drm_display_mode *mode,
816 struct drm_display_mode *adjusted_mode)
817{
818 struct xilinx_drm_dp *dp = to_dp(encoder);
819 int diff = mode->htotal - mode->hsync_end;
820
821
822
823
824
825 if (dp->dp_sub && diff < XILINX_DP_SUB_TX_MIN_H_BACKPORCH) {
826 int vrefresh = (adjusted_mode->clock * 1000) /
827 (adjusted_mode->vtotal * adjusted_mode->htotal);
828
829 diff = XILINX_DP_SUB_TX_MIN_H_BACKPORCH - diff;
830 adjusted_mode->htotal += diff;
831 adjusted_mode->clock = adjusted_mode->vtotal *
832 adjusted_mode->htotal * vrefresh / 1000;
833 }
834
835 return true;
836}
837
838
839
840
841
842
843
844
845
846static inline int xilinx_drm_dp_max_rate(int link_rate, u8 lane_num, u8 bpp)
847{
848 return link_rate * lane_num * 8 / bpp;
849}
850
851static int xilinx_drm_dp_mode_valid(struct drm_encoder *encoder,
852 struct drm_display_mode *mode)
853{
854 struct xilinx_drm_dp *dp = to_dp(encoder);
855 u8 max_lanes = dp->link_config.max_lanes;
856 u8 bpp = dp->config.bpp;
857 u32 max_pclock = dp->config.max_pclock;
858 int max_rate = dp->link_config.max_rate;
859 int rate;
860
861 if (max_pclock && mode->clock > max_pclock)
862 return MODE_CLOCK_HIGH;
863
864 rate = xilinx_drm_dp_max_rate(max_rate, max_lanes, bpp);
865 if (mode->clock > rate)
866 return MODE_CLOCK_HIGH;
867
868 return MODE_OK;
869}
870
871
872
873
874
875
876
877
878
879static void xilinx_drm_dp_mode_set_transfer_unit(struct xilinx_drm_dp *dp,
880 struct drm_display_mode *mode)
881{
882 u32 tu = XILINX_DP_TX_DEF_TRANSFER_UNIT_SIZE;
883 u32 bw, vid_kbytes, avg_bytes_per_tu, init_wait;
884
885
886 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_TRANSFER_UNIT_SIZE, tu);
887
888 vid_kbytes = mode->clock * (dp->config.bpp / 8);
889 bw = drm_dp_bw_code_to_link_rate(dp->mode.bw_code);
890 avg_bytes_per_tu = vid_kbytes * tu / (dp->mode.lane_cnt * bw / 1000);
891
892 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MIN_BYTES_PER_TU,
893 avg_bytes_per_tu / 1000);
894 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_FRAC_BYTES_PER_TU,
895 avg_bytes_per_tu % 1000);
896
897
898 if (tu < (avg_bytes_per_tu / 1000))
899 init_wait = 0;
900 else if ((avg_bytes_per_tu / 1000) <= 4)
901 init_wait = tu;
902 else
903 init_wait = tu - avg_bytes_per_tu / 1000;
904
905 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INIT_WAIT, init_wait);
906}
907
908
909
910
911
912
913
914
915
916static void xilinx_drm_dp_mode_set_stream(struct xilinx_drm_dp *dp,
917 struct drm_display_mode *mode)
918{
919 u8 lane_cnt = dp->mode.lane_cnt;
920 u32 reg, wpl;
921
922 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HTOTAL,
923 mode->htotal);
924 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VTOTAL,
925 mode->vtotal);
926
927 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_POLARITY,
928 (!!(mode->flags & DRM_MODE_FLAG_PVSYNC) <<
929 XILINX_DP_TX_MAIN_STREAM_POLARITY_VSYNC_SHIFT) |
930 (!!(mode->flags & DRM_MODE_FLAG_PHSYNC) <<
931 XILINX_DP_TX_MAIN_STREAM_POLARITY_HSYNC_SHIFT));
932
933 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HSWIDTH,
934 mode->hsync_end - mode->hsync_start);
935 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VSWIDTH,
936 mode->vsync_end - mode->vsync_start);
937
938 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HRES,
939 mode->hdisplay);
940 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VRES,
941 mode->vdisplay);
942
943 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_HSTART,
944 mode->htotal - mode->hsync_start);
945 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_VSTART,
946 mode->vtotal - mode->vsync_start);
947
948 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC0,
949 dp->config.misc0);
950 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_MAIN_STREAM_MISC1,
951 dp->config.misc1);
952
953
954 if (dp->config.misc0 & XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC) {
955 reg = drm_dp_bw_code_to_link_rate(dp->mode.bw_code);
956 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_N_VID, reg);
957 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_M_VID, mode->clock);
958 if (dp->aud_clk) {
959 int aud_rate = clk_get_rate(dp->aud_clk) / 512;
960
961 if (aud_rate != 44100 && aud_rate != 48000)
962 dev_dbg(dp->dev, "Audio rate: %d\n", aud_rate);
963
964 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_N_AUD,
965 reg);
966 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_M_AUD,
967 aud_rate);
968 }
969 }
970
971
972 if (dp->aud_clk)
973 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_AUDIO_CHANNELS, 1);
974
975 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_USER_PIXEL_WIDTH, 1);
976
977
978 wpl = (mode->hdisplay * dp->config.bpp + 15) / 16;
979 reg = wpl + wpl % lane_cnt - lane_cnt;
980 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_USER_DATA_CNT_PER_LANE, reg);
981}
982
983
984
985
986
987
988
989
990
991
992
993
994static int xilinx_drm_dp_mode_configure(struct xilinx_drm_dp *dp, int pclock,
995 u8 current_bw)
996{
997 int max_rate = dp->link_config.max_rate;
998 u8 bws[3] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7, DP_LINK_BW_5_4 };
999 u8 max_lanes = dp->link_config.max_lanes;
1000 u8 max_link_rate_code = drm_dp_link_rate_to_bw_code(max_rate);
1001 u8 bpp = dp->config.bpp;
1002 u8 lane_cnt;
1003 s8 clock, i;
1004
1005 for (i = ARRAY_SIZE(bws) - 1; i >= 0; i--) {
1006 if (current_bw && bws[i] >= current_bw)
1007 continue;
1008
1009 if (bws[i] <= max_link_rate_code)
1010 break;
1011 }
1012
1013 for (lane_cnt = 1; lane_cnt <= max_lanes; lane_cnt <<= 1)
1014 for (clock = i; clock >= 0; clock--) {
1015 int bw;
1016 u32 rate;
1017
1018 bw = drm_dp_bw_code_to_link_rate(bws[clock]);
1019 rate = xilinx_drm_dp_max_rate(bw, lane_cnt, bpp);
1020 if (pclock <= rate) {
1021 dp->mode.bw_code = bws[clock];
1022 dp->mode.lane_cnt = lane_cnt;
1023 return bws[clock];
1024 }
1025 }
1026
1027 DRM_ERROR("failed to configure link values\n");
1028
1029 return -EINVAL;
1030}
1031
1032static void xilinx_drm_dp_mode_set(struct drm_encoder *encoder,
1033 struct drm_display_mode *mode,
1034 struct drm_display_mode *adjusted_mode)
1035{
1036 struct xilinx_drm_dp *dp = to_dp(encoder);
1037 int bw = 0;
1038 unsigned int ret;
1039
1040 do {
1041 bw = xilinx_drm_dp_mode_configure(dp, adjusted_mode->clock, bw);
1042 if (bw < 0)
1043 return;
1044
1045 xilinx_drm_dp_mode_set_stream(dp, adjusted_mode);
1046 xilinx_drm_dp_mode_set_transfer_unit(dp, adjusted_mode);
1047
1048 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN, 0);
1049 ret = xilinx_drm_dp_train(dp);
1050 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN,
1051 XILINX_DP_TX_PHY_POWER_DOWN_ALL);
1052 if (!ret)
1053 return;
1054 } while (bw >= DP_LINK_BW_1_62);
1055
1056 DRM_ERROR("failed to train the DP link\n");
1057}
1058
1059static enum drm_connector_status
1060xilinx_drm_dp_detect(struct drm_encoder *encoder,
1061 struct drm_connector *connector)
1062{
1063 struct xilinx_drm_dp *dp = to_dp(encoder);
1064 struct xilinx_drm_dp_link_config *link_config = &dp->link_config;
1065 u32 state;
1066 int ret;
1067
1068 state = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_INTR_SIGNAL_STATE);
1069 if (state & XILINX_DP_TX_INTR_SIGNAL_STATE_HPD) {
1070 ret = drm_dp_dpcd_read(&dp->aux, 0x0, dp->dpcd,
1071 sizeof(dp->dpcd));
1072 if (ret < 0)
1073 return connector_status_disconnected;
1074
1075 link_config->max_rate = min_t(int,
1076 drm_dp_max_link_rate(dp->dpcd),
1077 dp->config.max_link_rate);
1078 link_config->max_lanes = min_t(u8,
1079 drm_dp_max_lane_count(dp->dpcd),
1080 dp->config.max_lanes);
1081
1082 return connector_status_connected;
1083 }
1084
1085 return connector_status_disconnected;
1086}
1087
1088static int xilinx_drm_dp_get_modes(struct drm_encoder *encoder,
1089 struct drm_connector *connector)
1090{
1091 struct xilinx_drm_dp *dp = to_dp(encoder);
1092 struct edid *edid;
1093 int ret;
1094
1095 edid = drm_get_edid(connector, &dp->aux.ddc);
1096 if (!edid)
1097 return 0;
1098
1099 drm_mode_connector_update_edid_property(connector, edid);
1100 ret = drm_add_edid_modes(connector, edid);
1101
1102 kfree(edid);
1103
1104 return ret;
1105}
1106
1107static struct drm_encoder_slave_funcs xilinx_drm_dp_encoder_funcs = {
1108 .dpms = xilinx_drm_dp_dpms,
1109 .save = xilinx_drm_dp_save,
1110 .restore = xilinx_drm_dp_restore,
1111 .mode_fixup = xilinx_drm_dp_mode_fixup,
1112 .mode_valid = xilinx_drm_dp_mode_valid,
1113 .mode_set = xilinx_drm_dp_mode_set,
1114 .detect = xilinx_drm_dp_detect,
1115 .get_modes = xilinx_drm_dp_get_modes,
1116};
1117
1118static int xilinx_drm_dp_encoder_init(struct platform_device *pdev,
1119 struct drm_device *dev,
1120 struct drm_encoder_slave *encoder)
1121{
1122 struct xilinx_drm_dp *dp = platform_get_drvdata(pdev);
1123 int clock_rate;
1124 u32 reg, w;
1125
1126 encoder->slave_priv = dp;
1127 encoder->slave_funcs = &xilinx_drm_dp_encoder_funcs;
1128
1129 dp->encoder = &encoder->base;
1130
1131
1132 clock_rate = clk_get_rate(dp->aclk);
1133 if (clock_rate < XILINX_DP_TX_CLK_DIVIDER_MHZ) {
1134 DRM_ERROR("aclk should be higher than 1MHz\n");
1135 return -EINVAL;
1136 }
1137
1138
1139 for (w = 8; w <= 48; w += 8) {
1140
1141 if (w >= (4 * clock_rate / 10000000) &&
1142 w <= (6 * clock_rate / 10000000))
1143 break;
1144 }
1145
1146 if (w > 48) {
1147 DRM_ERROR("aclk frequency too high\n");
1148 return -EINVAL;
1149 }
1150 reg = w << XILINX_DP_TX_CLK_DIVIDER_AUX_FILTER_SHIFT;
1151
1152 reg |= clock_rate / XILINX_DP_TX_CLK_DIVIDER_MHZ;
1153 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_CLK_DIVIDER, reg);
1154
1155 if (dp->dp_sub)
1156 xilinx_drm_writel(dp->iomem, XILINX_DP_SUB_TX_INTR_EN,
1157 XILINX_DP_TX_INTR_ALL);
1158 else
1159 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INTR_MASK,
1160 ~XILINX_DP_TX_INTR_ALL);
1161 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 1);
1162
1163 return 0;
1164}
1165
1166static irqreturn_t xilinx_drm_dp_irq_handler(int irq, void *data)
1167{
1168 struct xilinx_drm_dp *dp = (struct xilinx_drm_dp *)data;
1169 u32 reg, status;
1170
1171 reg = dp->dp_sub ?
1172 XILINX_DP_SUB_TX_INTR_STATUS : XILINX_DP_TX_INTR_STATUS;
1173 status = xilinx_drm_readl(dp->iomem, reg);
1174 if (!status)
1175 return IRQ_NONE;
1176
1177 if (status & XILINX_DP_TX_INTR_CHBUF_UNDERFLW_MASK)
1178 dev_dbg(dp->dev, "underflow interrupt\n");
1179 if (status & XILINX_DP_TX_INTR_CHBUF_OVERFLW_MASK)
1180 dev_dbg(dp->dev, "overflow interrupt\n");
1181
1182 xilinx_drm_writel(dp->iomem, reg, status);
1183
1184 if (status & XILINX_DP_TX_INTR_VBLANK_START)
1185 xilinx_drm_dp_sub_handle_vblank(dp->dp_sub);
1186
1187 if (status & XILINX_DP_TX_INTR_HPD_EVENT)
1188 drm_helper_hpd_irq_event(dp->encoder->dev);
1189
1190 if (status & XILINX_DP_TX_INTR_HPD_IRQ) {
1191 u8 status[DP_LINK_STATUS_SIZE + 2];
1192
1193 drm_dp_dpcd_read(&dp->aux, DP_SINK_COUNT, status,
1194 DP_LINK_STATUS_SIZE + 2);
1195
1196 if (status[4] & DP_LINK_STATUS_UPDATED ||
1197 !drm_dp_clock_recovery_ok(&status[2], dp->mode.lane_cnt) ||
1198 !drm_dp_channel_eq_ok(&status[2], dp->mode.lane_cnt))
1199 xilinx_drm_dp_train(dp);
1200 }
1201
1202 return IRQ_HANDLED;
1203}
1204
1205static ssize_t
1206xilinx_drm_dp_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
1207{
1208 struct xilinx_drm_dp *dp = container_of(aux, struct xilinx_drm_dp, aux);
1209 int ret;
1210
1211 ret = xilinx_drm_dp_aux_cmd_submit(dp, msg->request, msg->address,
1212 msg->buffer, msg->size, &msg->reply);
1213 if (ret < 0)
1214 return ret;
1215
1216 return msg->size;
1217}
1218
1219static int xilinx_drm_dp_parse_of(struct xilinx_drm_dp *dp)
1220{
1221 struct device_node *node = dp->dev->of_node;
1222 struct xilinx_drm_dp_config *config = &dp->config;
1223 const char *string;
1224 u32 num_colors, bpc;
1225 bool sync;
1226 int ret;
1227
1228 ret = of_property_read_string(node, "xlnx,dp-version", &string);
1229 if (ret < 0) {
1230 dev_err(dp->dev, "No DP version in DT\n");
1231 return ret;
1232 }
1233
1234 if (strcmp(string, "v1.1a") == 0) {
1235 config->dp_version = DP_V1_1A;
1236 } else if (strcmp(string, "v1.2") == 0) {
1237 config->dp_version = DP_V1_2;
1238 } else {
1239 dev_err(dp->dev, "Invalid DP version in DT\n");
1240 return -EINVAL;
1241 }
1242
1243 ret = of_property_read_u32(node, "xlnx,max-lanes", &config->max_lanes);
1244 if (ret < 0) {
1245 dev_err(dp->dev, "No lane count in DT\n");
1246 return ret;
1247 }
1248
1249 if (config->max_lanes != 1 && config->max_lanes != 2 &&
1250 config->max_lanes != 4) {
1251 dev_err(dp->dev, "Invalid max lanes in DT\n");
1252 return -EINVAL;
1253 }
1254
1255 ret = of_property_read_u32(node, "xlnx,max-link-rate",
1256 &config->max_link_rate);
1257 if (ret < 0) {
1258 dev_err(dp->dev, "No link rate in DT\n");
1259 return ret;
1260 }
1261
1262 if (config->max_link_rate != DP_REDUCED_BIT_RATE &&
1263 config->max_link_rate != DP_HIGH_BIT_RATE &&
1264 config->max_link_rate != DP_HIGH_BIT_RATE2) {
1265 dev_err(dp->dev, "Invalid link rate in DT\n");
1266 return -EINVAL;
1267 }
1268
1269 config->enable_yonly = of_property_read_bool(node, "xlnx,enable-yonly");
1270 config->enable_ycrcb = of_property_read_bool(node, "xlnx,enable-ycrcb");
1271
1272 sync = of_property_read_bool(node, "xlnx,sync");
1273 if (sync)
1274 config->misc0 |= XILINX_DP_TX_MAIN_STREAM_MISC0_SYNC;
1275
1276 ret = of_property_read_string(node, "xlnx,colormetry", &string);
1277 if (ret < 0) {
1278 dev_err(dp->dev, "No colormetry in DT\n");
1279 return ret;
1280 }
1281
1282 if (strcmp(string, "rgb") == 0) {
1283 config->misc0 |= XILINX_DP_MISC0_RGB;
1284 num_colors = 3;
1285 } else if (config->enable_ycrcb && strcmp(string, "ycrcb422") == 0) {
1286 config->misc0 |= XILINX_DP_MISC0_YCRCB_422;
1287 num_colors = 2;
1288 } else if (config->enable_ycrcb && strcmp(string, "ycrcb444") == 0) {
1289 config->misc0 |= XILINX_DP_MISC0_YCRCB_444;
1290 num_colors = 3;
1291 } else if (config->enable_yonly && strcmp(string, "yonly") == 0) {
1292 config->misc1 |= XILINX_DP_MISC1_Y_ONLY;
1293 num_colors = 1;
1294 } else {
1295 dev_err(dp->dev, "Invalid colormetry in DT\n");
1296 return -EINVAL;
1297 }
1298
1299 ret = of_property_read_u32(node, "xlnx,max-bpc", &config->max_bpc);
1300 if (ret < 0) {
1301 dev_err(dp->dev, "No max bpc in DT\n");
1302 return ret;
1303 }
1304
1305 if (config->max_bpc != 8 && config->max_bpc != 10 &&
1306 config->max_bpc != 12 && config->max_bpc != 16) {
1307 dev_err(dp->dev, "Invalid max bpc in DT\n");
1308 return -EINVAL;
1309 }
1310
1311 ret = of_property_read_u32(node, "xlnx,bpc", &bpc);
1312 if (ret < 0) {
1313 dev_err(dp->dev, "No color depth(bpc) in DT\n");
1314 return ret;
1315 }
1316
1317 if (bpc > config->max_bpc) {
1318 dev_err(dp->dev, "Invalid color depth(bpc) in DT\n");
1319 return -EINVAL;
1320 }
1321
1322 switch (bpc) {
1323 case 6:
1324 config->misc0 |= XILINX_DP_MISC0_BPC_6;
1325 break;
1326 case 8:
1327 config->misc0 |= XILINX_DP_MISC0_BPC_8;
1328 break;
1329 case 10:
1330 config->misc0 |= XILINX_DP_MISC0_BPC_10;
1331 break;
1332 case 12:
1333 config->misc0 |= XILINX_DP_MISC0_BPC_12;
1334 break;
1335 case 16:
1336 config->misc0 |= XILINX_DP_MISC0_BPC_16;
1337 break;
1338 default:
1339 dev_err(dp->dev, "Not supported color depth in DT\n");
1340 return -EINVAL;
1341 }
1342
1343 config->bpp = num_colors * bpc;
1344
1345 of_property_read_u32(node, "xlnx,max-pclock-frequency",
1346 &config->max_pclock);
1347
1348 return 0;
1349}
1350
1351static int xilinx_drm_dp_probe(struct platform_device *pdev)
1352{
1353 struct xilinx_drm_dp *dp;
1354 struct resource *res;
1355 u32 version, i;
1356 int irq, ret;
1357
1358 dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
1359 if (!dp)
1360 return -ENOMEM;
1361
1362 dp->dpms = DRM_MODE_DPMS_OFF;
1363 dp->dev = &pdev->dev;
1364
1365 ret = xilinx_drm_dp_parse_of(dp);
1366 if (ret < 0)
1367 return ret;
1368
1369 dp->aclk = devm_clk_get(dp->dev, "aclk");
1370 if (IS_ERR(dp->aclk))
1371 return PTR_ERR(dp->aclk);
1372
1373 ret = clk_prepare_enable(dp->aclk);
1374 if (ret) {
1375 dev_err(dp->dev, "failed to enable the aclk\n");
1376 return ret;
1377 }
1378
1379 dp->aud_clk = devm_clk_get(dp->dev, "aud_clk");
1380 if (IS_ERR(dp->aud_clk)) {
1381 ret = PTR_ERR(dp->aud_clk);
1382 if (ret == -EPROBE_DEFER)
1383 goto error_aclk;
1384 dp->aud_clk = NULL;
1385 dev_dbg(dp->dev, "failed to get the aud_clk:\n");
1386 } else {
1387 ret = clk_prepare_enable(dp->aud_clk);
1388 if (ret) {
1389 dev_err(dp->dev, "failed to enable aud_clk\n");
1390 goto error_aclk;
1391 }
1392 }
1393
1394 dp->dp_sub = xilinx_drm_dp_sub_of_get(pdev->dev.of_node);
1395 if (IS_ERR(dp->dp_sub)) {
1396 ret = PTR_ERR(dp->dp_sub);
1397 goto error_aud_clk;
1398 }
1399
1400 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1401 dp->iomem = devm_ioremap_resource(dp->dev, res);
1402 if (IS_ERR(dp->iomem)) {
1403 ret = PTR_ERR(dp->iomem);
1404 goto error_dp_sub;
1405 }
1406
1407 platform_set_drvdata(pdev, dp);
1408
1409 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN,
1410 XILINX_DP_TX_PHY_POWER_DOWN_ALL);
1411 xilinx_drm_set(dp->iomem, XILINX_DP_TX_PHY_CONFIG,
1412 XILINX_DP_TX_PHY_CONFIG_ALL_RESET);
1413 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_FORCE_SCRAMBLER_RESET, 1);
1414 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 0);
1415
1416 if (dp->dp_sub) {
1417 for (i = 0; i < dp->config.max_lanes; i++) {
1418 char phy_name[16];
1419
1420 snprintf(phy_name, sizeof(phy_name), "dp-phy%d", i);
1421 dp->phy[i] = devm_phy_get(dp->dev, phy_name);
1422 if (IS_ERR(dp->phy[i])) {
1423 dev_err(dp->dev, "failed to get phy lane\n");
1424 ret = PTR_ERR(dp->phy[i]);
1425 dp->phy[i] = NULL;
1426 goto error_dp_sub;
1427 }
1428
1429 ret = phy_init(dp->phy[i]);
1430 if (ret) {
1431 dev_err(dp->dev,
1432 "failed to init phy lane %d\n", i);
1433 goto error_dp_sub;
1434 }
1435 }
1436
1437 xilinx_drm_writel(dp->iomem, XILINX_DP_SUB_TX_INTR_DS,
1438 XILINX_DP_TX_INTR_ALL);
1439 xilinx_drm_clr(dp->iomem, XILINX_DP_TX_PHY_CONFIG,
1440 XILINX_DP_TX_PHY_CONFIG_ALL_RESET);
1441 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN, 0);
1442
1443
1444 if (dp->phy[0]) {
1445 ret = xpsgtr_wait_pll_lock(dp->phy[0]);
1446 if (ret) {
1447 dev_err(dp->dev, "failed to lock pll\n");
1448 goto error_dp_sub;
1449 }
1450 }
1451 } else {
1452 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_INTR_MASK,
1453 XILINX_DP_TX_INTR_ALL);
1454 xilinx_drm_clr(dp->iomem, XILINX_DP_TX_PHY_CONFIG,
1455 XILINX_DP_TX_PHY_CONFIG_ALL_RESET);
1456 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_PHY_POWER_DOWN, 0);
1457 }
1458
1459 dp->aux.name = "Xilinx DP AUX";
1460 dp->aux.dev = dp->dev;
1461 dp->aux.transfer = xilinx_drm_dp_aux_transfer;
1462 ret = drm_dp_aux_register(&dp->aux);
1463 if (ret < 0) {
1464 dev_err(dp->dev, "failed to initialize DP aux\n");
1465 return ret;
1466 }
1467
1468 irq = platform_get_irq(pdev, 0);
1469 if (irq < 0) {
1470 ret = irq;
1471 goto error;
1472 }
1473
1474 ret = devm_request_threaded_irq(dp->dev, irq, NULL,
1475 xilinx_drm_dp_irq_handler, IRQF_ONESHOT,
1476 dev_name(dp->dev), dp);
1477 if (ret < 0)
1478 goto error;
1479
1480 version = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_VERSION);
1481
1482 dev_info(dp->dev, "device found, version %u.%02x%x\n",
1483 ((version & XILINX_DP_TX_VERSION_MAJOR_MASK) >>
1484 XILINX_DP_TX_VERSION_MAJOR_SHIFT),
1485 ((version & XILINX_DP_TX_VERSION_MINOR_MASK) >>
1486 XILINX_DP_TX_VERSION_MINOR_SHIFT),
1487 ((version & XILINX_DP_TX_VERSION_REVISION_MASK) >>
1488 XILINX_DP_TX_VERSION_REVISION_SHIFT));
1489
1490 version = xilinx_drm_readl(dp->iomem, XILINX_DP_TX_CORE_ID);
1491 if (version & XILINX_DP_TX_CORE_ID_DIRECTION) {
1492 dev_err(dp->dev, "Receiver is not supported\n");
1493 ret = -ENODEV;
1494 goto error;
1495 }
1496
1497 dev_info(dp->dev, "Display Port, version %u.%02x%02x (tx)\n",
1498 ((version & XILINX_DP_TX_CORE_ID_MAJOR_MASK) >>
1499 XILINX_DP_TX_CORE_ID_MAJOR_SHIFT),
1500 ((version & XILINX_DP_TX_CORE_ID_MINOR_MASK) >>
1501 XILINX_DP_TX_CORE_ID_MINOR_SHIFT),
1502 ((version & XILINX_DP_TX_CORE_ID_REVISION_MASK) >>
1503 XILINX_DP_TX_CORE_ID_REVISION_SHIFT));
1504
1505 return 0;
1506
1507error:
1508 drm_dp_aux_unregister(&dp->aux);
1509error_dp_sub:
1510 if (dp->dp_sub) {
1511 for (i = 0; i < dp->config.max_lanes; i++) {
1512 if (dp->phy[i]) {
1513 phy_exit(dp->phy[i]);
1514 dp->phy[i] = NULL;
1515 }
1516 }
1517 }
1518 xilinx_drm_dp_sub_put(dp->dp_sub);
1519error_aud_clk:
1520 if (dp->aud_clk)
1521 clk_disable_unprepare(dp->aud_clk);
1522error_aclk:
1523 clk_disable_unprepare(dp->aclk);
1524 return ret;
1525}
1526
1527static int xilinx_drm_dp_remove(struct platform_device *pdev)
1528{
1529 struct xilinx_drm_dp *dp = platform_get_drvdata(pdev);
1530 unsigned int i;
1531
1532 xilinx_drm_writel(dp->iomem, XILINX_DP_TX_ENABLE, 0);
1533
1534 drm_dp_aux_unregister(&dp->aux);
1535
1536 if (dp->dp_sub) {
1537 for (i = 0; i < dp->config.max_lanes; i++) {
1538 if (dp->phy[i]) {
1539 phy_exit(dp->phy[i]);
1540 dp->phy[i] = NULL;
1541 }
1542 }
1543 }
1544
1545 xilinx_drm_dp_sub_put(dp->dp_sub);
1546
1547 if (dp->aud_clk)
1548 clk_disable_unprepare(dp->aud_clk);
1549 clk_disable_unprepare(dp->aclk);
1550
1551 return 0;
1552}
1553
1554static const struct of_device_id xilinx_drm_dp_of_match[] = {
1555 { .compatible = "xlnx,v-dp", },
1556 { },
1557};
1558MODULE_DEVICE_TABLE(of, xilinx_drm_dp_of_match);
1559
1560static struct drm_platform_encoder_driver xilinx_drm_dp_driver = {
1561 .platform_driver = {
1562 .probe = xilinx_drm_dp_probe,
1563 .remove = xilinx_drm_dp_remove,
1564 .driver = {
1565 .owner = THIS_MODULE,
1566 .name = "xilinx-drm-dp",
1567 .of_match_table = xilinx_drm_dp_of_match,
1568 },
1569 },
1570
1571 .encoder_init = xilinx_drm_dp_encoder_init,
1572};
1573
1574static int __init xilinx_drm_dp_init(void)
1575{
1576 return platform_driver_register(&xilinx_drm_dp_driver.platform_driver);
1577}
1578
1579static void __exit xilinx_drm_dp_exit(void)
1580{
1581 platform_driver_unregister(&xilinx_drm_dp_driver.platform_driver);
1582}
1583
1584module_init(xilinx_drm_dp_init);
1585module_exit(xilinx_drm_dp_exit);
1586
1587MODULE_AUTHOR("Xilinx, Inc.");
1588MODULE_DESCRIPTION("Xilinx DRM KMS DiplayPort Driver");
1589MODULE_LICENSE("GPL v2");
1590