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
cdns_mhdp_bridge_hpd_enable(struct drm_bridge * bridge)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
cdns_mhdp_bridge_hpd_disable(struct drm_bridge * bridge)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
cdns_mhdp_mailbox_read(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_mailbox_write(struct cdns_mhdp_device * mhdp,u8 val)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
cdns_mhdp_mailbox_recv_header(struct cdns_mhdp_device * mhdp,u8 module_id,u8 opcode,u16 req_size)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
cdns_mhdp_mailbox_recv_data(struct cdns_mhdp_device * mhdp,u8 * buff,u16 buff_size)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
cdns_mhdp_mailbox_send(struct cdns_mhdp_device * mhdp,u8 module_id,u8 opcode,u16 size,u8 * message)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
cdns_mhdp_reg_read(struct cdns_mhdp_device * mhdp,u32 addr,u32 * value)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
cdns_mhdp_reg_write(struct cdns_mhdp_device * mhdp,u16 addr,u32 val)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
cdns_mhdp_reg_write_bit(struct cdns_mhdp_device * mhdp,u16 addr,u8 start_bit,u8 bits_no,u32 val)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
cdns_mhdp_dpcd_read(struct cdns_mhdp_device * mhdp,u32 addr,u8 * data,u16 len)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
cdns_mhdp_dpcd_write(struct cdns_mhdp_device * mhdp,u32 addr,u8 value)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
cdns_mhdp_set_firmware_active(struct cdns_mhdp_device * mhdp,bool enable)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
cdns_mhdp_get_hpd_status(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_get_edid_block(void * data,u8 * edid,unsigned int block,size_t length)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
cdns_mhdp_read_hpd_event(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_adjust_lt(struct cdns_mhdp_device * mhdp,unsigned int nlanes,unsigned int udelay,const u8 * lanes_data,u8 link_status[DP_LINK_STATUS_SIZE])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
cdns_mhdp_link_power_up(struct drm_dp_aux * aux,struct cdns_mhdp_link * link)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
cdns_mhdp_link_power_down(struct drm_dp_aux * aux,struct cdns_mhdp_link * link)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
cdns_mhdp_link_configure(struct drm_dp_aux * aux,struct cdns_mhdp_link * link)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
cdns_mhdp_max_link_rate(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_max_num_lanes(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_eq_training_pattern_supported(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_get_ssc_supported(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_detect(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_check_fw_version(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_fw_activate(const struct firmware * fw,struct cdns_mhdp_device * mhdp)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
cdns_mhdp_fw_cb(const struct firmware * fw,void * context)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
cdns_mhdp_load_firmware(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_transfer(struct drm_dp_aux * aux,struct drm_dp_aux_msg * msg)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
cdns_mhdp_link_training_init(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_get_adjust_train(struct cdns_mhdp_device * mhdp,u8 link_status[DP_LINK_STATUS_SIZE],u8 lanes_data[CDNS_DP_MAX_NUM_LANES],union phy_configure_opts * phy_cfg)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
cdns_mhdp_set_adjust_request_voltage(u8 link_status[DP_LINK_STATUS_SIZE],unsigned int lane,u8 volt)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
cdns_mhdp_set_adjust_request_pre_emphasis(u8 link_status[DP_LINK_STATUS_SIZE],unsigned int lane,u8 pre_emphasis)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
cdns_mhdp_adjust_requested_eq(struct cdns_mhdp_device * mhdp,u8 link_status[DP_LINK_STATUS_SIZE])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
cdns_mhdp_print_lt_status(const char * prefix,struct cdns_mhdp_device * mhdp,union phy_configure_opts * phy_cfg)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
cdns_mhdp_link_training_channel_eq(struct cdns_mhdp_device * mhdp,u8 eq_tps,unsigned int training_interval)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
cdns_mhdp_adjust_requested_cr(struct cdns_mhdp_device * mhdp,u8 link_status[DP_LINK_STATUS_SIZE],u8 * req_volt,u8 * req_pre)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
cdns_mhdp_validate_cr(struct cdns_mhdp_device * mhdp,bool * cr_done,bool * same_before_adjust,bool * max_swing_reached,u8 before_cr[CDNS_DP_MAX_NUM_LANES],u8 after_cr[DP_LINK_STATUS_SIZE],u8 * req_volt,u8 * req_pre)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
cdns_mhdp_link_training_cr(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_lower_link_rate(struct cdns_mhdp_link * link)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
cdns_mhdp_link_training(struct cdns_mhdp_device * mhdp,unsigned int training_interval)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, ®32);
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
cdns_mhdp_get_training_interval_us(struct cdns_mhdp_device * mhdp,u32 interval)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
cdns_mhdp_fill_host_caps(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_fill_sink_caps(struct cdns_mhdp_device * mhdp,u8 dpcd[DP_RECEIVER_CAP_SIZE])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
cdns_mhdp_link_up(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_link_down(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_edid_read(struct cdns_mhdp_device * mhdp,struct drm_connector * connector)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
cdns_mhdp_get_modes(struct drm_connector * connector)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
cdns_mhdp_connector_detect(struct drm_connector * conn,struct drm_modeset_acquire_ctx * ctx,bool force)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
cdns_mhdp_get_bpp(struct cdns_mhdp_display_fmt * fmt)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
cdns_mhdp_bandwidth_ok(struct cdns_mhdp_device * mhdp,const struct drm_display_mode * mode,unsigned int lanes,unsigned int rate)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
cdns_mhdp_mode_valid(struct drm_connector * conn,const struct drm_display_mode * mode)1621 enum drm_mode_status cdns_mhdp_mode_valid(struct drm_connector *conn,
1622 const 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
cdns_mhdp_connector_atomic_check(struct drm_connector * conn,struct drm_atomic_state * state)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
cdns_mhdp_connector_init(struct cdns_mhdp_device * mhdp)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
cdns_mhdp_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)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
cdns_mhdp_configure_video(struct cdns_mhdp_device * mhdp,const struct drm_display_mode * mode)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
cdns_mhdp_sst_enable(struct cdns_mhdp_device * mhdp,const struct drm_display_mode * mode)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
cdns_mhdp_atomic_enable(struct drm_bridge * bridge,struct drm_atomic_state * state)1981 static void cdns_mhdp_atomic_enable(struct drm_bridge *bridge,
1982 struct drm_atomic_state *state)
1983 {
1984 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
1985 struct cdns_mhdp_bridge_state *mhdp_state;
1986 struct drm_crtc_state *crtc_state;
1987 struct drm_connector *connector;
1988 struct drm_connector_state *conn_state;
1989 struct drm_bridge_state *new_state;
1990 const struct drm_display_mode *mode;
1991 u32 resp;
1992 int ret;
1993
1994 dev_dbg(mhdp->dev, "bridge enable\n");
1995
1996 mutex_lock(&mhdp->link_mutex);
1997
1998 if (mhdp->plugged && !mhdp->link_up) {
1999 ret = cdns_mhdp_link_up(mhdp);
2000 if (ret < 0)
2001 goto out;
2002 }
2003
2004 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->enable)
2005 mhdp->info->ops->enable(mhdp);
2006
2007 /* Enable VIF clock for stream 0 */
2008 ret = cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2009 if (ret < 0) {
2010 dev_err(mhdp->dev, "Failed to read CDNS_DPTX_CAR %d\n", ret);
2011 goto out;
2012 }
2013
2014 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2015 resp | CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN);
2016
2017 connector = drm_atomic_get_new_connector_for_encoder(state,
2018 bridge->encoder);
2019 if (WARN_ON(!connector))
2020 goto out;
2021
2022 conn_state = drm_atomic_get_new_connector_state(state, connector);
2023 if (WARN_ON(!conn_state))
2024 goto out;
2025
2026 if (mhdp->hdcp_supported &&
2027 mhdp->hw_state == MHDP_HW_READY &&
2028 conn_state->content_protection ==
2029 DRM_MODE_CONTENT_PROTECTION_DESIRED) {
2030 mutex_unlock(&mhdp->link_mutex);
2031 cdns_mhdp_hdcp_enable(mhdp, conn_state->hdcp_content_type);
2032 mutex_lock(&mhdp->link_mutex);
2033 }
2034
2035 crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
2036 if (WARN_ON(!crtc_state))
2037 goto out;
2038
2039 mode = &crtc_state->adjusted_mode;
2040
2041 new_state = drm_atomic_get_new_bridge_state(state, bridge);
2042 if (WARN_ON(!new_state))
2043 goto out;
2044
2045 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2046 mhdp->link.rate)) {
2047 ret = -EINVAL;
2048 goto out;
2049 }
2050
2051 cdns_mhdp_sst_enable(mhdp, mode);
2052
2053 mhdp_state = to_cdns_mhdp_bridge_state(new_state);
2054
2055 mhdp_state->current_mode = drm_mode_duplicate(bridge->dev, mode);
2056 if (!mhdp_state->current_mode)
2057 return;
2058
2059 drm_mode_set_name(mhdp_state->current_mode);
2060
2061 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__, mode->name);
2062
2063 mhdp->bridge_enabled = true;
2064
2065 out:
2066 mutex_unlock(&mhdp->link_mutex);
2067 if (ret < 0)
2068 schedule_work(&mhdp->modeset_retry_work);
2069 }
2070
cdns_mhdp_atomic_disable(struct drm_bridge * bridge,struct drm_atomic_state * state)2071 static void cdns_mhdp_atomic_disable(struct drm_bridge *bridge,
2072 struct drm_atomic_state *state)
2073 {
2074 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2075 u32 resp;
2076
2077 dev_dbg(mhdp->dev, "%s\n", __func__);
2078
2079 mutex_lock(&mhdp->link_mutex);
2080
2081 if (mhdp->hdcp_supported)
2082 cdns_mhdp_hdcp_disable(mhdp);
2083
2084 mhdp->bridge_enabled = false;
2085 cdns_mhdp_reg_read(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, &resp);
2086 resp &= ~CDNS_DP_FRAMER_EN;
2087 resp |= CDNS_DP_NO_VIDEO_MODE;
2088 cdns_mhdp_reg_write(mhdp, CDNS_DP_FRAMER_GLOBAL_CONFIG, resp);
2089
2090 cdns_mhdp_link_down(mhdp);
2091
2092 /* Disable VIF clock for stream 0 */
2093 cdns_mhdp_reg_read(mhdp, CDNS_DPTX_CAR, &resp);
2094 cdns_mhdp_reg_write(mhdp, CDNS_DPTX_CAR,
2095 resp & ~(CDNS_VIF_CLK_EN | CDNS_VIF_CLK_RSTN));
2096
2097 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->disable)
2098 mhdp->info->ops->disable(mhdp);
2099
2100 mutex_unlock(&mhdp->link_mutex);
2101 }
2102
cdns_mhdp_detach(struct drm_bridge * bridge)2103 static void cdns_mhdp_detach(struct drm_bridge *bridge)
2104 {
2105 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2106
2107 dev_dbg(mhdp->dev, "%s\n", __func__);
2108
2109 drm_dp_aux_unregister(&mhdp->aux);
2110
2111 spin_lock(&mhdp->start_lock);
2112
2113 mhdp->bridge_attached = false;
2114
2115 spin_unlock(&mhdp->start_lock);
2116
2117 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2118 }
2119
2120 static struct drm_bridge_state *
cdns_mhdp_bridge_atomic_duplicate_state(struct drm_bridge * bridge)2121 cdns_mhdp_bridge_atomic_duplicate_state(struct drm_bridge *bridge)
2122 {
2123 struct cdns_mhdp_bridge_state *state;
2124
2125 state = kzalloc(sizeof(*state), GFP_KERNEL);
2126 if (!state)
2127 return NULL;
2128
2129 __drm_atomic_helper_bridge_duplicate_state(bridge, &state->base);
2130
2131 return &state->base;
2132 }
2133
2134 static void
cdns_mhdp_bridge_atomic_destroy_state(struct drm_bridge * bridge,struct drm_bridge_state * state)2135 cdns_mhdp_bridge_atomic_destroy_state(struct drm_bridge *bridge,
2136 struct drm_bridge_state *state)
2137 {
2138 struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2139
2140 cdns_mhdp_state = to_cdns_mhdp_bridge_state(state);
2141
2142 if (cdns_mhdp_state->current_mode) {
2143 drm_mode_destroy(bridge->dev, cdns_mhdp_state->current_mode);
2144 cdns_mhdp_state->current_mode = NULL;
2145 }
2146
2147 kfree(cdns_mhdp_state);
2148 }
2149
2150 static struct drm_bridge_state *
cdns_mhdp_bridge_atomic_reset(struct drm_bridge * bridge)2151 cdns_mhdp_bridge_atomic_reset(struct drm_bridge *bridge)
2152 {
2153 struct cdns_mhdp_bridge_state *cdns_mhdp_state;
2154
2155 cdns_mhdp_state = kzalloc(sizeof(*cdns_mhdp_state), GFP_KERNEL);
2156 if (!cdns_mhdp_state)
2157 return NULL;
2158
2159 __drm_atomic_helper_bridge_reset(bridge, &cdns_mhdp_state->base);
2160
2161 return &cdns_mhdp_state->base;
2162 }
2163
cdns_mhdp_get_input_bus_fmts(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state,u32 output_fmt,unsigned int * num_input_fmts)2164 static u32 *cdns_mhdp_get_input_bus_fmts(struct drm_bridge *bridge,
2165 struct drm_bridge_state *bridge_state,
2166 struct drm_crtc_state *crtc_state,
2167 struct drm_connector_state *conn_state,
2168 u32 output_fmt,
2169 unsigned int *num_input_fmts)
2170 {
2171 u32 *input_fmts;
2172
2173 *num_input_fmts = 0;
2174
2175 input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL);
2176 if (!input_fmts)
2177 return NULL;
2178
2179 *num_input_fmts = 1;
2180 input_fmts[0] = MEDIA_BUS_FMT_RGB121212_1X36;
2181
2182 return input_fmts;
2183 }
2184
cdns_mhdp_atomic_check(struct drm_bridge * bridge,struct drm_bridge_state * bridge_state,struct drm_crtc_state * crtc_state,struct drm_connector_state * conn_state)2185 static int cdns_mhdp_atomic_check(struct drm_bridge *bridge,
2186 struct drm_bridge_state *bridge_state,
2187 struct drm_crtc_state *crtc_state,
2188 struct drm_connector_state *conn_state)
2189 {
2190 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2191 const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
2192
2193 mutex_lock(&mhdp->link_mutex);
2194
2195 if (!cdns_mhdp_bandwidth_ok(mhdp, mode, mhdp->link.num_lanes,
2196 mhdp->link.rate)) {
2197 dev_err(mhdp->dev, "%s: Not enough BW for %s (%u lanes at %u Mbps)\n",
2198 __func__, mode->name, mhdp->link.num_lanes,
2199 mhdp->link.rate / 100);
2200 mutex_unlock(&mhdp->link_mutex);
2201 return -EINVAL;
2202 }
2203
2204 /*
2205 * There might be flags negotiation supported in future.
2206 * Set the bus flags in atomic_check statically for now.
2207 */
2208 if (mhdp->info)
2209 bridge_state->input_bus_cfg.flags = *mhdp->info->input_bus_flags;
2210
2211 mutex_unlock(&mhdp->link_mutex);
2212 return 0;
2213 }
2214
cdns_mhdp_bridge_detect(struct drm_bridge * bridge)2215 static enum drm_connector_status cdns_mhdp_bridge_detect(struct drm_bridge *bridge)
2216 {
2217 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2218
2219 return cdns_mhdp_detect(mhdp);
2220 }
2221
cdns_mhdp_bridge_edid_read(struct drm_bridge * bridge,struct drm_connector * connector)2222 static const struct drm_edid *cdns_mhdp_bridge_edid_read(struct drm_bridge *bridge,
2223 struct drm_connector *connector)
2224 {
2225 struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
2226
2227 return cdns_mhdp_edid_read(mhdp, connector);
2228 }
2229
2230 static const struct drm_bridge_funcs cdns_mhdp_bridge_funcs = {
2231 .atomic_enable = cdns_mhdp_atomic_enable,
2232 .atomic_disable = cdns_mhdp_atomic_disable,
2233 .atomic_check = cdns_mhdp_atomic_check,
2234 .attach = cdns_mhdp_attach,
2235 .detach = cdns_mhdp_detach,
2236 .atomic_duplicate_state = cdns_mhdp_bridge_atomic_duplicate_state,
2237 .atomic_destroy_state = cdns_mhdp_bridge_atomic_destroy_state,
2238 .atomic_reset = cdns_mhdp_bridge_atomic_reset,
2239 .atomic_get_input_bus_fmts = cdns_mhdp_get_input_bus_fmts,
2240 .detect = cdns_mhdp_bridge_detect,
2241 .edid_read = cdns_mhdp_bridge_edid_read,
2242 .hpd_enable = cdns_mhdp_bridge_hpd_enable,
2243 .hpd_disable = cdns_mhdp_bridge_hpd_disable,
2244 };
2245
cdns_mhdp_detect_hpd(struct cdns_mhdp_device * mhdp,bool * hpd_pulse)2246 static bool cdns_mhdp_detect_hpd(struct cdns_mhdp_device *mhdp, bool *hpd_pulse)
2247 {
2248 int hpd_event, hpd_status;
2249
2250 *hpd_pulse = false;
2251
2252 hpd_event = cdns_mhdp_read_hpd_event(mhdp);
2253
2254 /* Getting event bits failed, bail out */
2255 if (hpd_event < 0) {
2256 dev_warn(mhdp->dev, "%s: read event failed: %d\n",
2257 __func__, hpd_event);
2258 return false;
2259 }
2260
2261 hpd_status = cdns_mhdp_get_hpd_status(mhdp);
2262 if (hpd_status < 0) {
2263 dev_warn(mhdp->dev, "%s: get hpd status failed: %d\n",
2264 __func__, hpd_status);
2265 return false;
2266 }
2267
2268 if (hpd_event & DPTX_READ_EVENT_HPD_PULSE)
2269 *hpd_pulse = true;
2270
2271 return !!hpd_status;
2272 }
2273
cdns_mhdp_update_link_status(struct cdns_mhdp_device * mhdp)2274 static int cdns_mhdp_update_link_status(struct cdns_mhdp_device *mhdp)
2275 {
2276 struct cdns_mhdp_bridge_state *cdns_bridge_state;
2277 struct drm_display_mode *current_mode;
2278 bool old_plugged = mhdp->plugged;
2279 struct drm_bridge_state *state;
2280 u8 status[DP_LINK_STATUS_SIZE];
2281 bool hpd_pulse;
2282 int ret = 0;
2283
2284 mutex_lock(&mhdp->link_mutex);
2285
2286 mhdp->plugged = cdns_mhdp_detect_hpd(mhdp, &hpd_pulse);
2287
2288 if (!mhdp->plugged) {
2289 cdns_mhdp_link_down(mhdp);
2290 mhdp->link.rate = mhdp->host.link_rate;
2291 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2292 goto out;
2293 }
2294
2295 /*
2296 * If we get a HPD pulse event and we were and still are connected,
2297 * check the link status. If link status is ok, there's nothing to do
2298 * as we don't handle DP interrupts. If link status is bad, continue
2299 * with full link setup.
2300 */
2301 if (hpd_pulse && old_plugged == mhdp->plugged) {
2302 ret = drm_dp_dpcd_read_link_status(&mhdp->aux, status);
2303
2304 /*
2305 * If everything looks fine, just return, as we don't handle
2306 * DP IRQs.
2307 */
2308 if (ret > 0 &&
2309 drm_dp_channel_eq_ok(status, mhdp->link.num_lanes) &&
2310 drm_dp_clock_recovery_ok(status, mhdp->link.num_lanes))
2311 goto out;
2312
2313 /* If link is bad, mark link as down so that we do a new LT */
2314 mhdp->link_up = false;
2315 }
2316
2317 if (!mhdp->link_up) {
2318 ret = cdns_mhdp_link_up(mhdp);
2319 if (ret < 0)
2320 goto out;
2321 }
2322
2323 if (mhdp->bridge_enabled) {
2324 state = drm_priv_to_bridge_state(mhdp->bridge.base.state);
2325 if (!state) {
2326 ret = -EINVAL;
2327 goto out;
2328 }
2329
2330 cdns_bridge_state = to_cdns_mhdp_bridge_state(state);
2331 if (!cdns_bridge_state) {
2332 ret = -EINVAL;
2333 goto out;
2334 }
2335
2336 current_mode = cdns_bridge_state->current_mode;
2337 if (!current_mode) {
2338 ret = -EINVAL;
2339 goto out;
2340 }
2341
2342 if (!cdns_mhdp_bandwidth_ok(mhdp, current_mode, mhdp->link.num_lanes,
2343 mhdp->link.rate)) {
2344 ret = -EINVAL;
2345 goto out;
2346 }
2347
2348 dev_dbg(mhdp->dev, "%s: Enabling mode %s\n", __func__,
2349 current_mode->name);
2350
2351 cdns_mhdp_sst_enable(mhdp, current_mode);
2352 }
2353 out:
2354 mutex_unlock(&mhdp->link_mutex);
2355 return ret;
2356 }
2357
cdns_mhdp_modeset_retry_fn(struct work_struct * work)2358 static void cdns_mhdp_modeset_retry_fn(struct work_struct *work)
2359 {
2360 struct cdns_mhdp_device *mhdp;
2361 struct drm_connector *conn;
2362
2363 mhdp = container_of(work, typeof(*mhdp), modeset_retry_work);
2364
2365 conn = &mhdp->connector;
2366
2367 /* Grab the locks before changing connector property */
2368 mutex_lock(&conn->dev->mode_config.mutex);
2369
2370 /*
2371 * Set connector link status to BAD and send a Uevent to notify
2372 * userspace to do a modeset.
2373 */
2374 drm_connector_set_link_status_property(conn, DRM_MODE_LINK_STATUS_BAD);
2375 mutex_unlock(&conn->dev->mode_config.mutex);
2376
2377 /* Send Hotplug uevent so userspace can reprobe */
2378 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2379 }
2380
cdns_mhdp_irq_handler(int irq,void * data)2381 static irqreturn_t cdns_mhdp_irq_handler(int irq, void *data)
2382 {
2383 struct cdns_mhdp_device *mhdp = data;
2384 u32 apb_stat, sw_ev0;
2385 bool bridge_attached;
2386
2387 apb_stat = readl(mhdp->regs + CDNS_APB_INT_STATUS);
2388 if (!(apb_stat & CDNS_APB_INT_MASK_SW_EVENT_INT))
2389 return IRQ_NONE;
2390
2391 sw_ev0 = readl(mhdp->regs + CDNS_SW_EVENT0);
2392
2393 /*
2394 * Calling drm_kms_helper_hotplug_event() when not attached
2395 * to drm device causes an oops because the drm_bridge->dev
2396 * is NULL. See cdns_mhdp_fw_cb() comments for details about the
2397 * problems related drm_kms_helper_hotplug_event() call.
2398 */
2399 spin_lock(&mhdp->start_lock);
2400 bridge_attached = mhdp->bridge_attached;
2401 spin_unlock(&mhdp->start_lock);
2402
2403 if (bridge_attached && (sw_ev0 & CDNS_DPTX_HPD)) {
2404 schedule_work(&mhdp->hpd_work);
2405 }
2406
2407 if (sw_ev0 & ~CDNS_DPTX_HPD) {
2408 mhdp->sw_events |= (sw_ev0 & ~CDNS_DPTX_HPD);
2409 wake_up(&mhdp->sw_events_wq);
2410 }
2411
2412 return IRQ_HANDLED;
2413 }
2414
cdns_mhdp_wait_for_sw_event(struct cdns_mhdp_device * mhdp,u32 event)2415 u32 cdns_mhdp_wait_for_sw_event(struct cdns_mhdp_device *mhdp, u32 event)
2416 {
2417 u32 ret;
2418
2419 ret = wait_event_timeout(mhdp->sw_events_wq,
2420 mhdp->sw_events & event,
2421 msecs_to_jiffies(500));
2422 if (!ret) {
2423 dev_dbg(mhdp->dev, "SW event 0x%x timeout\n", event);
2424 goto sw_event_out;
2425 }
2426
2427 ret = mhdp->sw_events;
2428 mhdp->sw_events &= ~event;
2429
2430 sw_event_out:
2431 return ret;
2432 }
2433
cdns_mhdp_hpd_work(struct work_struct * work)2434 static void cdns_mhdp_hpd_work(struct work_struct *work)
2435 {
2436 struct cdns_mhdp_device *mhdp = container_of(work,
2437 struct cdns_mhdp_device,
2438 hpd_work);
2439 int ret;
2440
2441 ret = cdns_mhdp_update_link_status(mhdp);
2442 if (mhdp->connector.dev) {
2443 if (ret < 0)
2444 schedule_work(&mhdp->modeset_retry_work);
2445 else
2446 drm_kms_helper_hotplug_event(mhdp->bridge.dev);
2447 } else {
2448 drm_bridge_hpd_notify(&mhdp->bridge, cdns_mhdp_detect(mhdp));
2449 }
2450 }
2451
cdns_mhdp_probe(struct platform_device * pdev)2452 static int cdns_mhdp_probe(struct platform_device *pdev)
2453 {
2454 struct device *dev = &pdev->dev;
2455 struct cdns_mhdp_device *mhdp;
2456 unsigned long rate;
2457 struct clk *clk;
2458 int ret;
2459 int irq;
2460
2461 mhdp = devm_kzalloc(dev, sizeof(*mhdp), GFP_KERNEL);
2462 if (!mhdp)
2463 return -ENOMEM;
2464
2465 clk = devm_clk_get_enabled(dev, NULL);
2466 if (IS_ERR(clk)) {
2467 dev_err(dev, "couldn't get and enable clk: %ld\n", PTR_ERR(clk));
2468 return PTR_ERR(clk);
2469 }
2470
2471 mhdp->clk = clk;
2472 mhdp->dev = dev;
2473 mutex_init(&mhdp->mbox_mutex);
2474 mutex_init(&mhdp->link_mutex);
2475 spin_lock_init(&mhdp->start_lock);
2476
2477 drm_dp_aux_init(&mhdp->aux);
2478 mhdp->aux.dev = dev;
2479 mhdp->aux.transfer = cdns_mhdp_transfer;
2480
2481 mhdp->regs = devm_platform_ioremap_resource(pdev, 0);
2482 if (IS_ERR(mhdp->regs)) {
2483 dev_err(dev, "Failed to get memory resource\n");
2484 return PTR_ERR(mhdp->regs);
2485 }
2486
2487 mhdp->sapb_regs = devm_platform_ioremap_resource_byname(pdev, "mhdptx-sapb");
2488 if (IS_ERR(mhdp->sapb_regs)) {
2489 mhdp->hdcp_supported = false;
2490 dev_warn(dev,
2491 "Failed to get SAPB memory resource, HDCP not supported\n");
2492 } else {
2493 mhdp->hdcp_supported = true;
2494 }
2495
2496 mhdp->phy = devm_of_phy_get_by_index(dev, pdev->dev.of_node, 0);
2497 if (IS_ERR(mhdp->phy)) {
2498 dev_err(dev, "no PHY configured\n");
2499 return PTR_ERR(mhdp->phy);
2500 }
2501
2502 platform_set_drvdata(pdev, mhdp);
2503
2504 mhdp->info = of_device_get_match_data(dev);
2505
2506 pm_runtime_enable(dev);
2507 ret = pm_runtime_resume_and_get(dev);
2508 if (ret < 0) {
2509 dev_err(dev, "pm_runtime_resume_and_get failed\n");
2510 pm_runtime_disable(dev);
2511 return ret;
2512 }
2513
2514 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->init) {
2515 ret = mhdp->info->ops->init(mhdp);
2516 if (ret != 0) {
2517 dev_err(dev, "MHDP platform initialization failed: %d\n",
2518 ret);
2519 goto runtime_put;
2520 }
2521 }
2522
2523 rate = clk_get_rate(clk);
2524 writel(rate % 1000000, mhdp->regs + CDNS_SW_CLK_L);
2525 writel(rate / 1000000, mhdp->regs + CDNS_SW_CLK_H);
2526
2527 dev_dbg(dev, "func clk rate %lu Hz\n", rate);
2528
2529 writel(~0, mhdp->regs + CDNS_APB_INT_MASK);
2530
2531 irq = platform_get_irq(pdev, 0);
2532 ret = devm_request_threaded_irq(mhdp->dev, irq, NULL,
2533 cdns_mhdp_irq_handler, IRQF_ONESHOT,
2534 "mhdp8546", mhdp);
2535 if (ret) {
2536 dev_err(dev, "cannot install IRQ %d\n", irq);
2537 ret = -EIO;
2538 goto plat_fini;
2539 }
2540
2541 cdns_mhdp_fill_host_caps(mhdp);
2542
2543 /* Initialize link rate and num of lanes to host values */
2544 mhdp->link.rate = mhdp->host.link_rate;
2545 mhdp->link.num_lanes = mhdp->host.lanes_cnt;
2546
2547 /* The only currently supported format */
2548 mhdp->display_fmt.y_only = false;
2549 mhdp->display_fmt.color_format = DRM_COLOR_FORMAT_RGB444;
2550 mhdp->display_fmt.bpc = 8;
2551
2552 mhdp->bridge.of_node = pdev->dev.of_node;
2553 mhdp->bridge.funcs = &cdns_mhdp_bridge_funcs;
2554 mhdp->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
2555 DRM_BRIDGE_OP_HPD;
2556 mhdp->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
2557
2558 ret = phy_init(mhdp->phy);
2559 if (ret) {
2560 dev_err(mhdp->dev, "Failed to initialize PHY: %d\n", ret);
2561 goto plat_fini;
2562 }
2563
2564 /* Initialize the work for modeset in case of link train failure */
2565 INIT_WORK(&mhdp->modeset_retry_work, cdns_mhdp_modeset_retry_fn);
2566 INIT_WORK(&mhdp->hpd_work, cdns_mhdp_hpd_work);
2567
2568 init_waitqueue_head(&mhdp->fw_load_wq);
2569 init_waitqueue_head(&mhdp->sw_events_wq);
2570
2571 ret = cdns_mhdp_load_firmware(mhdp);
2572 if (ret)
2573 goto phy_exit;
2574
2575 if (mhdp->hdcp_supported)
2576 cdns_mhdp_hdcp_init(mhdp);
2577
2578 drm_bridge_add(&mhdp->bridge);
2579
2580 return 0;
2581
2582 phy_exit:
2583 phy_exit(mhdp->phy);
2584 plat_fini:
2585 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2586 mhdp->info->ops->exit(mhdp);
2587 runtime_put:
2588 pm_runtime_put_sync(dev);
2589 pm_runtime_disable(dev);
2590
2591 return ret;
2592 }
2593
cdns_mhdp_remove(struct platform_device * pdev)2594 static void cdns_mhdp_remove(struct platform_device *pdev)
2595 {
2596 struct cdns_mhdp_device *mhdp = platform_get_drvdata(pdev);
2597 unsigned long timeout = msecs_to_jiffies(100);
2598 int ret;
2599
2600 drm_bridge_remove(&mhdp->bridge);
2601
2602 ret = wait_event_timeout(mhdp->fw_load_wq,
2603 mhdp->hw_state == MHDP_HW_READY,
2604 timeout);
2605 spin_lock(&mhdp->start_lock);
2606 mhdp->hw_state = MHDP_HW_STOPPED;
2607 spin_unlock(&mhdp->start_lock);
2608
2609 if (ret == 0) {
2610 dev_err(mhdp->dev, "%s: Timeout waiting for fw loading\n",
2611 __func__);
2612 } else {
2613 ret = cdns_mhdp_set_firmware_active(mhdp, false);
2614 if (ret)
2615 dev_err(mhdp->dev, "Failed to stop firmware (%pe)\n",
2616 ERR_PTR(ret));
2617 }
2618
2619 phy_exit(mhdp->phy);
2620
2621 if (mhdp->info && mhdp->info->ops && mhdp->info->ops->exit)
2622 mhdp->info->ops->exit(mhdp);
2623
2624 pm_runtime_put_sync(&pdev->dev);
2625 pm_runtime_disable(&pdev->dev);
2626
2627 cancel_work_sync(&mhdp->modeset_retry_work);
2628 flush_work(&mhdp->hpd_work);
2629 /* Ignoring mhdp->hdcp.check_work and mhdp->hdcp.prop_work here. */
2630 }
2631
2632 static const struct of_device_id mhdp_ids[] = {
2633 { .compatible = "cdns,mhdp8546", },
2634 #ifdef CONFIG_DRM_CDNS_MHDP8546_J721E
2635 { .compatible = "ti,j721e-mhdp8546",
2636 .data = &(const struct cdns_mhdp_platform_info) {
2637 .input_bus_flags = &mhdp_ti_j721e_bridge_input_bus_flags,
2638 .ops = &mhdp_ti_j721e_ops,
2639 },
2640 },
2641 #endif
2642 { /* sentinel */ }
2643 };
2644 MODULE_DEVICE_TABLE(of, mhdp_ids);
2645
2646 static struct platform_driver mhdp_driver = {
2647 .driver = {
2648 .name = "cdns-mhdp8546",
2649 .of_match_table = mhdp_ids,
2650 },
2651 .probe = cdns_mhdp_probe,
2652 .remove = cdns_mhdp_remove,
2653 };
2654 module_platform_driver(mhdp_driver);
2655
2656 MODULE_FIRMWARE(FW_NAME);
2657
2658 MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
2659 MODULE_AUTHOR("Swapnil Jakhade <sjakhade@cadence.com>");
2660 MODULE_AUTHOR("Yuti Amonkar <yamonkar@cadence.com>");
2661 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
2662 MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");
2663 MODULE_DESCRIPTION("Cadence MHDP8546 DP bridge driver");
2664 MODULE_LICENSE("GPL");
2665 MODULE_ALIAS("platform:cdns-mhdp8546");
2666