This source file includes following definitions.
- cdn_dp_set_fw_clk
- cdn_dp_clock_reset
- cdn_dp_mailbox_read
- cdp_dp_mailbox_write
- cdn_dp_mailbox_validate_receive
- cdn_dp_mailbox_read_receive
- cdn_dp_mailbox_send
- cdn_dp_reg_write
- cdn_dp_reg_write_bit
- cdn_dp_dpcd_read
- cdn_dp_dpcd_write
- cdn_dp_load_firmware
- cdn_dp_set_firmware_active
- cdn_dp_set_host_cap
- cdn_dp_event_config
- cdn_dp_get_event
- cdn_dp_get_hpd_status
- cdn_dp_get_edid_block
- cdn_dp_training_start
- cdn_dp_get_training_status
- cdn_dp_train_link
- cdn_dp_set_video_status
- cdn_dp_get_msa_misc
- cdn_dp_config_video
- cdn_dp_audio_stop
- cdn_dp_audio_mute
- cdn_dp_audio_config_i2s
- cdn_dp_audio_config_spdif
- cdn_dp_audio_config
1
2
3
4
5
6
7 #include <linux/clk.h>
8 #include <linux/device.h>
9 #include <linux/delay.h>
10 #include <linux/io.h>
11 #include <linux/iopoll.h>
12 #include <linux/reset.h>
13
14 #include "cdn-dp-core.h"
15 #include "cdn-dp-reg.h"
16
17 #define CDN_DP_SPDIF_CLK 200000000
18 #define FW_ALIVE_TIMEOUT_US 1000000
19 #define MAILBOX_RETRY_US 1000
20 #define MAILBOX_TIMEOUT_US 5000000
21 #define LINK_TRAINING_RETRY_MS 20
22 #define LINK_TRAINING_TIMEOUT_MS 500
23
24 void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, unsigned long clk)
25 {
26 writel(clk / 1000000, dp->regs + SW_CLK_H);
27 }
28
29 void cdn_dp_clock_reset(struct cdn_dp_device *dp)
30 {
31 u32 val;
32
33 val = DPTX_FRMR_DATA_CLK_RSTN_EN |
34 DPTX_FRMR_DATA_CLK_EN |
35 DPTX_PHY_DATA_RSTN_EN |
36 DPTX_PHY_DATA_CLK_EN |
37 DPTX_PHY_CHAR_RSTN_EN |
38 DPTX_PHY_CHAR_CLK_EN |
39 SOURCE_AUX_SYS_CLK_RSTN_EN |
40 SOURCE_AUX_SYS_CLK_EN |
41 DPTX_SYS_CLK_RSTN_EN |
42 DPTX_SYS_CLK_EN |
43 CFG_DPTX_VIF_CLK_RSTN_EN |
44 CFG_DPTX_VIF_CLK_EN;
45 writel(val, dp->regs + SOURCE_DPTX_CAR);
46
47 val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN;
48 writel(val, dp->regs + SOURCE_PHY_CAR);
49
50 val = SOURCE_PKT_SYS_RSTN_EN |
51 SOURCE_PKT_SYS_CLK_EN |
52 SOURCE_PKT_DATA_RSTN_EN |
53 SOURCE_PKT_DATA_CLK_EN;
54 writel(val, dp->regs + SOURCE_PKT_CAR);
55
56 val = SPDIF_CDR_CLK_RSTN_EN |
57 SPDIF_CDR_CLK_EN |
58 SOURCE_AIF_SYS_RSTN_EN |
59 SOURCE_AIF_SYS_CLK_EN |
60 SOURCE_AIF_CLK_RSTN_EN |
61 SOURCE_AIF_CLK_EN;
62 writel(val, dp->regs + SOURCE_AIF_CAR);
63
64 val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN |
65 SOURCE_CIPHER_SYS_CLK_EN |
66 SOURCE_CIPHER_CHAR_CLK_RSTN_EN |
67 SOURCE_CIPHER_CHAR_CLK_EN;
68 writel(val, dp->regs + SOURCE_CIPHER_CAR);
69
70 val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN |
71 SOURCE_CRYPTO_SYS_CLK_EN;
72 writel(val, dp->regs + SOURCE_CRYPTO_CAR);
73
74
75 writel(0, dp->regs + APB_INT_MASK);
76 }
77
78 static int cdn_dp_mailbox_read(struct cdn_dp_device *dp)
79 {
80 int val, ret;
81
82 ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR,
83 val, !val, MAILBOX_RETRY_US,
84 MAILBOX_TIMEOUT_US);
85 if (ret < 0)
86 return ret;
87
88 return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff;
89 }
90
91 static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val)
92 {
93 int ret, full;
94
95 ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR,
96 full, !full, MAILBOX_RETRY_US,
97 MAILBOX_TIMEOUT_US);
98 if (ret < 0)
99 return ret;
100
101 writel(val, dp->regs + MAILBOX0_WR_DATA);
102
103 return 0;
104 }
105
106 static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp,
107 u8 module_id, u8 opcode,
108 u16 req_size)
109 {
110 u32 mbox_size, i;
111 u8 header[4];
112 int ret;
113
114
115 for (i = 0; i < 4; i++) {
116 ret = cdn_dp_mailbox_read(dp);
117 if (ret < 0)
118 return ret;
119
120 header[i] = ret;
121 }
122
123 mbox_size = (header[2] << 8) | header[3];
124
125 if (opcode != header[0] || module_id != header[1] ||
126 req_size != mbox_size) {
127
128
129
130
131 for (i = 0; i < mbox_size; i++)
132 if (cdn_dp_mailbox_read(dp) < 0)
133 break;
134
135 return -EINVAL;
136 }
137
138 return 0;
139 }
140
141 static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp,
142 u8 *buff, u16 buff_size)
143 {
144 u32 i;
145 int ret;
146
147 for (i = 0; i < buff_size; i++) {
148 ret = cdn_dp_mailbox_read(dp);
149 if (ret < 0)
150 return ret;
151
152 buff[i] = ret;
153 }
154
155 return 0;
156 }
157
158 static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id,
159 u8 opcode, u16 size, u8 *message)
160 {
161 u8 header[4];
162 int ret, i;
163
164 header[0] = opcode;
165 header[1] = module_id;
166 header[2] = (size >> 8) & 0xff;
167 header[3] = size & 0xff;
168
169 for (i = 0; i < 4; i++) {
170 ret = cdp_dp_mailbox_write(dp, header[i]);
171 if (ret)
172 return ret;
173 }
174
175 for (i = 0; i < size; i++) {
176 ret = cdp_dp_mailbox_write(dp, message[i]);
177 if (ret)
178 return ret;
179 }
180
181 return 0;
182 }
183
184 static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val)
185 {
186 u8 msg[6];
187
188 msg[0] = (addr >> 8) & 0xff;
189 msg[1] = addr & 0xff;
190 msg[2] = (val >> 24) & 0xff;
191 msg[3] = (val >> 16) & 0xff;
192 msg[4] = (val >> 8) & 0xff;
193 msg[5] = val & 0xff;
194 return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER,
195 sizeof(msg), msg);
196 }
197
198 static int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr,
199 u8 start_bit, u8 bits_no, u32 val)
200 {
201 u8 field[8];
202
203 field[0] = (addr >> 8) & 0xff;
204 field[1] = addr & 0xff;
205 field[2] = start_bit;
206 field[3] = bits_no;
207 field[4] = (val >> 24) & 0xff;
208 field[5] = (val >> 16) & 0xff;
209 field[6] = (val >> 8) & 0xff;
210 field[7] = val & 0xff;
211
212 return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD,
213 sizeof(field), field);
214 }
215
216 int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len)
217 {
218 u8 msg[5], reg[5];
219 int ret;
220
221 msg[0] = (len >> 8) & 0xff;
222 msg[1] = len & 0xff;
223 msg[2] = (addr >> 16) & 0xff;
224 msg[3] = (addr >> 8) & 0xff;
225 msg[4] = addr & 0xff;
226 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD,
227 sizeof(msg), msg);
228 if (ret)
229 goto err_dpcd_read;
230
231 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
232 DPTX_READ_DPCD,
233 sizeof(reg) + len);
234 if (ret)
235 goto err_dpcd_read;
236
237 ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
238 if (ret)
239 goto err_dpcd_read;
240
241 ret = cdn_dp_mailbox_read_receive(dp, data, len);
242
243 err_dpcd_read:
244 return ret;
245 }
246
247 int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value)
248 {
249 u8 msg[6], reg[5];
250 int ret;
251
252 msg[0] = 0;
253 msg[1] = 1;
254 msg[2] = (addr >> 16) & 0xff;
255 msg[3] = (addr >> 8) & 0xff;
256 msg[4] = addr & 0xff;
257 msg[5] = value;
258 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD,
259 sizeof(msg), msg);
260 if (ret)
261 goto err_dpcd_write;
262
263 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
264 DPTX_WRITE_DPCD, sizeof(reg));
265 if (ret)
266 goto err_dpcd_write;
267
268 ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
269 if (ret)
270 goto err_dpcd_write;
271
272 if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4]))
273 ret = -EINVAL;
274
275 err_dpcd_write:
276 if (ret)
277 DRM_DEV_ERROR(dp->dev, "dpcd write failed: %d\n", ret);
278 return ret;
279 }
280
281 int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem,
282 u32 i_size, const u32 *d_mem, u32 d_size)
283 {
284 u32 reg;
285 int i, ret;
286
287
288 writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET,
289 dp->regs + APB_CTRL);
290
291 for (i = 0; i < i_size; i += 4)
292 writel(*i_mem++, dp->regs + ADDR_IMEM + i);
293
294 for (i = 0; i < d_size; i += 4)
295 writel(*d_mem++, dp->regs + ADDR_DMEM + i);
296
297
298 writel(0, dp->regs + APB_CTRL);
299
300
301 ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE,
302 reg, reg, 2000, FW_ALIVE_TIMEOUT_US);
303 if (ret < 0) {
304 DRM_DEV_ERROR(dp->dev, "failed to loaded the FW reg = %x\n",
305 reg);
306 return -EINVAL;
307 }
308
309 reg = readl(dp->regs + VER_L) & 0xff;
310 dp->fw_version = reg;
311 reg = readl(dp->regs + VER_H) & 0xff;
312 dp->fw_version |= reg << 8;
313 reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff;
314 dp->fw_version |= reg << 16;
315 reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff;
316 dp->fw_version |= reg << 24;
317
318 DRM_DEV_DEBUG(dp->dev, "firmware version: %x\n", dp->fw_version);
319
320 return 0;
321 }
322
323 int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable)
324 {
325 u8 msg[5];
326 int ret, i;
327
328 msg[0] = GENERAL_MAIN_CONTROL;
329 msg[1] = MB_MODULE_ID_GENERAL;
330 msg[2] = 0;
331 msg[3] = 1;
332 msg[4] = enable ? FW_ACTIVE : FW_STANDBY;
333
334 for (i = 0; i < sizeof(msg); i++) {
335 ret = cdp_dp_mailbox_write(dp, msg[i]);
336 if (ret)
337 goto err_set_firmware_active;
338 }
339
340
341 for (i = 0; i < sizeof(msg); i++) {
342 ret = cdn_dp_mailbox_read(dp);
343 if (ret < 0)
344 goto err_set_firmware_active;
345
346 msg[i] = ret;
347 }
348
349 ret = 0;
350
351 err_set_firmware_active:
352 if (ret < 0)
353 DRM_DEV_ERROR(dp->dev, "set firmware active failed\n");
354 return ret;
355 }
356
357 int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip)
358 {
359 u8 msg[8];
360 int ret;
361
362 msg[0] = CDN_DP_MAX_LINK_RATE;
363 msg[1] = lanes | SCRAMBLER_EN;
364 msg[2] = VOLTAGE_LEVEL_2;
365 msg[3] = PRE_EMPHASIS_LEVEL_3;
366 msg[4] = PTS1 | PTS2 | PTS3 | PTS4;
367 msg[5] = FAST_LT_NOT_SUPPORT;
368 msg[6] = flip ? LANE_MAPPING_FLIPPED : LANE_MAPPING_NORMAL;
369 msg[7] = ENHANCED;
370
371 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
372 DPTX_SET_HOST_CAPABILITIES,
373 sizeof(msg), msg);
374 if (ret)
375 goto err_set_host_cap;
376
377 ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL,
378 AUX_HOST_INVERT);
379
380 err_set_host_cap:
381 if (ret)
382 DRM_DEV_ERROR(dp->dev, "set host cap failed: %d\n", ret);
383 return ret;
384 }
385
386 int cdn_dp_event_config(struct cdn_dp_device *dp)
387 {
388 u8 msg[5];
389 int ret;
390
391 memset(msg, 0, sizeof(msg));
392
393 msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING;
394
395 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT,
396 sizeof(msg), msg);
397 if (ret)
398 DRM_DEV_ERROR(dp->dev, "set event config failed: %d\n", ret);
399
400 return ret;
401 }
402
403 u32 cdn_dp_get_event(struct cdn_dp_device *dp)
404 {
405 return readl(dp->regs + SW_EVENTS0);
406 }
407
408 int cdn_dp_get_hpd_status(struct cdn_dp_device *dp)
409 {
410 u8 status;
411 int ret;
412
413 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE,
414 0, NULL);
415 if (ret)
416 goto err_get_hpd;
417
418 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
419 DPTX_HPD_STATE, sizeof(status));
420 if (ret)
421 goto err_get_hpd;
422
423 ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status));
424 if (ret)
425 goto err_get_hpd;
426
427 return status;
428
429 err_get_hpd:
430 DRM_DEV_ERROR(dp->dev, "get hpd status failed: %d\n", ret);
431 return ret;
432 }
433
434 int cdn_dp_get_edid_block(void *data, u8 *edid,
435 unsigned int block, size_t length)
436 {
437 struct cdn_dp_device *dp = data;
438 u8 msg[2], reg[2], i;
439 int ret;
440
441 for (i = 0; i < 4; i++) {
442 msg[0] = block / 2;
443 msg[1] = block % 2;
444
445 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID,
446 sizeof(msg), msg);
447 if (ret)
448 continue;
449
450 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
451 DPTX_GET_EDID,
452 sizeof(reg) + length);
453 if (ret)
454 continue;
455
456 ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
457 if (ret)
458 continue;
459
460 ret = cdn_dp_mailbox_read_receive(dp, edid, length);
461 if (ret)
462 continue;
463
464 if (reg[0] == length && reg[1] == block / 2)
465 break;
466 }
467
468 if (ret)
469 DRM_DEV_ERROR(dp->dev, "get block[%d] edid failed: %d\n", block,
470 ret);
471
472 return ret;
473 }
474
475 static int cdn_dp_training_start(struct cdn_dp_device *dp)
476 {
477 unsigned long timeout;
478 u8 msg, event[2];
479 int ret;
480
481 msg = LINK_TRAINING_RUN;
482
483
484 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL,
485 sizeof(msg), &msg);
486 if (ret)
487 goto err_training_start;
488
489 timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS);
490 while (time_before(jiffies, timeout)) {
491 msleep(LINK_TRAINING_RETRY_MS);
492 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
493 DPTX_READ_EVENT, 0, NULL);
494 if (ret)
495 goto err_training_start;
496
497 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
498 DPTX_READ_EVENT,
499 sizeof(event));
500 if (ret)
501 goto err_training_start;
502
503 ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event));
504 if (ret)
505 goto err_training_start;
506
507 if (event[1] & EQ_PHASE_FINISHED)
508 return 0;
509 }
510
511 ret = -ETIMEDOUT;
512
513 err_training_start:
514 DRM_DEV_ERROR(dp->dev, "training failed: %d\n", ret);
515 return ret;
516 }
517
518 static int cdn_dp_get_training_status(struct cdn_dp_device *dp)
519 {
520 u8 status[10];
521 int ret;
522
523 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT,
524 0, NULL);
525 if (ret)
526 goto err_get_training_status;
527
528 ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
529 DPTX_READ_LINK_STAT,
530 sizeof(status));
531 if (ret)
532 goto err_get_training_status;
533
534 ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status));
535 if (ret)
536 goto err_get_training_status;
537
538 dp->link.rate = drm_dp_bw_code_to_link_rate(status[0]);
539 dp->link.num_lanes = status[1];
540
541 err_get_training_status:
542 if (ret)
543 DRM_DEV_ERROR(dp->dev, "get training status failed: %d\n", ret);
544 return ret;
545 }
546
547 int cdn_dp_train_link(struct cdn_dp_device *dp)
548 {
549 int ret;
550
551 ret = cdn_dp_training_start(dp);
552 if (ret) {
553 DRM_DEV_ERROR(dp->dev, "Failed to start training %d\n", ret);
554 return ret;
555 }
556
557 ret = cdn_dp_get_training_status(dp);
558 if (ret) {
559 DRM_DEV_ERROR(dp->dev, "Failed to get training stat %d\n", ret);
560 return ret;
561 }
562
563 DRM_DEV_DEBUG_KMS(dp->dev, "rate:0x%x, lanes:%d\n", dp->link.rate,
564 dp->link.num_lanes);
565 return ret;
566 }
567
568 int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active)
569 {
570 u8 msg;
571 int ret;
572
573 msg = !!active;
574
575 ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO,
576 sizeof(msg), &msg);
577 if (ret)
578 DRM_DEV_ERROR(dp->dev, "set video status failed: %d\n", ret);
579
580 return ret;
581 }
582
583 static int cdn_dp_get_msa_misc(struct video_info *video,
584 struct drm_display_mode *mode)
585 {
586 u32 msa_misc;
587 u8 val[2] = {0};
588
589 switch (video->color_fmt) {
590 case PXL_RGB:
591 case Y_ONLY:
592 val[0] = 0;
593 break;
594
595 case YCBCR_4_4_4:
596 val[0] = 6 + BT_601 * 8;
597 break;
598 case YCBCR_4_2_2:
599 val[0] = 5 + BT_601 * 8;
600 break;
601 case YCBCR_4_2_0:
602 val[0] = 5;
603 break;
604 };
605
606 switch (video->color_depth) {
607 case 6:
608 val[1] = 0;
609 break;
610 case 8:
611 val[1] = 1;
612 break;
613 case 10:
614 val[1] = 2;
615 break;
616 case 12:
617 val[1] = 3;
618 break;
619 case 16:
620 val[1] = 4;
621 break;
622 };
623
624 msa_misc = 2 * val[0] + 32 * val[1] +
625 ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0);
626
627 return msa_misc;
628 }
629
630 int cdn_dp_config_video(struct cdn_dp_device *dp)
631 {
632 struct video_info *video = &dp->video_info;
633 struct drm_display_mode *mode = &dp->mode;
634 u64 symbol;
635 u32 val, link_rate, rem;
636 u8 bit_per_pix, tu_size_reg = TU_SIZE;
637 int ret;
638
639 bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ?
640 (video->color_depth * 2) : (video->color_depth * 3);
641
642 link_rate = dp->link.rate / 1000;
643
644 ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, VIF_BYPASS_INTERLACE);
645 if (ret)
646 goto err_config_video;
647
648 ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0);
649 if (ret)
650 goto err_config_video;
651
652
653
654
655
656
657
658
659 do {
660 tu_size_reg += 2;
661 symbol = tu_size_reg * mode->clock * bit_per_pix;
662 do_div(symbol, dp->link.num_lanes * link_rate * 8);
663 rem = do_div(symbol, 1000);
664 if (tu_size_reg > 64) {
665 ret = -EINVAL;
666 DRM_DEV_ERROR(dp->dev,
667 "tu error, clk:%d, lanes:%d, rate:%d\n",
668 mode->clock, dp->link.num_lanes,
669 link_rate);
670 goto err_config_video;
671 }
672 } while ((symbol <= 1) || (tu_size_reg - symbol < 4) ||
673 (rem > 850) || (rem < 100));
674
675 val = symbol + (tu_size_reg << 8);
676 val |= TU_CNT_RST_EN;
677 ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val);
678 if (ret)
679 goto err_config_video;
680
681
682 val = div_u64(mode->clock * (symbol + 1), 1000) + link_rate;
683 val /= (dp->link.num_lanes * link_rate);
684 val = div_u64(8 * (symbol + 1), bit_per_pix) - val;
685 val += 2;
686 ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val);
687
688 switch (video->color_depth) {
689 case 6:
690 val = BCS_6;
691 break;
692 case 8:
693 val = BCS_8;
694 break;
695 case 10:
696 val = BCS_10;
697 break;
698 case 12:
699 val = BCS_12;
700 break;
701 case 16:
702 val = BCS_16;
703 break;
704 };
705
706 val += video->color_fmt << 8;
707 ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val);
708 if (ret)
709 goto err_config_video;
710
711 val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0;
712 val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0;
713 ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val);
714 if (ret)
715 goto err_config_video;
716
717 val = (mode->hsync_start - mode->hdisplay) << 16;
718 val |= mode->htotal - mode->hsync_end;
719 ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val);
720 if (ret)
721 goto err_config_video;
722
723 val = mode->hdisplay * bit_per_pix / 8;
724 ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val);
725 if (ret)
726 goto err_config_video;
727
728 val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16);
729 ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val);
730 if (ret)
731 goto err_config_video;
732
733 val = mode->hsync_end - mode->hsync_start;
734 val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15);
735 ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val);
736 if (ret)
737 goto err_config_video;
738
739 val = mode->vtotal;
740 val |= (mode->vtotal - mode->vsync_start) << 16;
741 ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val);
742 if (ret)
743 goto err_config_video;
744
745 val = mode->vsync_end - mode->vsync_start;
746 val |= (mode->vdisplay << 16) | (video->v_sync_polarity << 15);
747 ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val);
748 if (ret)
749 goto err_config_video;
750
751 val = cdn_dp_get_msa_misc(video, mode);
752 ret = cdn_dp_reg_write(dp, MSA_MISC, val);
753 if (ret)
754 goto err_config_video;
755
756 ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1);
757 if (ret)
758 goto err_config_video;
759
760 val = mode->hsync_end - mode->hsync_start;
761 val |= mode->hdisplay << 16;
762 ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val);
763 if (ret)
764 goto err_config_video;
765
766 val = mode->vdisplay;
767 val |= (mode->vtotal - mode->vsync_start) << 16;
768 ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val);
769 if (ret)
770 goto err_config_video;
771
772 val = mode->vtotal;
773 ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val);
774 if (ret)
775 goto err_config_video;
776
777 ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, 0);
778
779 err_config_video:
780 if (ret)
781 DRM_DEV_ERROR(dp->dev, "config video failed: %d\n", ret);
782 return ret;
783 }
784
785 int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio)
786 {
787 int ret;
788
789 ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0);
790 if (ret) {
791 DRM_DEV_ERROR(dp->dev, "audio stop failed: %d\n", ret);
792 return ret;
793 }
794
795 writel(0, dp->regs + SPDIF_CTRL_ADDR);
796
797
798 writel(0, dp->regs + AUDIO_SRC_CNTL);
799 writel(0, dp->regs + AUDIO_SRC_CNFG);
800 writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL);
801 writel(0, dp->regs + AUDIO_SRC_CNTL);
802
803
804 writel(0, dp->regs + SMPL2PKT_CNTL);
805 writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL);
806 writel(0, dp->regs + SMPL2PKT_CNTL);
807
808
809 writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL);
810 writel(0, dp->regs + FIFO_CNTL);
811
812 if (audio->format == AFMT_SPDIF)
813 clk_disable_unprepare(dp->spdif_clk);
814
815 return 0;
816 }
817
818 int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable)
819 {
820 int ret;
821
822 ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable);
823 if (ret)
824 DRM_DEV_ERROR(dp->dev, "audio mute failed: %d\n", ret);
825
826 return ret;
827 }
828
829 static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp,
830 struct audio_info *audio)
831 {
832 int sub_pckt_num = 1, i2s_port_en_val = 0xf, i;
833 u32 val;
834
835 if (audio->channels == 2) {
836 if (dp->link.num_lanes == 1)
837 sub_pckt_num = 2;
838 else
839 sub_pckt_num = 4;
840
841 i2s_port_en_val = 1;
842 } else if (audio->channels == 4) {
843 i2s_port_en_val = 3;
844 }
845
846 writel(0x0, dp->regs + SPDIF_CTRL_ADDR);
847
848 writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
849
850 val = MAX_NUM_CH(audio->channels);
851 val |= NUM_OF_I2S_PORTS(audio->channels);
852 val |= AUDIO_TYPE_LPCM;
853 val |= CFG_SUB_PCKT_NUM(sub_pckt_num);
854 writel(val, dp->regs + SMPL2PKT_CNFG);
855
856 if (audio->sample_width == 16)
857 val = 0;
858 else if (audio->sample_width == 24)
859 val = 1 << 9;
860 else
861 val = 2 << 9;
862
863 val |= AUDIO_CH_NUM(audio->channels);
864 val |= I2S_DEC_PORT_EN(i2s_port_en_val);
865 val |= TRANS_SMPL_WIDTH_32;
866 writel(val, dp->regs + AUDIO_SRC_CNFG);
867
868 for (i = 0; i < (audio->channels + 1) / 2; i++) {
869 if (audio->sample_width == 16)
870 val = (0x02 << 8) | (0x02 << 20);
871 else if (audio->sample_width == 24)
872 val = (0x0b << 8) | (0x0b << 20);
873
874 val |= ((2 * i) << 4) | ((2 * i + 1) << 16);
875 writel(val, dp->regs + STTS_BIT_CH(i));
876 }
877
878 switch (audio->sample_rate) {
879 case 32000:
880 val = SAMPLING_FREQ(3) |
881 ORIGINAL_SAMP_FREQ(0xc);
882 break;
883 case 44100:
884 val = SAMPLING_FREQ(0) |
885 ORIGINAL_SAMP_FREQ(0xf);
886 break;
887 case 48000:
888 val = SAMPLING_FREQ(2) |
889 ORIGINAL_SAMP_FREQ(0xd);
890 break;
891 case 88200:
892 val = SAMPLING_FREQ(8) |
893 ORIGINAL_SAMP_FREQ(0x7);
894 break;
895 case 96000:
896 val = SAMPLING_FREQ(0xa) |
897 ORIGINAL_SAMP_FREQ(5);
898 break;
899 case 176400:
900 val = SAMPLING_FREQ(0xc) |
901 ORIGINAL_SAMP_FREQ(3);
902 break;
903 case 192000:
904 val = SAMPLING_FREQ(0xe) |
905 ORIGINAL_SAMP_FREQ(1);
906 break;
907 }
908 val |= 4;
909 writel(val, dp->regs + COM_CH_STTS_BITS);
910
911 writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
912 writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL);
913 }
914
915 static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp)
916 {
917 u32 val;
918
919 writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
920
921 val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4);
922 writel(val, dp->regs + SMPL2PKT_CNFG);
923 writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
924
925 val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS;
926 writel(val, dp->regs + SPDIF_CTRL_ADDR);
927
928 clk_prepare_enable(dp->spdif_clk);
929 clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK);
930 }
931
932 int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio)
933 {
934 int ret;
935
936
937 if (audio->format == AFMT_SPDIF) {
938 reset_control_assert(dp->spdif_rst);
939 reset_control_deassert(dp->spdif_rst);
940 }
941
942 ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC);
943 if (ret)
944 goto err_audio_config;
945
946 ret = cdn_dp_reg_write(dp, CM_CTRL, 0);
947 if (ret)
948 goto err_audio_config;
949
950 if (audio->format == AFMT_I2S)
951 cdn_dp_audio_config_i2s(dp, audio);
952 else if (audio->format == AFMT_SPDIF)
953 cdn_dp_audio_config_spdif(dp);
954
955 ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN);
956
957 err_audio_config:
958 if (ret)
959 DRM_DEV_ERROR(dp->dev, "audio config failed: %d\n", ret);
960 return ret;
961 }