?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of 'remove_new' relic from platform driver struct
[linux.git] / drivers / gpu / drm / bridge / cadence / cdns-mhdp8546-core.c
blobd081850e3c03e982812f64bb62ae922a1828cc7e
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Cadence MHDP8546 DP bridge driver.
4 *
5 * Copyright (C) 2020 Cadence Design Systems, Inc.
6 *
7 * Authors: Quentin Schulz <quentin.schulz@free-electrons.com>
8 * Swapnil Jakhade <sjakhade@cadence.com>
9 * Yuti Amonkar <yamonkar@cadence.com>
10 * Tomi Valkeinen <tomi.valkeinen@ti.com>
11 * Jyri Sarha <jsarha@ti.com>
12 *
13 * TODO:
14 * - Implement optimized mailbox communication using mailbox interrupts
15 * - Add support for power management
16 * - Add support for features like audio, MST and fast link training
17 * - Implement request_fw_cancel to handle HW_STATE
18 * - Fix asynchronous loading of firmware implementation
19 * - Add DRM helper function for cdns_mhdp_lower_link_rate
20 */
21
22 #include <linux/clk.h>
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/firmware.h>
26 #include <linux/io.h>
27 #include <linux/iopoll.h>
28 #include <linux/irq.h>
29 #include <linux/media-bus-format.h>
30 #include <linux/module.h>
31 #include <linux/of.h>
32 #include <linux/phy/phy.h>
33 #include <linux/phy/phy-dp.h>
34 #include <linux/platform_device.h>
35 #include <linux/slab.h>
36 #include <linux/wait.h>
37
38 #include <drm/display/drm_dp_helper.h>
39 #include <drm/display/drm_hdcp_helper.h>
40 #include <drm/drm_atomic.h>
41 #include <drm/drm_atomic_helper.h>
42 #include <drm/drm_atomic_state_helper.h>
43 #include <drm/drm_bridge.h>
44 #include <drm/drm_connector.h>
45 #include <drm/drm_edid.h>
46 #include <drm/drm_modeset_helper_vtables.h>
47 #include <drm/drm_print.h>
48 #include <drm/drm_probe_helper.h>
49
50 #include <linux/unaligned.h>
51
52 #include "cdns-mhdp8546-core.h"
53 #include "cdns-mhdp8546-hdcp.h"
54 #include "cdns-mhdp8546-j721e.h"
55
56 static void cdns_mhdp_bridge_hpd_enable(struct drm_bridge *bridge)
57 {
58 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
59
60 /* Enable SW event interrupts */
61 if (mhdp->bridge_attached)
62 writel(readl(mhdp->regs + CDNS_APB_INT_MASK) &
63 ~CDNS_APB_INT_MASK_SW_EVENT_INT,
64 mhdp->regs + CDNS_APB_INT_MASK);
65 }
66
67 static void cdns_mhdp_bridge_hpd_disable(struct drm_bridge *bridge)
68 {
69 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
70
71 writel(readl(mhdp->regs + CDNS_APB_INT_MASK) |
72 CDNS_APB_INT_MASK_SW_EVENT_INT,
73 mhdp->regs + CDNS_APB_INT_MASK);
74 }
75
76 static int cdns_mhdp_mailbox_read(struct cdns_mhdp_device *mhdp)
77 {
78 int ret, empty;
79
80 WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
81
82 ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_EMPTY,
83 empty, !empty, MAILBOX_RETRY_US,
84 MAILBOX_TIMEOUT_US);
85 if (ret < 0)
86 return ret;
87
88 return readl(mhdp->regs + CDNS_MAILBOX_RX_DATA) & 0xff;
89 }
90
91 static int cdns_mhdp_mailbox_write(struct cdns_mhdp_device *mhdp, u8 val)
92 {
93 int ret, full;
94
95 WARN_ON(!mutex_is_locked(&mhdp->mbox_mutex));
96
97 ret = readx_poll_timeout(readl, mhdp->regs + CDNS_MAILBOX_FULL,
98 full, !full, MAILBOX_RETRY_US,
99 MAILBOX_TIMEOUT_US);
100 if (ret < 0)
101 return ret;
102
103 writel(val, mhdp->regs + CDNS_MAILBOX_TX_DATA);
104
105 return 0;
106 }
107
108 static int cdns_mhdp_mailbox_recv_header(struct cdns_mhdp_device *mhdp,
109 u8 module_id, u8 opcode,
110 u16 req_size)
111 {
112 u32 mbox_size, i;
113 u8 header[4];
114 int ret;
115
116 /* read the header of the message */
117 for (i = 0; i < sizeof(header); i++) {
118 ret = cdns_mhdp_mailbox_read(mhdp);
119 if (ret < 0)
120 return ret;
121
122 header[i] = ret;
123 }
124
125 mbox_size = get_unaligned_be16(header + 2);
126
127 if (opcode != header[0] || module_id != header[1] ||
128 req_size != mbox_size) {
129 /*
130 * If the message in mailbox is not what we want, we need to
131 * clear the mailbox by reading its contents.
132 */
133 for (i = 0; i < mbox_size; i++)
134 if (cdns_mhdp_mailbox_read(mhdp) < 0)
135 break;
136
137 return -EINVAL;
138 }
139
140 return 0;
141 }
142
143 static int cdns_mhdp_mailbox_recv_data(struct cdns_mhdp_device *mhdp,
144 u8 *buff, u16 buff_size)
145 {
146 u32 i;
147 int ret;
148
149 for (i = 0; i < buff_size; i++) {
150 ret = cdns_mhdp_mailbox_read(mhdp);
151 if (ret < 0)
152 return ret;
153
154 buff[i] = ret;
155 }
156
157 return 0;
158 }
159
160 static int cdns_mhdp_mailbox_send(struct cdns_mhdp_device *mhdp, u8 module_id,
161 u8 opcode, u16 size, u8 *message)
162 {
163 u8 header[4];
164 int ret, i;
165
166 header[0] = opcode;
167 header[1] = module_id;
168 put_unaligned_be16(size, header + 2);
169
170 for (i = 0; i < sizeof(header); i++) {
171 ret = cdns_mhdp_mailbox_write(mhdp, header[i]);
172 if (ret)
173 return ret;
174 }
175
176 for (i = 0; i < size; i++) {
177 ret = cdns_mhdp_mailbox_write(mhdp, message[i]);
178 if (ret)
179 return ret;
180 }
181
182 return 0;
183 }
184
185 static
186 int cdns_mhdp_reg_read(struct cdns_mhdp_device *mhdp, u32 addr, u32 *value)
187 {
188 u8 msg[4], resp[8];
189 int ret;
190
191 put_unaligned_be32(addr, msg);
192
193 mutex_lock(&mhdp->mbox_mutex);
194
195 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_GENERAL,
196 GENERAL_REGISTER_READ,
197 sizeof(msg), msg);
198 if (ret)
199 goto out;
200
201 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_GENERAL,
202 GENERAL_REGISTER_READ,
203 sizeof(resp));
204 if (ret)
205 goto out;
206
207 ret = cdns_mhdp_mailbox_recv_data(mhdp, resp, sizeof(resp));
208 if (ret)
209 goto out;
210
211 /* Returned address value should be the same as requested */
212 if (memcmp(msg, resp, sizeof(msg))) {
213 ret = -EINVAL;
214 goto out;
215 }
216
217 *value = get_unaligned_be32(resp + 4);
218
219 out:
220 mutex_unlock(&mhdp->mbox_mutex);
221 if (ret) {
222 dev_err(mhdp->dev, "Failed to read register\n");
223 *value = 0;
224 }
225
226 return ret;
227 }
228
229 static
230 int cdns_mhdp_reg_write(struct cdns_mhdp_device *mhdp, u16 addr, u32 val)
231 {
232 u8 msg[6];
233 int ret;
234
235 put_unaligned_be16(addr, msg);
236 put_unaligned_be32(val, msg + 2);
237
238 mutex_lock(&mhdp->mbox_mutex);
239
240 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
241 DPTX_WRITE_REGISTER, sizeof(msg), msg);
242
243 mutex_unlock(&mhdp->mbox_mutex);
244
245 return ret;
246 }
247
248 static
249 int cdns_mhdp_reg_write_bit(struct cdns_mhdp_device *mhdp, u16 addr,
250 u8 start_bit, u8 bits_no, u32 val)
251 {
252 u8 field[8];
253 int ret;
254
255 put_unaligned_be16(addr, field);
256 field[2] = start_bit;
257 field[3] = bits_no;
258 put_unaligned_be32(val, field + 4);
259
260 mutex_lock(&mhdp->mbox_mutex);
261
262 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
263 DPTX_WRITE_FIELD, sizeof(field), field);
264
265 mutex_unlock(&mhdp->mbox_mutex);
266
267 return ret;
268 }
269
270 static
271 int cdns_mhdp_dpcd_read(struct cdns_mhdp_device *mhdp,
272 u32 addr, u8 *data, u16 len)
273 {
274 u8 msg[5], reg[5];
275 int ret;
276
277 put_unaligned_be16(len, msg);
278 put_unaligned_be24(addr, msg + 2);
279
280 mutex_lock(&mhdp->mbox_mutex);
281
282 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
283 DPTX_READ_DPCD, sizeof(msg), msg);
284 if (ret)
285 goto out;
286
287 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
288 DPTX_READ_DPCD,
289 sizeof(reg) + len);
290 if (ret)
291 goto out;
292
293 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
294 if (ret)
295 goto out;
296
297 ret = cdns_mhdp_mailbox_recv_data(mhdp, data, len);
298
299 out:
300 mutex_unlock(&mhdp->mbox_mutex);
301
302 return ret;
303 }
304
305 static
306 int cdns_mhdp_dpcd_write(struct cdns_mhdp_device *mhdp, u32 addr, u8 value)
307 {
308 u8 msg[6], reg[5];
309 int ret;
310
311 put_unaligned_be16(1, msg);
312 put_unaligned_be24(addr, msg + 2);
313 msg[5] = value;
314
315 mutex_lock(&mhdp->mbox_mutex);
316
317 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
318 DPTX_WRITE_DPCD, sizeof(msg), msg);
319 if (ret)
320 goto out;
321
322 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
323 DPTX_WRITE_DPCD, sizeof(reg));
324 if (ret)
325 goto out;
326
327 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
328 if (ret)
329 goto out;
330
331 if (addr != get_unaligned_be24(reg + 2))
332 ret = -EINVAL;
333
334 out:
335 mutex_unlock(&mhdp->mbox_mutex);
336
337 if (ret)
338 dev_err(mhdp->dev, "dpcd write failed: %d\n", ret);
339 return ret;
340 }
341
342 static
343 int cdns_mhdp_set_firmware_active(struct cdns_mhdp_device *mhdp, bool enable)
344 {
345 u8 msg[5];
346 int ret, i;
347
348 msg[0] = GENERAL_MAIN_CONTROL;
349 msg[1] = MB_MODULE_ID_GENERAL;
350 msg[2] = 0;
351 msg[3] = 1;
352 msg[4] = enable ? FW_ACTIVE : FW_STANDBY;
353
354 mutex_lock(&mhdp->mbox_mutex);
355
356 for (i = 0; i < sizeof(msg); i++) {
357 ret = cdns_mhdp_mailbox_write(mhdp, msg[i]);
358 if (ret)
359 goto out;
360 }
361
362 /* read the firmware state */
363 ret = cdns_mhdp_mailbox_recv_data(mhdp, msg, sizeof(msg));
364 if (ret)
365 goto out;
366
367 ret = 0;
368
369 out:
370 mutex_unlock(&mhdp->mbox_mutex);
371
372 if (ret < 0)
373 dev_err(mhdp->dev, "set firmware active failed\n");
374 return ret;
375 }
376
377 static
378 int cdns_mhdp_get_hpd_status(struct cdns_mhdp_device *mhdp)
379 {
380 u8 status;
381 int ret;
382
383 mutex_lock(&mhdp->mbox_mutex);
384
385 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
386 DPTX_HPD_STATE, 0, NULL);
387 if (ret)
388 goto err_get_hpd;
389
390 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
391 DPTX_HPD_STATE,
392 sizeof(status));
393 if (ret)
394 goto err_get_hpd;
395
396 ret = cdns_mhdp_mailbox_recv_data(mhdp, &status, sizeof(status));
397 if (ret)
398 goto err_get_hpd;
399
400 mutex_unlock(&mhdp->mbox_mutex);
401
402 dev_dbg(mhdp->dev, "%s: HPD %splugged\n", __func__,
403 status ? "" : "un");
404
405 return status;
406
407 err_get_hpd:
408 mutex_unlock(&mhdp->mbox_mutex);
409
410 return ret;
411 }
412
413 static
414 int cdns_mhdp_get_edid_block(void *data, u8 *edid,
415 unsigned int block, size_t length)
416 {
417 struct cdns_mhdp_device *mhdp = data;
418 u8 msg[2], reg[2], i;
419 int ret;
420
421 mutex_lock(&mhdp->mbox_mutex);
422
423 for (i = 0; i < 4; i++) {
424 msg[0] = block / 2;
425 msg[1] = block % 2;
426
427 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
428 DPTX_GET_EDID, sizeof(msg), msg);
429 if (ret)
430 continue;
431
432 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
433 DPTX_GET_EDID,
434 sizeof(reg) + length);
435 if (ret)
436 continue;
437
438 ret = cdns_mhdp_mailbox_recv_data(mhdp, reg, sizeof(reg));
439 if (ret)
440 continue;
441
442 ret = cdns_mhdp_mailbox_recv_data(mhdp, edid, length);
443 if (ret)
444 continue;
445
446 if (reg[0] == length && reg[1] == block / 2)
447 break;
448 }
449
450 mutex_unlock(&mhdp->mbox_mutex);
451
452 if (ret)
453 dev_err(mhdp->dev, "get block[%d] edid failed: %d\n",
454 block, ret);
455
456 return ret;
457 }
458
459 static
460 int cdns_mhdp_read_hpd_event(struct cdns_mhdp_device *mhdp)
461 {
462 u8 event = 0;
463 int ret;
464
465 mutex_lock(&mhdp->mbox_mutex);
466
467 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
468 DPTX_READ_EVENT, 0, NULL);
469 if (ret)
470 goto out;
471
472 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
473 DPTX_READ_EVENT, sizeof(event));
474 if (ret < 0)
475 goto out;
476
477 ret = cdns_mhdp_mailbox_recv_data(mhdp, &event, sizeof(event));
478 out:
479 mutex_unlock(&mhdp->mbox_mutex);
480
481 if (ret < 0)
482 return ret;
483
484 dev_dbg(mhdp->dev, "%s: %s%s%s%s\n", __func__,
485 (event & DPTX_READ_EVENT_HPD_TO_HIGH) ? "TO_HIGH " : "",
486 (event & DPTX_READ_EVENT_HPD_TO_LOW) ? "TO_LOW " : "",
487 (event & DPTX_READ_EVENT_HPD_PULSE) ? "PULSE " : "",
488 (event & DPTX_READ_EVENT_HPD_STATE) ? "HPD_STATE " : "");
489
490 return event;
491 }
492
493 static
494 int cdns_mhdp_adjust_lt(struct cdns_mhdp_device *mhdp, unsigned int nlanes,
495 unsigned int udelay, const u8 *lanes_data,
496 u8 link_status[DP_LINK_STATUS_SIZE])
497 {
498 u8 payload[7];
499 u8 hdr[5]; /* For DPCD read response header */
500 u32 addr;
501 int ret;
502
503 if (nlanes != 4 && nlanes != 2 && nlanes != 1) {
504 dev_err(mhdp->dev, "invalid number of lanes: %u\n", nlanes);
505 ret = -EINVAL;
506 goto out;
507 }
508
509 payload[0] = nlanes;
510 put_unaligned_be16(udelay, payload + 1);
511 memcpy(payload + 3, lanes_data, nlanes);
512
513 mutex_lock(&mhdp->mbox_mutex);
514
515 ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
516 DPTX_ADJUST_LT,
517 sizeof(payload), payload);
518 if (ret)
519 goto out;
520
521 /* Yes, read the DPCD read command response */
522 ret = cdns_mhdp_mailbox_recv_header(mhdp, MB_MODULE_ID_DP_TX,
523 DPTX_READ_DPCD,
524 sizeof(hdr) + DP_LINK_STATUS_SIZE);
525 if (ret)
526 goto out;
527
528 ret = cdns_mhdp_mailbox_recv_data(mhdp, hdr, sizeof(hdr));
529 if (ret)
530 goto out;
531
532 addr = get_unaligned_be24(hdr + 2);
533 if (addr != DP_LANE0_1_STATUS)
534 goto out;
535
536 ret = cdns_mhdp_mailbox_recv_data(mhdp, link_status,
537 DP_LINK_STATUS_SIZE);
538
539 out:
540 mutex_unlock(&mhdp->mbox_mutex);
541
542 if (ret)
543 dev_err(mhdp->dev, "Failed to adjust Link Training.\n");
544
545 return ret;
546 }
547
548 /**
549 * cdns_mhdp_link_power_up() - power up a DisplayPort link
550 * @aux: DisplayPort AUX channel
551 * @link: pointer to a structure containing the link configuration
552 *
553 * Returns 0 on success or a negative error code on failure.
554 */
555 static
556 int cdns_mhdp_link_power_up(struct drm_dp_aux *aux, struct cdns_mhdp_link *link)
557 {
558 u8 value;
559 int err;
560
561 /* DP_SET_POWER register is only available on DPCD v1.1 and later */
562 if (link->revision < 0x11)
563 return 0;
564
565 err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
566 if (err < 0)
567 return err;
568
569 value &= ~DP_SET_POWER_MASK;
570 value |= DP_SET_POWER_D0;
571
572 err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
573 if (err < 0)
574 return err;
575
576 /*
577 * According to the DP 1.1 specification, a "Sink Device must exit the
578 * power saving state within 1 ms" (Section 2.5.3.1, Table 5-52, "Sink
579 * Control Field" (register 0x600).
580 */
581 usleep_range(1000, 2000);
582
583 return 0;
584 }
585
586 /**
587 * cdns_mhdp_link_power_down() - power down a DisplayPort link
588 * @aux: DisplayPort AUX channel
589 * @link: pointer to a structure containing the link configuration
590 *
591 * Returns 0 on success or a negative error code on failure.
592 */
593 static
594 int cdns_mhdp_link_power_down(struct drm_dp_aux *aux,
595 struct cdns_mhdp_link *link)
596 {
597 u8 value;
598 int err;
599
600 /* DP_SET_POWER register is only available on DPCD v1.1 and later */
601 if (link->revision < 0x11)
602 return 0;
603
604 err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
605 if (err < 0)
606 return err;
607
608 value &= ~DP_SET_POWER_MASK;
609 value |= DP_SET_POWER_D3;
610
611 err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
612 if (err < 0)
613 return err;
614
615 return 0;
616 }
617
618 /**
619 * cdns_mhdp_link_configure() - configure a DisplayPort link
620 * @aux: DisplayPort AUX channel
621 * @link: pointer to a structure containing the link configuration
622 *
623 * Returns 0 on success or a negative error code on failure.
624 */
625 static
626 int cdns_mhdp_link_configure(struct drm_dp_aux *aux,
627 struct cdns_mhdp_link *link)
628 {
629 u8 values[2];
630 int err;
631
632 values[0] = drm_dp_link_rate_to_bw_code(link->rate);
633 values[1] = link->num_lanes;
634
635 if (link->capabilities & DP_LINK_CAP_ENHANCED_FRAMING)
636 values[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
637
638 err = drm_dp_dpcd_write(aux, DP_LINK_BW_SET, values, sizeof(values));
639 if (err < 0)
640 return err;
641
642 return 0;
643 }
644
645 static unsigned int cdns_mhdp_max_link_rate(struct cdns_mhdp_device *mhdp)
646 {
647 return min(mhdp->host.link_rate, mhdp->sink.link_rate);
648 }
649
650 static u8 cdns_mhdp_max_num_lanes(struct cdns_mhdp_device *mhdp)
651 {
652 return min(mhdp->sink.lanes_cnt, mhdp->host.lanes_cnt);
653 }
654
655 static u8 cdns_mhdp_eq_training_pattern_supported(struct cdns_mhdp_device *mhdp)
656 {
657 return fls(mhdp->host.pattern_supp & mhdp->sink.pattern_supp);
658 }
659
660 static bool cdns_mhdp_get_ssc_supported(struct cdns_mhdp_device *mhdp)
661 {
662 /* Check if SSC is supported by both sides */
663 return mhdp->host.ssc && mhdp->sink.ssc;
664 }
665
666 static enum drm_connector_status cdns_mhdp_detect(struct cdns_mhdp_device *mhdp)
667 {
668 dev_dbg(mhdp->dev, "%s: %d\n", __func__, mhdp->plugged);
669
670 if (mhdp->plugged)
671 return connector_status_connected;
672 else
673 return connector_status_disconnected;
674 }
675
676 static int cdns_mhdp_check_fw_version(struct cdns_mhdp_device *mhdp)
677 {
678 u32 major_num, minor_num, revision;
679 u32 fw_ver, lib_ver;
680
681 fw_ver = (readl(mhdp->regs + CDNS_VER_H) << 8)
682 | readl(mhdp->regs + CDNS_VER_L);
683
684 lib_ver = (readl(mhdp->regs + CDNS_LIB_H_ADDR) << 8)
685 | readl(mhdp->regs + CDNS_LIB_L_ADDR);
686
687 if (lib_ver < 33984) {
688 /*
689 * Older FW versions with major number 1, used to store FW
690 * version information by storing repository revision number
691 * in registers. This is for identifying these FW versions.
692 */
693 major_num = 1;
694 minor_num = 2;
695 if (fw_ver == 26098) {
696 revision = 15;
697 } else if (lib_ver == 0 && fw_ver == 0) {
698 revision = 17;
699 } else {
700 dev_err(mhdp->dev, "Unsupported FW version: fw_ver = %u, lib_ver = %u\n",
701 fw_ver, lib_ver);
702 return -ENODEV;
703 }
704 } else {
705 /* To identify newer FW versions with major number 2 onwards. */
706 major_num = fw_ver / 10000;
707 minor_num = (fw_ver / 100) % 100;
708 revision = (fw_ver % 10000) % 100;
709 }
710
711 dev_dbg(mhdp->dev, "FW version: v%u.%u.%u\n", major_num, minor_num,
712 revision);
713 return 0;
714 }
715
716 static int cdns_mhdp_fw_activate(const struct firmware *fw,
717 struct cdns_mhdp_device *mhdp)
718 {
719 unsigned int reg;
720 int ret;
721
722 /* Release uCPU reset and stall it. */
723 writel(CDNS_CPU_STALL, mhdp->regs + CDNS_APB_CTRL);
724
725 memcpy_toio(mhdp->regs + CDNS_MHDP_IMEM, fw->data, fw->size);
726
727 /* Leave debug mode, release stall */
728 writel(0, mhdp->regs + CDNS_APB_CTRL);
729
730 /*
731 * Wait for the KEEP_ALIVE "message" on the first 8 bits.
732 * Updated each sched "tick" (~2ms)
733 */
734 ret = readl_poll_timeout(mhdp->regs + CDNS_KEEP_ALIVE, reg,
735 reg & CDNS_KEEP_ALIVE_MASK, 500,
736 CDNS_KEEP_ALIVE_TIMEOUT);
737 if (ret) {
738 dev_err(mhdp->dev,
739 "device didn't give any life sign: reg %d\n", reg);
740 return ret;
741 }
742
743 ret = cdns_mhdp_check_fw_version(mhdp);
744 if (ret)
745 return ret;
746
747 /* Init events to 0 as it's not cleared by FW at boot but on read */
748 readl(mhdp->regs + CDNS_SW_EVENT0);
749 readl(mhdp->regs + CDNS_SW_EVENT1);
750 readl(mhdp->regs + CDNS_SW_EVENT2);
751 readl(mhdp->regs + CDNS_SW_EVENT3);
752
753 /* Activate uCPU */
754 ret = cdns_mhdp_set_firmware_active(mhdp, true);
755 if (ret)
756 return ret;
757
758 spin_lock(&mhdp->start_lock);
759
760 mhdp->hw_state = MHDP_HW_READY;
761
762 /*
763 * Here we must keep the lock while enabling the interrupts
764 * since it would otherwise be possible that interrupt enable
765 * code is executed after the bridge is detached. The similar
766 * situation is not possible in attach()/detach() callbacks
767 * since the hw_state changes from MHDP_HW_READY to
768 * MHDP_HW_STOPPED happens only due to driver removal when
769 * bridge should already be detached.
770 */
771 cdns_mhdp_bridge_hpd_enable(&mhdp->bridge);
772
773 spin_unlock(&mhdp->start_lock);
774
775 wake_up(&mhdp->fw_load_wq);
776 dev_dbg(mhdp->dev, "DP FW activated\n");
777
778 return 0;
779 }
780
781 static void cdns_mhdp_fw_cb(const struct firmware *fw, void *context)
782 {
783 struct cdns_mhdp_device *mhdp = context;
784 bool bridge_attached;
785 int ret;
786
787 dev_dbg(mhdp->dev, "firmware callback\n");
788
789 if (!fw || !fw->data) {
790 dev_err(mhdp->dev, "%s: No firmware.\n", __func__);
791 return;
792 }
793
794 ret = cdns_mhdp_fw_activate(fw, mhdp);
795
796 release_firmware(fw);
797
798 if (ret)
799 return;
800
801 /*
802 * XXX how to make sure the bridge is still attached when
803 * calling drm_kms_helper_hotplug_event() after releasing
804 * the lock? We should not hold the spin lock when
805 * calling drm_kms_helper_hotplug_event() since it may
806 * cause a dead lock. FB-dev console calls detect from the
807 * same thread just down the call stack started here.
808 */
809 spin_lock(&mhdp->start_lock);
810 bridge_attached = mhdp->bridge_attached;
811 spin_unlock(&mhdp->start_lock);
812 if (bridge_attached) {
813 if (mhdp->connector.dev)
814 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
815 else
816 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
817 }
818 }
819
820 static int cdns_mhdp_load_firmware(struct cdns_mhdp_device *mhdp)
821 {
822 int ret;
823
824 ret = request_firmware_nowait(THIS_MODULE, true, FW_NAME, mhdp->dev,
825 GFP_KERNEL, mhdp, cdns_mhdp_fw_cb);
826 if (ret) {
827 dev_err(mhdp->dev, "failed to load firmware (%s), ret: %d\n",
828 FW_NAME, ret);
829 return ret;
830 }
831
832 return 0;
833 }
834
835 static ssize_t cdns_mhdp_transfer(struct drm_dp_aux *aux,
836 struct drm_dp_aux_msg *msg)
837 {
838 struct cdns_mhdp_device *mhdp = dev_get_drvdata(aux->dev);
839 int ret;
840
841 if (msg->request != DP_AUX_NATIVE_WRITE &&
842 msg->request != DP_AUX_NATIVE_READ)
843 return -EOPNOTSUPP;
844
845 if (msg->request == DP_AUX_NATIVE_WRITE) {
846 const u8 *buf = msg->buffer;
847 unsigned int i;
848
849 for (i = 0; i < msg->size; ++i) {
850 ret = cdns_mhdp_dpcd_write(mhdp,
851 msg->address + i, buf[i]);
852 if (!ret)
853 continue;
854
855 dev_err(mhdp->dev,
856 "Failed to write DPCD addr %u\n",
857 msg->address + i);
858
859 return ret;
860 }
861 } else {
862 ret = cdns_mhdp_dpcd_read(mhdp, msg->address,
863 msg->buffer, msg->size);
864 if (ret) {
865 dev_err(mhdp->dev,
866 "Failed to read DPCD addr %u\n",
867 msg->address);
868
869 return ret;
870 }
871 }
872
873 return msg->size;
874 }
875
876 static int cdns_mhdp_link_training_init(struct cdns_mhdp_device *mhdp)
877 {
878 union phy_configure_opts phy_cfg;
879 u32 reg32;
880 int ret;
881
882 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
883 DP_TRAINING_PATTERN_DISABLE);
884
885 /* Reset PHY configuration */
886 reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
887 if (!mhdp->host.scrambler)
888 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
889
890 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
891
892 cdns_mhdp_reg_write(mhdp, CDNS_DP_ENHNCD,
893 mhdp->sink.enhanced & mhdp->host.enhanced);
894
895 cdns_mhdp_reg_write(mhdp, CDNS_DP_LANE_EN,
896 CDNS_DP_LANE_EN_LANES(mhdp->link.num_lanes));
897
898 cdns_mhdp_link_configure(&mhdp->aux, &mhdp->link);
899 phy_cfg.dp.link_rate = mhdp->link.rate / 100;
900 phy_cfg.dp.lanes = mhdp->link.num_lanes;
901
902 memset(phy_cfg.dp.voltage, 0, sizeof(phy_cfg.dp.voltage));
903 memset(phy_cfg.dp.pre, 0, sizeof(phy_cfg.dp.pre));
904
905 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
906 phy_cfg.dp.set_lanes = true;
907 phy_cfg.dp.set_rate = true;
908 phy_cfg.dp.set_voltages = true;
909 ret = phy_configure(mhdp->phy, &phy_cfg);
910 if (ret) {
911 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
912 __func__, ret);
913 return ret;
914 }
915
916 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG,
917 CDNS_PHY_COMMON_CONFIG |
918 CDNS_PHY_TRAINING_EN |
919 CDNS_PHY_TRAINING_TYPE(1) |
920 CDNS_PHY_SCRAMBLER_BYPASS);
921
922 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
923 DP_TRAINING_PATTERN_1 | DP_LINK_SCRAMBLING_DISABLE);
924
925 return 0;
926 }
927
928 static void cdns_mhdp_get_adjust_train(struct cdns_mhdp_device *mhdp,
929 u8 link_status[DP_LINK_STATUS_SIZE],
930 u8 lanes_data[CDNS_DP_MAX_NUM_LANES],
931 union phy_configure_opts *phy_cfg)
932 {
933 u8 adjust, max_pre_emph, max_volt_swing;
934 u8 set_volt, set_pre;
935 unsigned int i;
936
937 max_pre_emph = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis)
938 << DP_TRAIN_PRE_EMPHASIS_SHIFT;
939 max_volt_swing = CDNS_VOLT_SWING(mhdp->host.volt_swing);
940
941 for (i = 0; i < mhdp->link.num_lanes; i++) {
942 /* Check if Voltage swing and pre-emphasis are within limits */
943 adjust = drm_dp_get_adjust_request_voltage(link_status, i);
944 set_volt = min(adjust, max_volt_swing);
945
946 adjust = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
947 set_pre = min(adjust, max_pre_emph)
948 >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
949
950 /*
951 * Voltage swing level and pre-emphasis level combination is
952 * not allowed: leaving pre-emphasis as-is, and adjusting
953 * voltage swing.
954 */
955 if (set_volt + set_pre > 3)
956 set_volt = 3 - set_pre;
957
958 phy_cfg->dp.voltage[i] = set_volt;
959 lanes_data[i] = set_volt;
960
961 if (set_volt == max_volt_swing)
962 lanes_data[i] |= DP_TRAIN_MAX_SWING_REACHED;
963
964 phy_cfg->dp.pre[i] = set_pre;
965 lanes_data[i] |= (set_pre << DP_TRAIN_PRE_EMPHASIS_SHIFT);
966
967 if (set_pre == (max_pre_emph >> DP_TRAIN_PRE_EMPHASIS_SHIFT))
968 lanes_data[i] |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
969 }
970 }
971
972 static
973 void cdns_mhdp_set_adjust_request_voltage(u8 link_status[DP_LINK_STATUS_SIZE],
974 unsigned int lane, u8 volt)
975 {
976 unsigned int s = ((lane & 1) ?
977 DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT :
978 DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT);
979 unsigned int idx = DP_ADJUST_REQUEST_LANE0_1 - DP_LANE0_1_STATUS + (lane >> 1);
980
981 link_status[idx] &= ~(DP_ADJUST_VOLTAGE_SWING_LANE0_MASK << s);
982 link_status[idx] |= volt << s;
983 }
984
985 static
986 void cdns_mhdp_set_adjust_request_pre_emphasis(u8 link_status[DP_LINK_STATUS_SIZE],
987 unsigned int lane, u8 pre_emphasis)
988 {
989 unsigned int s = ((lane & 1) ?
990 DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT :
991 DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT);
992 unsigned int idx = DP_ADJUST_REQUEST_LANE0_1 - DP_LANE0_1_STATUS + (lane >> 1);
993
994 link_status[idx] &= ~(DP_ADJUST_PRE_EMPHASIS_LANE0_MASK << s);
995 link_status[idx] |= pre_emphasis << s;
996 }
997
998 static void cdns_mhdp_adjust_requested_eq(struct cdns_mhdp_device *mhdp,
999 u8 link_status[DP_LINK_STATUS_SIZE])
1000 {
1001 u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1002 u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1003 unsigned int i;
1004 u8 volt, pre;
1005
1006 for (i = 0; i < mhdp->link.num_lanes; i++) {
1007 volt = drm_dp_get_adjust_request_voltage(link_status, i);
1008 pre = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
1009 if (volt + pre > 3)
1010 cdns_mhdp_set_adjust_request_voltage(link_status, i,
1011 3 - pre);
1012 if (mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING)
1013 cdns_mhdp_set_adjust_request_voltage(link_status, i,
1014 max_volt);
1015 if (mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS)
1016 cdns_mhdp_set_adjust_request_pre_emphasis(link_status,
1017 i, max_pre);
1018 }
1019 }
1020
1021 static void cdns_mhdp_print_lt_status(const char *prefix,
1022 struct cdns_mhdp_device *mhdp,
1023 union phy_configure_opts *phy_cfg)
1024 {
1025 char vs[8] = "0/0/0/0";
1026 char pe[8] = "0/0/0/0";
1027 unsigned int i;
1028
1029 for (i = 0; i < mhdp->link.num_lanes; i++) {
1030 vs[i * 2] = '0' + phy_cfg->dp.voltage[i];
1031 pe[i * 2] = '0' + phy_cfg->dp.pre[i];
1032 }
1033
1034 vs[i * 2 - 1] = '\0';
1035 pe[i * 2 - 1] = '\0';
1036
1037 dev_dbg(mhdp->dev, "%s, %u lanes, %u Mbps, vs %s, pe %s\n",
1038 prefix,
1039 mhdp->link.num_lanes, mhdp->link.rate / 100,
1040 vs, pe);
1041 }
1042
1043 static bool cdns_mhdp_link_training_channel_eq(struct cdns_mhdp_device *mhdp,
1044 u8 eq_tps,
1045 unsigned int training_interval)
1046 {
1047 u8 lanes_data[CDNS_DP_MAX_NUM_LANES], fail_counter_short = 0;
1048 u8 link_status[DP_LINK_STATUS_SIZE];
1049 union phy_configure_opts phy_cfg;
1050 u32 reg32;
1051 int ret;
1052 bool r;
1053
1054 dev_dbg(mhdp->dev, "Starting EQ phase\n");
1055
1056 /* Enable link training TPS[eq_tps] in PHY */
1057 reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_EN |
1058 CDNS_PHY_TRAINING_TYPE(eq_tps);
1059 if (eq_tps != 4)
1060 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1061 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1062
1063 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1064 (eq_tps != 4) ? eq_tps | DP_LINK_SCRAMBLING_DISABLE :
1065 CDNS_DP_TRAINING_PATTERN_4);
1066
1067 drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1068
1069 do {
1070 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1071 &phy_cfg);
1072 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1073 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1074 phy_cfg.dp.set_lanes = false;
1075 phy_cfg.dp.set_rate = false;
1076 phy_cfg.dp.set_voltages = true;
1077 ret = phy_configure(mhdp->phy, &phy_cfg);
1078 if (ret) {
1079 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1080 __func__, ret);
1081 goto err;
1082 }
1083
1084 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes,
1085 training_interval, lanes_data, link_status);
1086
1087 r = drm_dp_clock_recovery_ok(link_status, mhdp->link.num_lanes);
1088 if (!r)
1089 goto err;
1090
1091 if (drm_dp_channel_eq_ok(link_status, mhdp->link.num_lanes)) {
1092 cdns_mhdp_print_lt_status("EQ phase ok", mhdp,
1093 &phy_cfg);
1094 return true;
1095 }
1096
1097 fail_counter_short++;
1098
1099 cdns_mhdp_adjust_requested_eq(mhdp, link_status);
1100 } while (fail_counter_short < 5);
1101
1102 err:
1103 cdns_mhdp_print_lt_status("EQ phase failed", mhdp, &phy_cfg);
1104
1105 return false;
1106 }
1107
1108 static void cdns_mhdp_adjust_requested_cr(struct cdns_mhdp_device *mhdp,
1109 u8 link_status[DP_LINK_STATUS_SIZE],
1110 u8 *req_volt, u8 *req_pre)
1111 {
1112 const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1113 const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1114 unsigned int i;
1115
1116 for (i = 0; i < mhdp->link.num_lanes; i++) {
1117 u8 val;
1118
1119 val = mhdp->host.volt_swing & CDNS_FORCE_VOLT_SWING ?
1120 max_volt : req_volt[i];
1121 cdns_mhdp_set_adjust_request_voltage(link_status, i, val);
1122
1123 val = mhdp->host.pre_emphasis & CDNS_FORCE_PRE_EMPHASIS ?
1124 max_pre : req_pre[i];
1125 cdns_mhdp_set_adjust_request_pre_emphasis(link_status, i, val);
1126 }
1127 }
1128
1129 static
1130 void cdns_mhdp_validate_cr(struct cdns_mhdp_device *mhdp, bool *cr_done,
1131 bool *same_before_adjust, bool *max_swing_reached,
1132 u8 before_cr[CDNS_DP_MAX_NUM_LANES],
1133 u8 after_cr[DP_LINK_STATUS_SIZE], u8 *req_volt,
1134 u8 *req_pre)
1135 {
1136 const u8 max_volt = CDNS_VOLT_SWING(mhdp->host.volt_swing);
1137 const u8 max_pre = CDNS_PRE_EMPHASIS(mhdp->host.pre_emphasis);
1138 bool same_pre, same_volt;
1139 unsigned int i;
1140 u8 adjust;
1141
1142 *same_before_adjust = false;
1143 *max_swing_reached = false;
1144 *cr_done = drm_dp_clock_recovery_ok(after_cr, mhdp->link.num_lanes);
1145
1146 for (i = 0; i < mhdp->link.num_lanes; i++) {
1147 adjust = drm_dp_get_adjust_request_voltage(after_cr, i);
1148 req_volt[i] = min(adjust, max_volt);
1149
1150 adjust = drm_dp_get_adjust_request_pre_emphasis(after_cr, i) >>
1151 DP_TRAIN_PRE_EMPHASIS_SHIFT;
1152 req_pre[i] = min(adjust, max_pre);
1153
1154 same_pre = (before_cr[i] & DP_TRAIN_PRE_EMPHASIS_MASK) ==
1155 req_pre[i] << DP_TRAIN_PRE_EMPHASIS_SHIFT;
1156 same_volt = (before_cr[i] & DP_TRAIN_VOLTAGE_SWING_MASK) ==
1157 req_volt[i];
1158 if (same_pre && same_volt)
1159 *same_before_adjust = true;
1160
1161 /* 3.1.5.2 in DP Standard v1.4. Table 3-1 */
1162 if (!*cr_done && req_volt[i] + req_pre[i] >= 3) {
1163 *max_swing_reached = true;
1164 return;
1165 }
1166 }
1167 }
1168
1169 static bool cdns_mhdp_link_training_cr(struct cdns_mhdp_device *mhdp)
1170 {
1171 u8 lanes_data[CDNS_DP_MAX_NUM_LANES],
1172 fail_counter_short = 0, fail_counter_cr_long = 0;
1173 u8 link_status[DP_LINK_STATUS_SIZE];
1174 bool cr_done;
1175 union phy_configure_opts phy_cfg;
1176 int ret;
1177
1178 dev_dbg(mhdp->dev, "Starting CR phase\n");
1179
1180 ret = cdns_mhdp_link_training_init(mhdp);
1181 if (ret)
1182 goto err;
1183
1184 drm_dp_dpcd_read_link_status(&mhdp->aux, link_status);
1185
1186 do {
1187 u8 requested_adjust_volt_swing[CDNS_DP_MAX_NUM_LANES] = {};
1188 u8 requested_adjust_pre_emphasis[CDNS_DP_MAX_NUM_LANES] = {};
1189 bool same_before_adjust, max_swing_reached;
1190
1191 cdns_mhdp_get_adjust_train(mhdp, link_status, lanes_data,
1192 &phy_cfg);
1193 phy_cfg.dp.lanes = mhdp->link.num_lanes;
1194 phy_cfg.dp.ssc = cdns_mhdp_get_ssc_supported(mhdp);
1195 phy_cfg.dp.set_lanes = false;
1196 phy_cfg.dp.set_rate = false;
1197 phy_cfg.dp.set_voltages = true;
1198 ret = phy_configure(mhdp->phy, &phy_cfg);
1199 if (ret) {
1200 dev_err(mhdp->dev, "%s: phy_configure() failed: %d\n",
1201 __func__, ret);
1202 goto err;
1203 }
1204
1205 cdns_mhdp_adjust_lt(mhdp, mhdp->link.num_lanes, 100,
1206 lanes_data, link_status);
1207
1208 cdns_mhdp_validate_cr(mhdp, &cr_done, &same_before_adjust,
1209 &max_swing_reached, lanes_data,
1210 link_status,
1211 requested_adjust_volt_swing,
1212 requested_adjust_pre_emphasis);
1213
1214 if (max_swing_reached) {
1215 dev_err(mhdp->dev, "CR: max swing reached\n");
1216 goto err;
1217 }
1218
1219 if (cr_done) {
1220 cdns_mhdp_print_lt_status("CR phase ok", mhdp,
1221 &phy_cfg);
1222 return true;
1223 }
1224
1225 /* Not all CR_DONE bits set */
1226 fail_counter_cr_long++;
1227
1228 if (same_before_adjust) {
1229 fail_counter_short++;
1230 continue;
1231 }
1232
1233 fail_counter_short = 0;
1234 /*
1235 * Voltage swing/pre-emphasis adjust requested
1236 * during CR phase
1237 */
1238 cdns_mhdp_adjust_requested_cr(mhdp, link_status,
1239 requested_adjust_volt_swing,
1240 requested_adjust_pre_emphasis);
1241 } while (fail_counter_short < 5 && fail_counter_cr_long < 10);
1242
1243 err:
1244 cdns_mhdp_print_lt_status("CR phase failed", mhdp, &phy_cfg);
1245
1246 return false;
1247 }
1248
1249 static void cdns_mhdp_lower_link_rate(struct cdns_mhdp_link *link)
1250 {
1251 switch (drm_dp_link_rate_to_bw_code(link->rate)) {
1252 case DP_LINK_BW_2_7:
1253 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_1_62);
1254 break;
1255 case DP_LINK_BW_5_4:
1256 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_2_7);
1257 break;
1258 case DP_LINK_BW_8_1:
1259 link->rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_5_4);
1260 break;
1261 }
1262 }
1263
1264 static int cdns_mhdp_link_training(struct cdns_mhdp_device *mhdp,
1265 unsigned int training_interval)
1266 {
1267 u32 reg32;
1268 const u8 eq_tps = cdns_mhdp_eq_training_pattern_supported(mhdp);
1269 int ret;
1270
1271 while (1) {
1272 if (!cdns_mhdp_link_training_cr(mhdp)) {
1273 if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1274 DP_LINK_BW_1_62) {
1275 dev_dbg(mhdp->dev,
1276 "Reducing link rate during CR phase\n");
1277 cdns_mhdp_lower_link_rate(&mhdp->link);
1278
1279 continue;
1280 } else if (mhdp->link.num_lanes > 1) {
1281 dev_dbg(mhdp->dev,
1282 "Reducing lanes number during CR phase\n");
1283 mhdp->link.num_lanes >>= 1;
1284 mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1285
1286 continue;
1287 }
1288
1289 dev_err(mhdp->dev,
1290 "Link training failed during CR phase\n");
1291 goto err;
1292 }
1293
1294 if (cdns_mhdp_link_training_channel_eq(mhdp, eq_tps,
1295 training_interval))
1296 break;
1297
1298 if (mhdp->link.num_lanes > 1) {
1299 dev_dbg(mhdp->dev,
1300 "Reducing lanes number during EQ phase\n");
1301 mhdp->link.num_lanes >>= 1;
1302
1303 continue;
1304 } else if (drm_dp_link_rate_to_bw_code(mhdp->link.rate) !=
1305 DP_LINK_BW_1_62) {
1306 dev_dbg(mhdp->dev,
1307 "Reducing link rate during EQ phase\n");
1308 cdns_mhdp_lower_link_rate(&mhdp->link);
1309 mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1310
1311 continue;
1312 }
1313
1314 dev_err(mhdp->dev, "Link training failed during EQ phase\n");
1315 goto err;
1316 }
1317
1318 dev_dbg(mhdp->dev, "Link training ok. Lanes: %u, Rate %u Mbps\n",
1319 mhdp->link.num_lanes, mhdp->link.rate / 100);
1320
1321 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1322 mhdp->host.scrambler ? 0 :
1323 DP_LINK_SCRAMBLING_DISABLE);
1324
1325 ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &reg32);
1326 if (ret < 0) {
1327 dev_err(mhdp->dev,
1328 "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1329 ret);
1330 return ret;
1331 }
1332 reg32 &= ~GENMASK(1, 0);
1333 reg32 |= CDNS_DP_NUM_LANES(mhdp->link.num_lanes);
1334 reg32 |= CDNS_DP_WR_FAILING_EDGE_VSYNC;
1335 reg32 |= CDNS_DP_FRAMER_EN;
1336 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, reg32);
1337
1338 /* Reset PHY config */
1339 reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
1340 if (!mhdp->host.scrambler)
1341 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1342 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1343
1344 return 0;
1345 err:
1346 /* Reset PHY config */
1347 reg32 = CDNS_PHY_COMMON_CONFIG | CDNS_PHY_TRAINING_TYPE(1);
1348 if (!mhdp->host.scrambler)
1349 reg32 |= CDNS_PHY_SCRAMBLER_BYPASS;
1350 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_PHY_CONFIG, reg32);
1351
1352 drm_dp_dpcd_writeb(&mhdp->aux, DP_TRAINING_PATTERN_SET,
1353 DP_TRAINING_PATTERN_DISABLE);
1354
1355 return -EIO;
1356 }
1357
1358 static u32 cdns_mhdp_get_training_interval_us(struct cdns_mhdp_device *mhdp,
1359 u32 interval)
1360 {
1361 if (interval == 0)
1362 return 400;
1363 if (interval < 5)
1364 return 4000 << (interval - 1);
1365 dev_err(mhdp->dev,
1366 "wrong training interval returned by DPCD: %d\n", interval);
1367 return 0;
1368 }
1369
1370 static void cdns_mhdp_fill_host_caps(struct cdns_mhdp_device *mhdp)
1371 {
1372 unsigned int link_rate;
1373
1374 /* Get source capabilities based on PHY attributes */
1375
1376 mhdp->host.lanes_cnt = mhdp->phy->attrs.bus_width;
1377 if (!mhdp->host.lanes_cnt)
1378 mhdp->host.lanes_cnt = 4;
1379
1380 link_rate = mhdp->phy->attrs.max_link_rate;
1381 if (!link_rate)
1382 link_rate = drm_dp_bw_code_to_link_rate(DP_LINK_BW_8_1);
1383 else
1384 /* PHY uses Mb/s, DRM uses tens of kb/s. */
1385 link_rate *= 100;
1386
1387 mhdp->host.link_rate = link_rate;
1388 mhdp->host.volt_swing = CDNS_VOLT_SWING(3);
1389 mhdp->host.pre_emphasis = CDNS_PRE_EMPHASIS(3);
1390 mhdp->host.pattern_supp = CDNS_SUPPORT_TPS(1) |
1391 CDNS_SUPPORT_TPS(2) | CDNS_SUPPORT_TPS(3) |
1392 CDNS_SUPPORT_TPS(4);
1393 mhdp->host.lane_mapping = CDNS_LANE_MAPPING_NORMAL;
1394 mhdp->host.fast_link = false;
1395 mhdp->host.enhanced = true;
1396 mhdp->host.scrambler = true;
1397 mhdp->host.ssc = false;
1398 }
1399
1400 static void cdns_mhdp_fill_sink_caps(struct cdns_mhdp_device *mhdp,
1401 u8 dpcd[DP_RECEIVER_CAP_SIZE])
1402 {
1403 mhdp->sink.link_rate = mhdp->link.rate;
1404 mhdp->sink.lanes_cnt = mhdp->link.num_lanes;
1405 mhdp->sink.enhanced = !!(mhdp->link.capabilities &
1406 DP_LINK_CAP_ENHANCED_FRAMING);
1407
1408 /* Set SSC support */
1409 mhdp->sink.ssc = !!(dpcd[DP_MAX_DOWNSPREAD] &
1410 DP_MAX_DOWNSPREAD_0_5);
1411
1412 /* Set TPS support */
1413 mhdp->sink.pattern_supp = CDNS_SUPPORT_TPS(1) | CDNS_SUPPORT_TPS(2);
1414 if (drm_dp_tps3_supported(dpcd))
1415 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(3);
1416 if (drm_dp_tps4_supported(dpcd))
1417 mhdp->sink.pattern_supp |= CDNS_SUPPORT_TPS(4);
1418
1419 /* Set fast link support */
1420 mhdp->sink.fast_link = !!(dpcd[DP_MAX_DOWNSPREAD] &
1421 DP_NO_AUX_HANDSHAKE_LINK_TRAINING);
1422 }
1423
1424 static int cdns_mhdp_link_up(struct cdns_mhdp_device *mhdp)
1425 {
1426 u8 dpcd[DP_RECEIVER_CAP_SIZE], amp[2];
1427 u32 resp, interval, interval_us;
1428 u8 ext_cap_chk = 0;
1429 unsigned int addr;
1430 int err;
1431
1432 WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1433
1434 drm_dp_dpcd_readb(&mhdp->aux, DP_TRAINING_AUX_RD_INTERVAL,
1435 &ext_cap_chk);
1436
1437 if (ext_cap_chk & DP_EXTENDED_RECEIVER_CAP_FIELD_PRESENT)
1438 addr = DP_DP13_DPCD_REV;
1439 else
1440 addr = DP_DPCD_REV;
1441
1442 err = drm_dp_dpcd_read(&mhdp->aux, addr, dpcd, DP_RECEIVER_CAP_SIZE);
1443 if (err < 0) {
1444 dev_err(mhdp->dev, "Failed to read receiver capabilities\n");
1445 return err;
1446 }
1447
1448 mhdp->link.revision = dpcd[0];
1449 mhdp->link.rate = drm_dp_bw_code_to_link_rate(dpcd[1]);
1450 mhdp->link.num_lanes = dpcd[2] & DP_MAX_LANE_COUNT_MASK;
1451
1452 if (dpcd[2] & DP_ENHANCED_FRAME_CAP)
1453 mhdp->link.capabilities |= DP_LINK_CAP_ENHANCED_FRAMING;
1454
1455 dev_dbg(mhdp->dev, "Set sink device power state via DPCD\n");
1456 cdns_mhdp_link_power_up(&mhdp->aux, &mhdp->link);
1457
1458 cdns_mhdp_fill_sink_caps(mhdp, dpcd);
1459
1460 mhdp->link.rate = cdns_mhdp_max_link_rate(mhdp);
1461 mhdp->link.num_lanes = cdns_mhdp_max_num_lanes(mhdp);
1462
1463 /* Disable framer for link training */
1464 err = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
1465 if (err < 0) {
1466 dev_err(mhdp->dev,
1467 "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1468 err);
1469 return err;
1470 }
1471
1472 resp &= ~CDNS_DP_FRAMER_EN;
1473 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
1474
1475 /* Spread AMP if required, enable 8b/10b coding */
1476 amp[0] = cdns_mhdp_get_ssc_supported(mhdp) ? DP_SPREAD_AMP_0_5 : 0;
1477 amp[1] = DP_SET_ANSI_8B10B;
1478 drm_dp_dpcd_write(&mhdp->aux, DP_DOWNSPREAD_CTRL, amp, 2);
1479
1480 if (mhdp->host.fast_link & mhdp->sink.fast_link) {
1481 dev_err(mhdp->dev, "fastlink not supported\n");
1482 return -EOPNOTSUPP;
1483 }
1484
1485 interval = dpcd[DP_TRAINING_AUX_RD_INTERVAL] & DP_TRAINING_AUX_RD_MASK;
1486 interval_us = cdns_mhdp_get_training_interval_us(mhdp, interval);
1487 if (!interval_us ||
1488 cdns_mhdp_link_training(mhdp, interval_us)) {
1489 dev_err(mhdp->dev, "Link training failed. Exiting.\n");
1490 return -EIO;
1491 }
1492
1493 mhdp->link_up = true;
1494
1495 return 0;
1496 }
1497
1498 static void cdns_mhdp_link_down(struct cdns_mhdp_device *mhdp)
1499 {
1500 WARN_ON(!mutex_is_locked(&mhdp->link_mutex));
1501
1502 if (mhdp->plugged)
1503 cdns_mhdp_link_power_down(&mhdp->aux, &mhdp->link);
1504
1505 mhdp->link_up = false;
1506 }
1507
1508 static const struct drm_edid *cdns_mhdp_edid_read(struct cdns_mhdp_device *mhdp,
1509 struct drm_connector *connector)
1510 {
1511 if (!mhdp->plugged)
1512 return NULL;
1513
1514 return drm_edid_read_custom(connector, cdns_mhdp_get_edid_block, mhdp);
1515 }
1516
1517 static int cdns_mhdp_get_modes(struct drm_connector *connector)
1518 {
1519 struct cdns_mhdp_device *mhdp = connector_to_mhdp(connector);
1520 const struct drm_edid *drm_edid;
1521 int num_modes;
1522
1523 if (!mhdp->plugged)
1524 return 0;
1525
1526 drm_edid = cdns_mhdp_edid_read(mhdp, connector);
1527
1528 drm_edid_connector_update(connector, drm_edid);
1529
1530 if (!drm_edid) {
1531 dev_err(mhdp->dev, "Failed to read EDID\n");
1532 return 0;
1533 }
1534
1535 num_modes = drm_edid_connector_add_modes(connector);
1536 drm_edid_free(drm_edid);
1537
1538 /*
1539 * HACK: Warn about unsupported display formats until we deal
1540 * with them correctly.
1541 */
1542 if (connector->display_info.color_formats &&
1543 !(connector->display_info.color_formats &
1544 mhdp->display_fmt.color_format))
1545 dev_warn(mhdp->dev,
1546 "%s: No supported color_format found (0x%08x)\n",
1547 __func__, connector->display_info.color_formats);
1548
1549 if (connector->display_info.bpc &&
1550 connector->display_info.bpc < mhdp->display_fmt.bpc)
1551 dev_warn(mhdp->dev, "%s: Display bpc only %d < %d\n",
1552 __func__, connector->display_info.bpc,
1553 mhdp->display_fmt.bpc);
1554
1555 return num_modes;
1556 }
1557
1558 static int cdns_mhdp_connector_detect(struct drm_connector *conn,
1559 struct drm_modeset_acquire_ctx *ctx,
1560 bool force)
1561 {
1562 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1563
1564 return cdns_mhdp_detect(mhdp);
1565 }
1566
1567 static u32 cdns_mhdp_get_bpp(struct cdns_mhdp_display_fmt *fmt)
1568 {
1569 u32 bpp;
1570
1571 if (fmt->y_only)
1572 return fmt->bpc;
1573
1574 switch (fmt->color_format) {
1575 case DRM_COLOR_FORMAT_RGB444:
1576 case DRM_COLOR_FORMAT_YCBCR444:
1577 bpp = fmt->bpc * 3;
1578 break;
1579 case DRM_COLOR_FORMAT_YCBCR422:
1580 bpp = fmt->bpc * 2;
1581 break;
1582 case DRM_COLOR_FORMAT_YCBCR420:
1583 bpp = fmt->bpc * 3 / 2;
1584 break;
1585 default:
1586 bpp = fmt->bpc * 3;
1587 WARN_ON(1);
1588 }
1589 return bpp;
1590 }
1591
1592 static
1593 bool cdns_mhdp_bandwidth_ok(struct cdns_mhdp_device *mhdp,
1594 const struct drm_display_mode *mode,
1595 unsigned int lanes, unsigned int rate)
1596 {
1597 u32 max_bw, req_bw, bpp;
1598
1599 /*
1600 * mode->clock is expressed in kHz. Multiplying by bpp and dividing by 8
1601 * we get the number of kB/s. DisplayPort applies a 8b-10b encoding, the
1602 * value thus equals the bandwidth in 10kb/s units, which matches the
1603 * units of the rate parameter.
1604 */
1605
1606 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1607 req_bw = mode->clock * bpp / 8;
1608 max_bw = lanes * rate;
1609 if (req_bw > max_bw) {
1610 dev_dbg(mhdp->dev,
1611 "Unsupported Mode: %s, Req BW: %u, Available Max BW:%u\n",
1612 mode->name, req_bw, max_bw);
1613
1614 return false;
1615 }
1616
1617 return true;
1618 }
1619
1620 static
1621 enum drm_mode_status cdns_mhdp_mode_valid(struct drm_connector *conn,
1622 struct drm_display_mode *mode)
1623 {
1624 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1625
1626 mutex_lock(&mhdp->link_mutex);
1627
1628 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
1629 mhdp->link.rate)) {
1630 mutex_unlock(&mhdp->link_mutex);
1631 return MODE_CLOCK_HIGH;
1632 }
1633
1634 mutex_unlock(&mhdp->link_mutex);
1635 return MODE_OK;
1636 }
1637
1638 static int cdns_mhdp_connector_atomic_check(struct drm_connector *conn,
1639 struct drm_atomic_state *state)
1640 {
1641 struct cdns_mhdp_device *mhdp = connector_to_mhdp(conn);
1642 struct drm_connector_state *old_state, *new_state;
1643 struct drm_crtc_state *crtc_state;
1644 u64 old_cp, new_cp;
1645
1646 if (!mhdp->hdcp_supported)
1647 return 0;
1648
1649 old_state = drm_atomic_get_old_connector_state(state, conn);
1650 new_state = drm_atomic_get_new_connector_state(state, conn);
1651 old_cp = old_state->content_protection;
1652 new_cp = new_state->content_protection;
1653
1654 if (old_state->hdcp_content_type != new_state->hdcp_content_type &&
1655 new_cp != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
1656 new_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
1657 goto mode_changed;
1658 }
1659
1660 if (!new_state->crtc) {
1661 if (old_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED)
1662 new_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
1663 return 0;
1664 }
1665
1666 if (old_cp == new_cp ||
1667 (old_cp == DRM_MODE_CONTENT_PROTECTION_DESIRED &&
1668 new_cp == DRM_MODE_CONTENT_PROTECTION_ENABLED))
1669 return 0;
1670
1671 mode_changed:
1672 crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc);
1673 crtc_state->mode_changed = true;
1674
1675 return 0;
1676 }
1677
1678 static const struct drm_connector_helper_funcs cdns_mhdp_conn_helper_funcs = {
1679 .detect_ctx = cdns_mhdp_connector_detect,
1680 .get_modes = cdns_mhdp_get_modes,
1681 .mode_valid = cdns_mhdp_mode_valid,
1682 .atomic_check = cdns_mhdp_connector_atomic_check,
1683 };
1684
1685 static const struct drm_connector_funcs cdns_mhdp_conn_funcs = {
1686 .fill_modes = drm_helper_probe_single_connector_modes,
1687 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
1688 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
1689 .reset = drm_atomic_helper_connector_reset,
1690 .destroy = drm_connector_cleanup,
1691 };
1692
1693 static int cdns_mhdp_connector_init(struct cdns_mhdp_device *mhdp)
1694 {
1695 u32 bus_format = MEDIA_BUS_FMT_RGB121212_1X36;
1696 struct drm_connector *conn = &mhdp->connector;
1697 struct drm_bridge *bridge = &mhdp->bridge;
1698 int ret;
1699
1700 conn->polled = DRM_CONNECTOR_POLL_HPD;
1701
1702 ret = drm_connector_init(bridge->dev, conn, &cdns_mhdp_conn_funcs,
1703 DRM_MODE_CONNECTOR_DisplayPort);
1704 if (ret) {
1705 dev_err(mhdp->dev, "Failed to initialize connector with drm\n");
1706 return ret;
1707 }
1708
1709 drm_connector_helper_add(conn, &cdns_mhdp_conn_helper_funcs);
1710
1711 ret = drm_display_info_set_bus_formats(&conn->display_info,
1712 &bus_format, 1);
1713 if (ret)
1714 return ret;
1715
1716 ret = drm_connector_attach_encoder(conn, bridge->encoder);
1717 if (ret) {
1718 dev_err(mhdp->dev, "Failed to attach connector to encoder\n");
1719 return ret;
1720 }
1721
1722 if (mhdp->hdcp_supported)
1723 ret = drm_connector_attach_content_protection_property(conn, true);
1724
1725 return ret;
1726 }
1727
1728 static int cdns_mhdp_attach(struct drm_bridge *bridge,
1729 enum drm_bridge_attach_flags flags)
1730 {
1731 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1732 bool hw_ready;
1733 int ret;
1734
1735 dev_dbg(mhdp->dev, "%s\n", __func__);
1736
1737 mhdp->aux.drm_dev = bridge->dev;
1738 ret = drm_dp_aux_register(&mhdp->aux);
1739 if (ret < 0)
1740 return ret;
1741
1742 if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)) {
1743 ret = cdns_mhdp_connector_init(mhdp);
1744 if (ret)
1745 goto aux_unregister;
1746 }
1747
1748 spin_lock(&mhdp->start_lock);
1749
1750 mhdp->bridge_attached = true;
1751 hw_ready = mhdp->hw_state == MHDP_HW_READY;
1752
1753 spin_unlock(&mhdp->start_lock);
1754
1755 /* Enable SW event interrupts */
1756 if (hw_ready)
1757 cdns_mhdp_bridge_hpd_enable(bridge);
1758
1759 return 0;
1760 aux_unregister:
1761 drm_dp_aux_unregister(&mhdp->aux);
1762 return ret;
1763 }
1764
1765 static void cdns_mhdp_configure_video(struct cdns_mhdp_device *mhdp,
1766 const struct drm_display_mode *mode)
1767 {
1768 unsigned int dp_framer_sp = 0, msa_horizontal_1,
1769 msa_vertical_1, bnd_hsync2vsync, hsync2vsync_pol_ctrl,
1770 misc0 = 0, misc1 = 0, pxl_repr,
1771 front_porch, back_porch, msa_h0, msa_v0, hsync, vsync,
1772 dp_vertical_1;
1773 u8 stream_id = mhdp->stream_id;
1774 u32 bpp, bpc, pxlfmt, framer;
1775 int ret;
1776
1777 pxlfmt = mhdp->display_fmt.color_format;
1778 bpc = mhdp->display_fmt.bpc;
1779
1780 /*
1781 * If YCBCR supported and stream not SD, use ITU709
1782 * Need to handle ITU version with YCBCR420 when supported
1783 */
1784 if ((pxlfmt == DRM_COLOR_FORMAT_YCBCR444 ||
1785 pxlfmt == DRM_COLOR_FORMAT_YCBCR422) && mode->crtc_vdisplay >= 720)
1786 misc0 = DP_YCBCR_COEFFICIENTS_ITU709;
1787
1788 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1789
1790 switch (pxlfmt) {
1791 case DRM_COLOR_FORMAT_RGB444:
1792 pxl_repr = CDNS_DP_FRAMER_RGB << CDNS_DP_FRAMER_PXL_FORMAT;
1793 misc0 |= DP_COLOR_FORMAT_RGB;
1794 break;
1795 case DRM_COLOR_FORMAT_YCBCR444:
1796 pxl_repr = CDNS_DP_FRAMER_YCBCR444 << CDNS_DP_FRAMER_PXL_FORMAT;
1797 misc0 |= DP_COLOR_FORMAT_YCbCr444 | DP_TEST_DYNAMIC_RANGE_CEA;
1798 break;
1799 case DRM_COLOR_FORMAT_YCBCR422:
1800 pxl_repr = CDNS_DP_FRAMER_YCBCR422 << CDNS_DP_FRAMER_PXL_FORMAT;
1801 misc0 |= DP_COLOR_FORMAT_YCbCr422 | DP_TEST_DYNAMIC_RANGE_CEA;
1802 break;
1803 case DRM_COLOR_FORMAT_YCBCR420:
1804 pxl_repr = CDNS_DP_FRAMER_YCBCR420 << CDNS_DP_FRAMER_PXL_FORMAT;
1805 break;
1806 default:
1807 pxl_repr = CDNS_DP_FRAMER_Y_ONLY << CDNS_DP_FRAMER_PXL_FORMAT;
1808 }
1809
1810 switch (bpc) {
1811 case 6:
1812 misc0 |= DP_TEST_BIT_DEPTH_6;
1813 pxl_repr |= CDNS_DP_FRAMER_6_BPC;
1814 break;
1815 case 8:
1816 misc0 |= DP_TEST_BIT_DEPTH_8;
1817 pxl_repr |= CDNS_DP_FRAMER_8_BPC;
1818 break;
1819 case 10:
1820 misc0 |= DP_TEST_BIT_DEPTH_10;
1821 pxl_repr |= CDNS_DP_FRAMER_10_BPC;
1822 break;
1823 case 12:
1824 misc0 |= DP_TEST_BIT_DEPTH_12;
1825 pxl_repr |= CDNS_DP_FRAMER_12_BPC;
1826 break;
1827 case 16:
1828 misc0 |= DP_TEST_BIT_DEPTH_16;
1829 pxl_repr |= CDNS_DP_FRAMER_16_BPC;
1830 break;
1831 }
1832
1833 bnd_hsync2vsync = CDNS_IP_BYPASS_V_INTERFACE;
1834 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1835 bnd_hsync2vsync |= CDNS_IP_DET_INTERLACE_FORMAT;
1836
1837 cdns_mhdp_reg_write(mhdp, CDNS_BND_HSYNC2VSYNC(stream_id),
1838 bnd_hsync2vsync);
1839
1840 hsync2vsync_pol_ctrl = 0;
1841 if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1842 hsync2vsync_pol_ctrl |= CDNS_H2V_HSYNC_POL_ACTIVE_LOW;
1843 if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1844 hsync2vsync_pol_ctrl |= CDNS_H2V_VSYNC_POL_ACTIVE_LOW;
1845 cdns_mhdp_reg_write(mhdp, CDNS_HSYNC2VSYNC_POL_CTRL(stream_id),
1846 hsync2vsync_pol_ctrl);
1847
1848 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_PXL_REPR(stream_id), pxl_repr);
1849
1850 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1851 dp_framer_sp |= CDNS_DP_FRAMER_INTERLACE;
1852 if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1853 dp_framer_sp |= CDNS_DP_FRAMER_HSYNC_POL_LOW;
1854 if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1855 dp_framer_sp |= CDNS_DP_FRAMER_VSYNC_POL_LOW;
1856 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_SP(stream_id), dp_framer_sp);
1857
1858 front_porch = mode->crtc_hsync_start - mode->crtc_hdisplay;
1859 back_porch = mode->crtc_htotal - mode->crtc_hsync_end;
1860 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRONT_BACK_PORCH(stream_id),
1861 CDNS_DP_FRONT_PORCH(front_porch) |
1862 CDNS_DP_BACK_PORCH(back_porch));
1863
1864 cdns_mhdp_reg_write(mhdp, CDNS_DP_BYTE_COUNT(stream_id),
1865 mode->crtc_hdisplay * bpp / 8);
1866
1867 msa_h0 = mode->crtc_htotal - mode->crtc_hsync_start;
1868 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_0(stream_id),
1869 CDNS_DP_MSAH0_H_TOTAL(mode->crtc_htotal) |
1870 CDNS_DP_MSAH0_HSYNC_START(msa_h0));
1871
1872 hsync = mode->crtc_hsync_end - mode->crtc_hsync_start;
1873 msa_horizontal_1 = CDNS_DP_MSAH1_HSYNC_WIDTH(hsync) |
1874 CDNS_DP_MSAH1_HDISP_WIDTH(mode->crtc_hdisplay);
1875 if (mode->flags & DRM_MODE_FLAG_NHSYNC)
1876 msa_horizontal_1 |= CDNS_DP_MSAH1_HSYNC_POL_LOW;
1877 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_HORIZONTAL_1(stream_id),
1878 msa_horizontal_1);
1879
1880 msa_v0 = mode->crtc_vtotal - mode->crtc_vsync_start;
1881 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_0(stream_id),
1882 CDNS_DP_MSAV0_V_TOTAL(mode->crtc_vtotal) |
1883 CDNS_DP_MSAV0_VSYNC_START(msa_v0));
1884
1885 vsync = mode->crtc_vsync_end - mode->crtc_vsync_start;
1886 msa_vertical_1 = CDNS_DP_MSAV1_VSYNC_WIDTH(vsync) |
1887 CDNS_DP_MSAV1_VDISP_WIDTH(mode->crtc_vdisplay);
1888 if (mode->flags & DRM_MODE_FLAG_NVSYNC)
1889 msa_vertical_1 |= CDNS_DP_MSAV1_VSYNC_POL_LOW;
1890 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_VERTICAL_1(stream_id),
1891 msa_vertical_1);
1892
1893 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
1894 mode->crtc_vtotal % 2 == 0)
1895 misc1 = DP_TEST_INTERLACED;
1896 if (mhdp->display_fmt.y_only)
1897 misc1 |= CDNS_DP_TEST_COLOR_FORMAT_RAW_Y_ONLY;
1898 /* Use VSC SDP for Y420 */
1899 if (pxlfmt == DRM_COLOR_FORMAT_YCBCR420)
1900 misc1 = CDNS_DP_TEST_VSC_SDP;
1901
1902 cdns_mhdp_reg_write(mhdp, CDNS_DP_MSA_MISC(stream_id),
1903 misc0 | (misc1 << 8));
1904
1905 cdns_mhdp_reg_write(mhdp, CDNS_DP_HORIZONTAL(stream_id),
1906 CDNS_DP_H_HSYNC_WIDTH(hsync) |
1907 CDNS_DP_H_H_TOTAL(mode->crtc_hdisplay));
1908
1909 cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_0(stream_id),
1910 CDNS_DP_V0_VHEIGHT(mode->crtc_vdisplay) |
1911 CDNS_DP_V0_VSTART(msa_v0));
1912
1913 dp_vertical_1 = CDNS_DP_V1_VTOTAL(mode->crtc_vtotal);
1914 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
1915 mode->crtc_vtotal % 2 == 0)
1916 dp_vertical_1 |= CDNS_DP_V1_VTOTAL_EVEN;
1917
1918 cdns_mhdp_reg_write(mhdp, CDNS_DP_VERTICAL_1(stream_id), dp_vertical_1);
1919
1920 cdns_mhdp_reg_write_bit(mhdp, CDNS_DP_VB_ID(stream_id), 2, 1,
1921 (mode->flags & DRM_MODE_FLAG_INTERLACE) ?
1922 CDNS_DP_VB_ID_INTERLACED : 0);
1923
1924 ret = cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &framer);
1925 if (ret < 0) {
1926 dev_err(mhdp->dev,
1927 "Failed to read CDNS_DP_FRAMER_GLOBAL_CONFIG %d\n",
1928 ret);
1929 return;
1930 }
1931 framer |= CDNS_DP_FRAMER_EN;
1932 framer &= ~CDNS_DP_NO_VIDEO_MODE;
1933 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, framer);
1934 }
1935
1936 static void cdns_mhdp_sst_enable(struct cdns_mhdp_device *mhdp,
1937 const struct drm_display_mode *mode)
1938 {
1939 u32 rate, vs, required_bandwidth, available_bandwidth;
1940 s32 line_thresh1, line_thresh2, line_thresh = 0;
1941 int pxlclock = mode->crtc_clock;
1942 u32 tu_size = 64;
1943 u32 bpp;
1944
1945 /* Get rate in MSymbols per second per lane */
1946 rate = mhdp->link.rate / 1000;
1947
1948 bpp = cdns_mhdp_get_bpp(&mhdp->display_fmt);
1949
1950 required_bandwidth = pxlclock * bpp / 8;
1951 available_bandwidth = mhdp->link.num_lanes * rate;
1952
1953 vs = tu_size * required_bandwidth / available_bandwidth;
1954 vs /= 1000;
1955
1956 if (vs == tu_size)
1957 vs = tu_size - 1;
1958
1959 line_thresh1 = ((vs + 1) << 5) * 8 / bpp;
1960 line_thresh2 = (pxlclock << 5) / 1000 / rate * (vs + 1) - (1 << 5);
1961 line_thresh = line_thresh1 - line_thresh2 / (s32)mhdp->link.num_lanes;
1962 line_thresh = (line_thresh >> 5) + 2;
1963
1964 mhdp->stream_id = 0;
1965
1966 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_TU,
1967 CDNS_DP_FRAMER_TU_VS(vs) |
1968 CDNS_DP_FRAMER_TU_SIZE(tu_size) |
1969 CDNS_DP_FRAMER_TU_CNT_RST_EN);
1970
1971 cdns_mhdp_reg_write(mhdp, CDNS_DP_LINE_THRESH(0),
1972 line_thresh & GENMASK(5, 0));
1973
1974 cdns_mhdp_reg_write(mhdp, CDNS_DP_STREAM_CONFIG_2(0),
1975 CDNS_DP_SC2_TU_VS_DIFF((tu_size - vs > 3) ?
1976 0 : tu_size - vs));
1977
1978 cdns_mhdp_configure_video(mhdp, mode);
1979 }
1980
1981 static void cdns_mhdp_atomic_enable(struct drm_bridge *bridge,
1982 struct drm_bridge_state *bridge_state)
1983 {
1984 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1985 struct drm_atomic_state *state = bridge_state->base.state;
1986 struct cdns_mhdp_bridge_state *mhdp_state;
1987 struct drm_crtc_state *crtc_state;
1988 struct drm_connector *connector;
1989 struct drm_connector_state *conn_state;
1990 struct drm_bridge_state *new_state;
1991 const struct drm_display_mode *mode;
1992 u32 resp;
1993 int ret;
1994
1995 dev_dbg(mhdp->dev, "bridge enable\n");
1996
1997 mutex_lock(&mhdp->link_mutex);
1998
1999 if (mhdp->plugged && !mhdp->link_up) {
2000 ret = cdns_mhdp_link_up(mhdp);
2001 if (ret < 0)
2002 goto out;
2003 }
2004
2005 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->enable)
2006 mhdp->info->ops->enable(mhdp);
2007
2008 /* Enable VIF clock for stream 0 */
2009 ret = cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2010 if (ret < 0) {
2011 dev_err(mhdp->dev, "Failed to read CDNS_DPTX_CAR %d\n", ret);
2012 goto out;
2013 }
2014
2015 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2016 resp | CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN);
2017
2018 connector = drm_atomic_get_new_connector_for_encoder(state,
2019 bridge->encoder);
2020 if (WARN_ON(!connector))
2021 goto out;
2022
2023 conn_state = drm_atomic_get_new_connector_state(state, connector);
2024 if (WARN_ON(!conn_state))
2025 goto out;
2026
2027 if (mhdp->hdcp_supported &&
2028 mhdp->hw_state == MHDP_HW_READY &&
2029 conn_state->content_protection ==
2030 DRM_MODE_CONTENT_PROTECTION_DESIRED) {
2031 mutex_unlock(&mhdp->link_mutex);
2032 cdns_mhdp_hdcp_enable(mhdp, conn_state->hdcp_content_type);
2033 mutex_lock(&mhdp->link_mutex);
2034 }
2035
2036 crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
2037 if (WARN_ON(!crtc_state))
2038 goto out;
2039
2040 mode = &crtc_state->adjusted_mode;
2041
2042 new_state = drm_atomic_get_new_bridge_state(state, bridge);
2043 if (WARN_ON(!new_state))
2044 goto out;
2045
2046 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2047 mhdp->link.rate)) {
2048 ret = -EINVAL;
2049 goto out;
2050 }
2051
2052 cdns_mhdp_sst_enable(mhdp, mode);
2053
2054 mhdp_state = to_cdns_mhdp_bridge_state(new_state);
2055
2056 mhdp_state->current_mode = drm_mode_duplicate(bridge->dev, mode);
2057 if (!mhdp_state->current_mode)
2058 return;
2059
2060 drm_mode_set_name(mhdp_state->current_mode);
2061
2062 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__, mode->name);
2063
2064 mhdp->bridge_enabled = true;
2065
2066 out:
2067 mutex_unlock(&mhdp->link_mutex);
2068 if (ret < 0)
2069 schedule_work(&mhdp->modeset_retry_work);
2070 }
2071
2072 static void cdns_mhdp_atomic_disable(struct drm_bridge *bridge,
2073 struct drm_bridge_state *bridge_state)
2074 {
2075 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2076 u32 resp;
2077
2078 dev_dbg(mhdp->dev, "%s\n", __func__);
2079
2080 mutex_lock(&mhdp->link_mutex);
2081
2082 if (mhdp->hdcp_supported)
2083 cdns_mhdp_hdcp_disable(mhdp);
2084
2085 mhdp->bridge_enabled = false;
2086 cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
2087 resp &= ~CDNS_DP_FRAMER_EN;
2088 resp |= CDNS_DP_NO_VIDEO_MODE;
2089 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
2090
2091 cdns_mhdp_link_down(mhdp);
2092
2093 /* Disable VIF clock for stream 0 */
2094 cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2095 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2096 resp & ~(CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN));
2097
2098 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->disable)
2099 mhdp->info->ops->disable(mhdp);
2100
2101 mutex_unlock(&mhdp->link_mutex);
2102 }
2103
2104 static void cdns_mhdp_detach(struct drm_bridge *bridge)
2105 {
2106 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2107
2108 dev_dbg(mhdp->dev, "%s\n", __func__);
2109
2110 drm_dp_aux_unregister(&mhdp->aux);
2111
2112 spin_lock(&mhdp->start_lock);
2113
2114 mhdp->bridge_attached = false;
2115
2116 spin_unlock(&mhdp->start_lock);
2117
2118 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2119 }
2120
2121 static struct drm_bridge_state *
2122 cdns_mhdp_bridge_atomic_duplicate_state(struct drm_bridge *bridge)
2123 {
2124 struct cdns_mhdp_bridge_state *state;
2125
2126 state = kzalloc(sizeof(*state), GFP_KERNEL);
2127 if (!state)
2128 return NULL;
2129
2130 __drm_atomic_helper_bridge_duplicate_state(bridge, &state->base);
2131
2132 return &state->base;
2133 }
2134
2135 static void
2136 cdns_mhdp_bridge_atomic_destroy_state(struct drm_bridge *bridge,
2137 struct drm_bridge_state *state)
2138 {
2139 struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2140
2141 cdns_mhdp_state = to_cdns_mhdp_bridge_state(state);
2142
2143 if (cdns_mhdp_state->current_mode) {
2144 drm_mode_destroy(bridge->dev, cdns_mhdp_state->current_mode);
2145 cdns_mhdp_state->current_mode = NULL;
2146 }
2147
2148 kfree(cdns_mhdp_state);
2149 }
2150
2151 static struct drm_bridge_state *
2152 cdns_mhdp_bridge_atomic_reset(struct drm_bridge *bridge)
2153 {
2154 struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2155
2156 cdns_mhdp_state = kzalloc(sizeof(*cdns_mhdp_state), GFP_KERNEL);
2157 if (!cdns_mhdp_state)
2158 return NULL;
2159
2160 __drm_atomic_helper_bridge_reset(bridge, &cdns_mhdp_state->base);
2161
2162 return &cdns_mhdp_state->base;
2163 }
2164
2165 static u32 *cdns_mhdp_get_input_bus_fmts(struct drm_bridge *bridge,
2166 struct drm_bridge_state *bridge_state,
2167 struct drm_crtc_state *crtc_state,
2168 struct drm_connector_state *conn_state,
2169 u32 output_fmt,
2170 unsigned int *num_input_fmts)
2171 {
2172 u32 *input_fmts;
2173
2174 *num_input_fmts = 0;
2175
2176 input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL);
2177 if (!input_fmts)
2178 return NULL;
2179
2180 *num_input_fmts = 1;
2181 input_fmts[0] = MEDIA_BUS_FMT_RGB121212_1X36;
2182
2183 return input_fmts;
2184 }
2185
2186 static int cdns_mhdp_atomic_check(struct drm_bridge *bridge,
2187 struct drm_bridge_state *bridge_state,
2188 struct drm_crtc_state *crtc_state,
2189 struct drm_connector_state *conn_state)
2190 {
2191 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2192 const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
2193
2194 mutex_lock(&mhdp->link_mutex);
2195
2196 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2197 mhdp->link.rate)) {
2198 dev_err(mhdp->dev, "%s: Not enough BW for %s (%u lanes at %u Mbps)\n",
2199 __func__, mode->name, mhdp->link.num_lanes,
2200 mhdp->link.rate / 100);
2201 mutex_unlock(&mhdp->link_mutex);
2202 return -EINVAL;
2203 }
2204
2205 /*
2206 * There might be flags negotiation supported in future.
2207 * Set the bus flags in atomic_check statically for now.
2208 */
2209 if (mhdp->info)
2210 bridge_state->input_bus_cfg.flags = *mhdp->info->input_bus_flags;
2211
2212 mutex_unlock(&mhdp->link_mutex);
2213 return 0;
2214 }
2215
2216 static enum drm_connector_status cdns_mhdp_bridge_detect(struct drm_bridge *bridge)
2217 {
2218 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2219
2220 return cdns_mhdp_detect(mhdp);
2221 }
2222
2223 static const struct drm_edid *cdns_mhdp_bridge_edid_read(struct drm_bridge *bridge,
2224 struct drm_connector *connector)
2225 {
2226 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2227
2228 return cdns_mhdp_edid_read(mhdp, connector);
2229 }
2230
2231 static const struct drm_bridge_funcs cdns_mhdp_bridge_funcs = {
2232 .atomic_enable = cdns_mhdp_atomic_enable,
2233 .atomic_disable = cdns_mhdp_atomic_disable,
2234 .atomic_check = cdns_mhdp_atomic_check,
2235 .attach = cdns_mhdp_attach,
2236 .detach = cdns_mhdp_detach,
2237 .atomic_duplicate_state = cdns_mhdp_bridge_atomic_duplicate_state,
2238 .atomic_destroy_state = cdns_mhdp_bridge_atomic_destroy_state,
2239 .atomic_reset = cdns_mhdp_bridge_atomic_reset,
2240 .atomic_get_input_bus_fmts = cdns_mhdp_get_input_bus_fmts,
2241 .detect = cdns_mhdp_bridge_detect,
2242 .edid_read = cdns_mhdp_bridge_edid_read,
2243 .hpd_enable = cdns_mhdp_bridge_hpd_enable,
2244 .hpd_disable = cdns_mhdp_bridge_hpd_disable,
2245 };
2246
2247 static bool cdns_mhdp_detect_hpd(struct cdns_mhdp_device *mhdp, bool *hpd_pulse)
2248 {
2249 int hpd_event, hpd_status;
2250
2251 *hpd_pulse = false;
2252
2253 hpd_event = cdns_mhdp_read_hpd_event(mhdp);
2254
2255 /* Getting event bits failed, bail out */
2256 if (hpd_event < 0) {
2257 dev_warn(mhdp->dev, "%s: read event failed: %d\n",
2258 __func__, hpd_event);
2259 return false;
2260 }
2261
2262 hpd_status = cdns_mhdp_get_hpd_status(mhdp);
2263 if (hpd_status < 0) {
2264 dev_warn(mhdp->dev, "%s: get hpd status failed: %d\n",
2265 __func__, hpd_status);
2266 return false;
2267 }
2268
2269 if (hpd_event & DPTX_READ_EVENT_HPD_PULSE)
2270 *hpd_pulse = true;
2271
2272 return !!hpd_status;
2273 }
2274
2275 static int cdns_mhdp_update_link_status(struct cdns_mhdp_device *mhdp)
2276 {
2277 struct cdns_mhdp_bridge_state *cdns_bridge_state;
2278 struct drm_display_mode *current_mode;
2279 bool old_plugged = mhdp->plugged;
2280 struct drm_bridge_state *state;
2281 u8 status[DP_LINK_STATUS_SIZE];
2282 bool hpd_pulse;
2283 int ret = 0;
2284
2285 mutex_lock(&mhdp->link_mutex);
2286
2287 mhdp->plugged = cdns_mhdp_detect_hpd(mhdp, &hpd_pulse);
2288
2289 if (!mhdp->plugged) {
2290 cdns_mhdp_link_down(mhdp);
2291 mhdp->link.rate = mhdp->host.link_rate;
2292 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2293 goto out;
2294 }
2295
2296 /*
2297 * If we get a HPD pulse event and we were and still are connected,
2298 * check the link status. If link status is ok, there's nothing to do
2299 * as we don't handle DP interrupts. If link status is bad, continue
2300 * with full link setup.
2301 */
2302 if (hpd_pulse && old_plugged == mhdp->plugged) {
2303 ret = drm_dp_dpcd_read_link_status(&mhdp->aux, status);
2304
2305 /*
2306 * If everything looks fine, just return, as we don't handle
2307 * DP IRQs.
2308 */
2309 if (ret > 0 &&
2310 drm_dp_channel_eq_ok(status, mhdp->link.num_lanes) &&
2311 drm_dp_clock_recovery_ok(status, mhdp->link.num_lanes))
2312 goto out;
2313
2314 /* If link is bad, mark link as down so that we do a new LT */
2315 mhdp->link_up = false;
2316 }
2317
2318 if (!mhdp->link_up) {
2319 ret = cdns_mhdp_link_up(mhdp);
2320 if (ret < 0)
2321 goto out;
2322 }
2323
2324 if (mhdp->bridge_enabled) {
2325 state = drm_priv_to_bridge_state(mhdp->bridge.base.state);
2326 if (!state) {
2327 ret = -EINVAL;
2328 goto out;
2329 }
2330
2331 cdns_bridge_state = to_cdns_mhdp_bridge_state(state);
2332 if (!cdns_bridge_state) {
2333 ret = -EINVAL;
2334 goto out;
2335 }
2336
2337 current_mode = cdns_bridge_state->current_mode;
2338 if (!current_mode) {
2339 ret = -EINVAL;
2340 goto out;
2341 }
2342
2343 if (!cdns_mhdp_bandwidth_ok(mhdp, current_mode, mhdp->link.num_lanes,
2344 mhdp->link.rate)) {
2345 ret = -EINVAL;
2346 goto out;
2347 }
2348
2349 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__,
2350 current_mode->name);
2351
2352 cdns_mhdp_sst_enable(mhdp, current_mode);
2353 }
2354 out:
2355 mutex_unlock(&mhdp->link_mutex);
2356 return ret;
2357 }
2358
2359 static void cdns_mhdp_modeset_retry_fn(struct work_struct *work)
2360 {
2361 struct cdns_mhdp_device *mhdp;
2362 struct drm_connector *conn;
2363
2364 mhdp = container_of(work, typeof(*mhdp), modeset_retry_work);
2365
2366 conn = &mhdp->connector;
2367
2368 /* Grab the locks before changing connector property */
2369 mutex_lock(&conn->dev->mode_config.mutex);
2370
2371 /*
2372 * Set connector link status to BAD and send a Uevent to notify
2373 * userspace to do a modeset.
2374 */
2375 drm_connector_set_link_status_property(conn, DRM_MODE_LINK_STATUS_BAD);
2376 mutex_unlock(&conn->dev->mode_config.mutex);
2377
2378 /* Send Hotplug uevent so userspace can reprobe */
2379 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2380 }
2381
2382 static irqreturn_t cdns_mhdp_irq_handler(int irq, void *data)
2383 {
2384 struct cdns_mhdp_device *mhdp = data;
2385 u32 apb_stat, sw_ev0;
2386 bool bridge_attached;
2387
2388 apb_stat = readl(mhdp->regs + CDNS_APB_INT_STATUS);
2389 if (!(apb_stat & CDNS_APB_INT_MASK_SW_EVENT_INT))
2390 return IRQ_NONE;
2391
2392 sw_ev0 = readl(mhdp->regs + CDNS_SW_EVENT0);
2393
2394 /*
2395 * Calling drm_kms_helper_hotplug_event() when not attached
2396 * to drm device causes an oops because the drm_bridge->dev
2397 * is NULL. See cdns_mhdp_fw_cb() comments for details about the
2398 * problems related drm_kms_helper_hotplug_event() call.
2399 */
2400 spin_lock(&mhdp->start_lock);
2401 bridge_attached = mhdp->bridge_attached;
2402 spin_unlock(&mhdp->start_lock);
2403
2404 if (bridge_attached && (sw_ev0 & CDNS_DPTX_HPD)) {
2405 schedule_work(&mhdp->hpd_work);
2406 }
2407
2408 if (sw_ev0 & ~CDNS_DPTX_HPD) {
2409 mhdp->sw_events |= (sw_ev0 & ~CDNS_DPTX_HPD);
2410 wake_up(&mhdp->sw_events_wq);
2411 }
2412
2413 return IRQ_HANDLED;
2414 }
2415
2416 u32 cdns_mhdp_wait_for_sw_event(struct cdns_mhdp_device *mhdp, u32 event)
2417 {
2418 u32 ret;
2419
2420 ret = wait_event_timeout(mhdp->sw_events_wq,
2421 mhdp->sw_events & event,
2422 msecs_to_jiffies(500));
2423 if (!ret) {
2424 dev_dbg(mhdp->dev, "SW event 0x%x timeout\n", event);
2425 goto sw_event_out;
2426 }
2427
2428 ret = mhdp->sw_events;
2429 mhdp->sw_events &= ~event;
2430
2431 sw_event_out:
2432 return ret;
2433 }
2434
2435 static void cdns_mhdp_hpd_work(struct work_struct *work)
2436 {
2437 struct cdns_mhdp_device *mhdp = container_of(work,
2438 struct cdns_mhdp_device,
2439 hpd_work);
2440 int ret;
2441
2442 ret = cdns_mhdp_update_link_status(mhdp);
2443 if (mhdp->connector.dev) {
2444 if (ret < 0)
2445 schedule_work(&mhdp->modeset_retry_work);
2446 else
2447 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2448 } else {
2449 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
2450 }
2451 }
2452
2453 static int cdns_mhdp_probe(struct platform_device *pdev)
2454 {
2455 struct device *dev = &pdev->dev;
2456 struct cdns_mhdp_device *mhdp;
2457 unsigned long rate;
2458 struct clk *clk;
2459 int ret;
2460 int irq;
2461
2462 mhdp = devm_kzalloc(dev, sizeof(*mhdp), GFP_KERNEL);
2463 if (!mhdp)
2464 return -ENOMEM;
2465
2466 clk = devm_clk_get(dev, NULL);
2467 if (IS_ERR(clk)) {
2468 dev_err(dev, "couldn't get clk: %ld\n", PTR_ERR(clk));
2469 return PTR_ERR(clk);
2470 }
2471
2472 mhdp->clk = clk;
2473 mhdp->dev = dev;
2474 mutex_init(&mhdp->mbox_mutex);
2475 mutex_init(&mhdp->link_mutex);
2476 spin_lock_init(&mhdp->start_lock);
2477
2478 drm_dp_aux_init(&mhdp->aux);
2479 mhdp->aux.dev = dev;
2480 mhdp->aux.transfer = cdns_mhdp_transfer;
2481
2482 mhdp->regs = devm_platform_ioremap_resource(pdev, 0);
2483 if (IS_ERR(mhdp->regs)) {
2484 dev_err(dev, "Failed to get memory resource\n");
2485 return PTR_ERR(mhdp->regs);
2486 }
2487
2488 mhdp->sapb_regs = devm_platform_ioremap_resource_byname(pdev, "mhdptx-sapb");
2489 if (IS_ERR(mhdp->sapb_regs)) {
2490 mhdp->hdcp_supported = false;
2491 dev_warn(dev,
2492 "Failed to get SAPB memory resource, HDCP not supported\n");
2493 } else {
2494 mhdp->hdcp_supported = true;
2495 }
2496
2497 mhdp->phy = devm_of_phy_get_by_index(dev, pdev->dev.of_node, 0);
2498 if (IS_ERR(mhdp->phy)) {
2499 dev_err(dev, "no PHY configured\n");
2500 return PTR_ERR(mhdp->phy);
2501 }
2502
2503 platform_set_drvdata(pdev, mhdp);
2504
2505 mhdp->info = of_device_get_match_data(dev);
2506
2507 clk_prepare_enable(clk);
2508
2509 pm_runtime_enable(dev);
2510 ret = pm_runtime_resume_and_get(dev);
2511 if (ret < 0) {
2512 dev_err(dev, "pm_runtime_resume_and_get failed\n");
2513 pm_runtime_disable(dev);
2514 goto clk_disable;
2515 }
2516
2517 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->init) {
2518 ret = mhdp->info->ops->init(mhdp);
2519 if (ret != 0) {
2520 dev_err(dev, "MHDP platform initialization failed: %d\n",
2521 ret);
2522 goto runtime_put;
2523 }
2524 }
2525
2526 rate = clk_get_rate(clk);
2527 writel(rate % 1000000, mhdp->regs + CDNS_SW_CLK_L);
2528 writel(rate / 1000000, mhdp->regs + CDNS_SW_CLK_H);
2529
2530 dev_dbg(dev, "func clk rate %lu Hz\n", rate);
2531
2532 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2533
2534 irq = platform_get_irq(pdev, 0);
2535 ret = devm_request_threaded_irq(mhdp->dev, irq, NULL,
2536 cdns_mhdp_irq_handler, IRQF_ONESHOT,
2537 "mhdp8546", mhdp);
2538 if (ret) {
2539 dev_err(dev, "cannot install IRQ %d\n", irq);
2540 ret = -EIO;
2541 goto plat_fini;
2542 }
2543
2544 cdns_mhdp_fill_host_caps(mhdp);
2545
2546 /* Initialize link rate and num of lanes to host values */
2547 mhdp->link.rate = mhdp->host.link_rate;
2548 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2549
2550 /* The only currently supported format */
2551 mhdp->display_fmt.y_only = false;
2552 mhdp->display_fmt.color_format = DRM_COLOR_FORMAT_RGB444;
2553 mhdp->display_fmt.bpc = 8;
2554
2555 mhdp->bridge.of_node = pdev->dev.of_node;
2556 mhdp->bridge.funcs = &cdns_mhdp_bridge_funcs;
2557 mhdp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
2558 DRM_BRIDGE_OP_HPD;
2559 mhdp->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
2560
2561 ret = phy_init(mhdp->phy);
2562 if (ret) {
2563 dev_err(mhdp->dev, "Failed to initialize PHY: %d\n", ret);
2564 goto plat_fini;
2565 }
2566
2567 /* Initialize the work for modeset in case of link train failure */
2568 INIT_WORK(&mhdp->modeset_retry_work, cdns_mhdp_modeset_retry_fn);
2569 INIT_WORK(&mhdp->hpd_work, cdns_mhdp_hpd_work);
2570
2571 init_waitqueue_head(&mhdp->fw_load_wq);
2572 init_waitqueue_head(&mhdp->sw_events_wq);
2573
2574 ret = cdns_mhdp_load_firmware(mhdp);
2575 if (ret)
2576 goto phy_exit;
2577
2578 if (mhdp->hdcp_supported)
2579 cdns_mhdp_hdcp_init(mhdp);
2580
2581 drm_bridge_add(&mhdp->bridge);
2582
2583 return 0;
2584
2585 phy_exit:
2586 phy_exit(mhdp->phy);
2587 plat_fini:
2588 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2589 mhdp->info->ops->exit(mhdp);
2590 runtime_put:
2591 pm_runtime_put_sync(dev);
2592 pm_runtime_disable(dev);
2593 clk_disable:
2594 clk_disable_unprepare(mhdp->clk);
2595
2596 return ret;
2597 }
2598
2599 static void cdns_mhdp_remove(struct platform_device *pdev)
2600 {
2601 struct cdns_mhdp_device *mhdp = platform_get_drvdata(pdev);
2602 unsigned long timeout = msecs_to_jiffies(100);
2603 int ret;
2604
2605 drm_bridge_remove(&mhdp->bridge);
2606
2607 ret = wait_event_timeout(mhdp->fw_load_wq,
2608 mhdp->hw_state == MHDP_HW_READY,
2609 timeout);
2610 spin_lock(&mhdp->start_lock);
2611 mhdp->hw_state = MHDP_HW_STOPPED;
2612 spin_unlock(&mhdp->start_lock);
2613
2614 if (ret == 0) {
2615 dev_err(mhdp->dev, "%s: Timeout waiting for fw loading\n",
2616 __func__);
2617 } else {
2618 ret = cdns_mhdp_set_firmware_active(mhdp, false);
2619 if (ret)
2620 dev_err(mhdp->dev, "Failed to stop firmware (%pe)\n",
2621 ERR_PTR(ret));
2622 }
2623
2624 phy_exit(mhdp->phy);
2625
2626 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2627 mhdp->info->ops->exit(mhdp);
2628
2629 pm_runtime_put_sync(&pdev->dev);
2630 pm_runtime_disable(&pdev->dev);
2631
2632 cancel_work_sync(&mhdp->modeset_retry_work);
2633 flush_work(&mhdp->hpd_work);
2634 /* Ignoring mhdp->hdcp.check_work and mhdp->hdcp.prop_work here. */
2635
2636 clk_disable_unprepare(mhdp->clk);
2637 }
2638
2639 static const struct of_device_id mhdp_ids[] = {
2640 { .compatible = "cdns,mhdp8546", },
2641 #ifdef CONFIG_DRM_CDNS_MHDP8546_J721E
2642 { .compatible = "ti,j721e-mhdp8546",
2643 .data = &(const struct cdns_mhdp_platform_info) {
2644 .input_bus_flags = &mhdp_ti_j721e_bridge_input_bus_flags,
2645 .ops = &mhdp_ti_j721e_ops,
2646 },
2647 },
2648 #endif
2649 { /* sentinel */ }
2650 };
2651 MODULE_DEVICE_TABLE(of, mhdp_ids);
2652
2653 static struct platform_driver mhdp_driver = {
2654 .driver = {
2655 .name = "cdns-mhdp8546",
2656 .of_match_table = mhdp_ids,
2657 },
2658 .probe = cdns_mhdp_probe,
2659 .remove = cdns_mhdp_remove,
2660 };
2661 module_platform_driver(mhdp_driver);
2662
2663 MODULE_FIRMWARE(FW_NAME);
2664
2665 MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
2666 MODULE_AUTHOR("Swapnil Jakhade <sjakhade@cadence.com>");
2667 MODULE_AUTHOR("Yuti Amonkar <yamonkar@cadence.com>");
2668 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
2669 MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");
2670 MODULE_DESCRIPTION("Cadence MHDP8546 DP bridge driver");
2671 MODULE_LICENSE("GPL");
2672 MODULE_ALIAS("platform:cdns-mhdp8546");
Linux Kernel