1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright(c) 2016, Analogix Semiconductor.
4 *
5 * Based on anx7808 driver obtained from chromeos with copyright:
6 * Copyright(c) 2013, Google Inc.
7 */
8 #include <linux/delay.h>
9 #include <linux/err.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/i2c.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/of_irq.h>
16 #include <linux/of_platform.h>
17 #include <linux/regmap.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/types.h>
20
21 #include <drm/drm_atomic_helper.h>
22 #include <drm/drm_crtc.h>
23 #include <drm/drm_dp_helper.h>
24 #include <drm/drm_edid.h>
25 #include <drm/drm_print.h>
26 #include <drm/drm_probe_helper.h>
27
28 #include "analogix-anx78xx.h"
29
30 #define I2C_NUM_ADDRESSES 5
31 #define I2C_IDX_TX_P0 0
32 #define I2C_IDX_TX_P1 1
33 #define I2C_IDX_TX_P2 2
34 #define I2C_IDX_RX_P0 3
35 #define I2C_IDX_RX_P1 4
36
37 #define XTAL_CLK 270 /* 27M */
38 #define AUX_CH_BUFFER_SIZE 16
39 #define AUX_WAIT_TIMEOUT_MS 15
40
41 static const u8 anx78xx_i2c_addresses[] = {
42 [I2C_IDX_TX_P0] = TX_P0,
43 [I2C_IDX_TX_P1] = TX_P1,
44 [I2C_IDX_TX_P2] = TX_P2,
45 [I2C_IDX_RX_P0] = RX_P0,
46 [I2C_IDX_RX_P1] = RX_P1,
47 };
48
49 struct anx78xx_platform_data {
50 struct regulator *dvdd10;
51 struct gpio_desc *gpiod_hpd;
52 struct gpio_desc *gpiod_pd;
53 struct gpio_desc *gpiod_reset;
54
55 int hpd_irq;
56 int intp_irq;
57 };
58
59 struct anx78xx {
60 struct drm_dp_aux aux;
61 struct drm_bridge bridge;
62 struct i2c_client *client;
63 struct edid *edid;
64 struct drm_connector connector;
65 struct drm_dp_link link;
66 struct anx78xx_platform_data pdata;
67 struct mutex lock;
68
69 /*
70 * I2C Slave addresses of ANX7814 are mapped as TX_P0, TX_P1, TX_P2,
71 * RX_P0 and RX_P1.
72 */
73 struct i2c_client *i2c_dummy[I2C_NUM_ADDRESSES];
74 struct regmap *map[I2C_NUM_ADDRESSES];
75
76 u16 chipid;
77 u8 dpcd[DP_RECEIVER_CAP_SIZE];
78
79 bool powered;
80 };
81
connector_to_anx78xx(struct drm_connector * c)82 static inline struct anx78xx *connector_to_anx78xx(struct drm_connector *c)
83 {
84 return container_of(c, struct anx78xx, connector);
85 }
86
bridge_to_anx78xx(struct drm_bridge * bridge)87 static inline struct anx78xx *bridge_to_anx78xx(struct drm_bridge *bridge)
88 {
89 return container_of(bridge, struct anx78xx, bridge);
90 }
91
anx78xx_set_bits(struct regmap * map,u8 reg,u8 mask)92 static int anx78xx_set_bits(struct regmap *map, u8 reg, u8 mask)
93 {
94 return regmap_update_bits(map, reg, mask, mask);
95 }
96
anx78xx_clear_bits(struct regmap * map,u8 reg,u8 mask)97 static int anx78xx_clear_bits(struct regmap *map, u8 reg, u8 mask)
98 {
99 return regmap_update_bits(map, reg, mask, 0);
100 }
101
anx78xx_aux_op_finished(struct anx78xx * anx78xx)102 static bool anx78xx_aux_op_finished(struct anx78xx *anx78xx)
103 {
104 unsigned int value;
105 int err;
106
107 err = regmap_read(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL2_REG,
108 &value);
109 if (err < 0)
110 return false;
111
112 return (value & SP_AUX_EN) == 0;
113 }
114
anx78xx_aux_wait(struct anx78xx * anx78xx)115 static int anx78xx_aux_wait(struct anx78xx *anx78xx)
116 {
117 unsigned long timeout;
118 unsigned int status;
119 int err;
120
121 timeout = jiffies + msecs_to_jiffies(AUX_WAIT_TIMEOUT_MS) + 1;
122
123 while (!anx78xx_aux_op_finished(anx78xx)) {
124 if (time_after(jiffies, timeout)) {
125 if (!anx78xx_aux_op_finished(anx78xx)) {
126 DRM_ERROR("Timed out waiting AUX to finish\n");
127 return -ETIMEDOUT;
128 }
129
130 break;
131 }
132
133 usleep_range(1000, 2000);
134 }
135
136 /* Read the AUX channel access status */
137 err = regmap_read(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_CH_STATUS_REG,
138 &status);
139 if (err < 0) {
140 DRM_ERROR("Failed to read from AUX channel: %d\n", err);
141 return err;
142 }
143
144 if (status & SP_AUX_STATUS) {
145 DRM_ERROR("Failed to wait for AUX channel (status: %02x)\n",
146 status);
147 return -ETIMEDOUT;
148 }
149
150 return 0;
151 }
152
anx78xx_aux_address(struct anx78xx * anx78xx,unsigned int addr)153 static int anx78xx_aux_address(struct anx78xx *anx78xx, unsigned int addr)
154 {
155 int err;
156
157 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_ADDR_7_0_REG,
158 addr & 0xff);
159 if (err)
160 return err;
161
162 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_ADDR_15_8_REG,
163 (addr & 0xff00) >> 8);
164 if (err)
165 return err;
166
167 /*
168 * DP AUX CH Address Register #2, only update bits[3:0]
169 * [7:4] RESERVED
170 * [3:0] AUX_ADDR[19:16], Register control AUX CH address.
171 */
172 err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P0],
173 SP_AUX_ADDR_19_16_REG,
174 SP_AUX_ADDR_19_16_MASK,
175 (addr & 0xf0000) >> 16);
176
177 if (err)
178 return err;
179
180 return 0;
181 }
182
anx78xx_aux_transfer(struct drm_dp_aux * aux,struct drm_dp_aux_msg * msg)183 static ssize_t anx78xx_aux_transfer(struct drm_dp_aux *aux,
184 struct drm_dp_aux_msg *msg)
185 {
186 struct anx78xx *anx78xx = container_of(aux, struct anx78xx, aux);
187 u8 ctrl1 = msg->request;
188 u8 ctrl2 = SP_AUX_EN;
189 u8 *buffer = msg->buffer;
190 int err;
191
192 /* The DP AUX transmit and receive buffer has 16 bytes. */
193 if (WARN_ON(msg->size > AUX_CH_BUFFER_SIZE))
194 return -E2BIG;
195
196 /* Zero-sized messages specify address-only transactions. */
197 if (msg->size < 1)
198 ctrl2 |= SP_ADDR_ONLY;
199 else /* For non-zero-sized set the length field. */
200 ctrl1 |= (msg->size - 1) << SP_AUX_LENGTH_SHIFT;
201
202 if ((msg->request & DP_AUX_I2C_READ) == 0) {
203 /* When WRITE | MOT write values to data buffer */
204 err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P0],
205 SP_DP_BUF_DATA0_REG, buffer,
206 msg->size);
207 if (err)
208 return err;
209 }
210
211 /* Write address and request */
212 err = anx78xx_aux_address(anx78xx, msg->address);
213 if (err)
214 return err;
215
216 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL1_REG,
217 ctrl1);
218 if (err)
219 return err;
220
221 /* Start transaction */
222 err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P0],
223 SP_DP_AUX_CH_CTRL2_REG, SP_ADDR_ONLY |
224 SP_AUX_EN, ctrl2);
225 if (err)
226 return err;
227
228 err = anx78xx_aux_wait(anx78xx);
229 if (err)
230 return err;
231
232 msg->reply = DP_AUX_I2C_REPLY_ACK;
233
234 if ((msg->size > 0) && (msg->request & DP_AUX_I2C_READ)) {
235 /* Read values from data buffer */
236 err = regmap_bulk_read(anx78xx->map[I2C_IDX_TX_P0],
237 SP_DP_BUF_DATA0_REG, buffer,
238 msg->size);
239 if (err)
240 return err;
241 }
242
243 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
244 SP_DP_AUX_CH_CTRL2_REG, SP_ADDR_ONLY);
245 if (err)
246 return err;
247
248 return msg->size;
249 }
250
anx78xx_set_hpd(struct anx78xx * anx78xx)251 static int anx78xx_set_hpd(struct anx78xx *anx78xx)
252 {
253 int err;
254
255 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
256 SP_TMDS_CTRL_BASE + 7, SP_PD_RT);
257 if (err)
258 return err;
259
260 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL3_REG,
261 SP_HPD_OUT);
262 if (err)
263 return err;
264
265 return 0;
266 }
267
anx78xx_clear_hpd(struct anx78xx * anx78xx)268 static int anx78xx_clear_hpd(struct anx78xx *anx78xx)
269 {
270 int err;
271
272 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL3_REG,
273 SP_HPD_OUT);
274 if (err)
275 return err;
276
277 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
278 SP_TMDS_CTRL_BASE + 7, SP_PD_RT);
279 if (err)
280 return err;
281
282 return 0;
283 }
284
285 static const struct reg_sequence tmds_phy_initialization[] = {
286 { SP_TMDS_CTRL_BASE + 1, 0x90 },
287 { SP_TMDS_CTRL_BASE + 2, 0xa9 },
288 { SP_TMDS_CTRL_BASE + 6, 0x92 },
289 { SP_TMDS_CTRL_BASE + 7, 0x80 },
290 { SP_TMDS_CTRL_BASE + 20, 0xf2 },
291 { SP_TMDS_CTRL_BASE + 22, 0xc4 },
292 { SP_TMDS_CTRL_BASE + 23, 0x18 },
293 };
294
anx78xx_rx_initialization(struct anx78xx * anx78xx)295 static int anx78xx_rx_initialization(struct anx78xx *anx78xx)
296 {
297 int err;
298
299 err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_HDMI_MUTE_CTRL_REG,
300 SP_AUD_MUTE | SP_VID_MUTE);
301 if (err)
302 return err;
303
304 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0], SP_CHIP_CTRL_REG,
305 SP_MAN_HDMI5V_DET | SP_PLLLOCK_CKDT_EN |
306 SP_DIGITAL_CKDT_EN);
307 if (err)
308 return err;
309
310 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
311 SP_SOFTWARE_RESET1_REG, SP_HDCP_MAN_RST |
312 SP_SW_MAN_RST | SP_TMDS_RST | SP_VIDEO_RST);
313 if (err)
314 return err;
315
316 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
317 SP_SOFTWARE_RESET1_REG, SP_HDCP_MAN_RST |
318 SP_SW_MAN_RST | SP_TMDS_RST | SP_VIDEO_RST);
319 if (err)
320 return err;
321
322 /* Sync detect change, GP set mute */
323 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
324 SP_AUD_EXCEPTION_ENABLE_BASE + 1, BIT(5) |
325 BIT(6));
326 if (err)
327 return err;
328
329 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
330 SP_AUD_EXCEPTION_ENABLE_BASE + 3,
331 SP_AEC_EN21);
332 if (err)
333 return err;
334
335 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0], SP_AUDVID_CTRL_REG,
336 SP_AVC_EN | SP_AAC_OE | SP_AAC_EN);
337 if (err)
338 return err;
339
340 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_RX_P0],
341 SP_SYSTEM_POWER_DOWN1_REG, SP_PWDN_CTRL);
342 if (err)
343 return err;
344
345 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_RX_P0],
346 SP_VID_DATA_RANGE_CTRL_REG, SP_R2Y_INPUT_LIMIT);
347 if (err)
348 return err;
349
350 /* Enable DDC stretch */
351 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
352 SP_DP_EXTRA_I2C_DEV_ADDR_REG, SP_I2C_EXTRA_ADDR);
353 if (err)
354 return err;
355
356 /* TMDS phy initialization */
357 err = regmap_multi_reg_write(anx78xx->map[I2C_IDX_RX_P0],
358 tmds_phy_initialization,
359 ARRAY_SIZE(tmds_phy_initialization));
360 if (err)
361 return err;
362
363 err = anx78xx_clear_hpd(anx78xx);
364 if (err)
365 return err;
366
367 return 0;
368 }
369
370 static const u8 dp_tx_output_precise_tune_bits[20] = {
371 0x01, 0x03, 0x07, 0x7f, 0x71, 0x6b, 0x7f,
372 0x73, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00,
373 0x0c, 0x42, 0x1e, 0x3e, 0x72, 0x7e,
374 };
375
anx78xx_link_phy_initialization(struct anx78xx * anx78xx)376 static int anx78xx_link_phy_initialization(struct anx78xx *anx78xx)
377 {
378 int err;
379
380 /*
381 * REVISIT : It is writing to a RESERVED bits in Analog Control 0
382 * register.
383 */
384 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_ANALOG_CTRL0_REG,
385 0x02);
386 if (err)
387 return err;
388
389 /*
390 * Write DP TX output emphasis precise tune bits.
391 */
392 err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P1],
393 SP_DP_TX_LT_CTRL0_REG,
394 dp_tx_output_precise_tune_bits,
395 ARRAY_SIZE(dp_tx_output_precise_tune_bits));
396
397 if (err)
398 return err;
399
400 return 0;
401 }
402
anx78xx_xtal_clk_sel(struct anx78xx * anx78xx)403 static int anx78xx_xtal_clk_sel(struct anx78xx *anx78xx)
404 {
405 unsigned int value;
406 int err;
407
408 err = regmap_update_bits(anx78xx->map[I2C_IDX_TX_P2],
409 SP_ANALOG_DEBUG2_REG,
410 SP_XTAL_FRQ | SP_FORCE_SW_OFF_BYPASS,
411 SP_XTAL_FRQ_27M);
412 if (err)
413 return err;
414
415 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL3_REG,
416 XTAL_CLK & SP_WAIT_COUNTER_7_0_MASK);
417 if (err)
418 return err;
419
420 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL4_REG,
421 ((XTAL_CLK & 0xff00) >> 2) | (XTAL_CLK / 10));
422 if (err)
423 return err;
424
425 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
426 SP_I2C_GEN_10US_TIMER0_REG, XTAL_CLK & 0xff);
427 if (err)
428 return err;
429
430 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
431 SP_I2C_GEN_10US_TIMER1_REG,
432 (XTAL_CLK & 0xff00) >> 8);
433 if (err)
434 return err;
435
436 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_MISC_CTRL_REG,
437 XTAL_CLK / 10 - 1);
438 if (err)
439 return err;
440
441 err = regmap_read(anx78xx->map[I2C_IDX_RX_P0],
442 SP_HDMI_US_TIMER_CTRL_REG,
443 &value);
444 if (err)
445 return err;
446
447 err = regmap_write(anx78xx->map[I2C_IDX_RX_P0],
448 SP_HDMI_US_TIMER_CTRL_REG,
449 (value & SP_MS_TIMER_MARGIN_10_8_MASK) |
450 ((((XTAL_CLK / 10) >> 1) - 2) << 3));
451 if (err)
452 return err;
453
454 return 0;
455 }
456
457 static const struct reg_sequence otp_key_protect[] = {
458 { SP_OTP_KEY_PROTECT1_REG, SP_OTP_PSW1 },
459 { SP_OTP_KEY_PROTECT2_REG, SP_OTP_PSW2 },
460 { SP_OTP_KEY_PROTECT3_REG, SP_OTP_PSW3 },
461 };
462
anx78xx_tx_initialization(struct anx78xx * anx78xx)463 static int anx78xx_tx_initialization(struct anx78xx *anx78xx)
464 {
465 int err;
466
467 /* Set terminal resistor to 50 ohm */
468 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_AUX_CH_CTRL2_REG,
469 0x30);
470 if (err)
471 return err;
472
473 /* Enable aux double diff output */
474 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
475 SP_DP_AUX_CH_CTRL2_REG, 0x08);
476 if (err)
477 return err;
478
479 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
480 SP_DP_HDCP_CTRL_REG, SP_AUTO_EN |
481 SP_AUTO_START);
482 if (err)
483 return err;
484
485 err = regmap_multi_reg_write(anx78xx->map[I2C_IDX_TX_P0],
486 otp_key_protect,
487 ARRAY_SIZE(otp_key_protect));
488 if (err)
489 return err;
490
491 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
492 SP_HDCP_KEY_COMMAND_REG, SP_DISABLE_SYNC_HDCP);
493 if (err)
494 return err;
495
496 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL8_REG,
497 SP_VID_VRES_TH);
498 if (err)
499 return err;
500
501 /*
502 * DP HDCP auto authentication wait timer (when downstream starts to
503 * auth, DP side will wait for this period then do auth automatically)
504 */
505 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_HDCP_AUTO_TIMER_REG,
506 0x00);
507 if (err)
508 return err;
509
510 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
511 SP_DP_HDCP_CTRL_REG, SP_LINK_POLLING);
512 if (err)
513 return err;
514
515 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
516 SP_DP_LINK_DEBUG_CTRL_REG, SP_M_VID_DEBUG);
517 if (err)
518 return err;
519
520 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2],
521 SP_ANALOG_DEBUG2_REG, SP_POWERON_TIME_1P5MS);
522 if (err)
523 return err;
524
525 err = anx78xx_xtal_clk_sel(anx78xx);
526 if (err)
527 return err;
528
529 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_AUX_DEFER_CTRL_REG,
530 SP_DEFER_CTRL_EN | 0x0c);
531 if (err)
532 return err;
533
534 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
535 SP_DP_POLLING_CTRL_REG,
536 SP_AUTO_POLLING_DISABLE);
537 if (err)
538 return err;
539
540 /*
541 * Short the link integrity check timer to speed up bstatus
542 * polling for HDCP CTS item 1A-07
543 */
544 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
545 SP_HDCP_LINK_CHECK_TIMER_REG, 0x1d);
546 if (err)
547 return err;
548
549 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
550 SP_DP_MISC_CTRL_REG, SP_EQ_TRAINING_LOOP);
551 if (err)
552 return err;
553
554 /* Power down the main link by default */
555 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
556 SP_DP_ANALOG_POWER_DOWN_REG, SP_CH0_PD);
557 if (err)
558 return err;
559
560 err = anx78xx_link_phy_initialization(anx78xx);
561 if (err)
562 return err;
563
564 /* Gen m_clk with downspreading */
565 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
566 SP_DP_M_CALCULATION_CTRL_REG, SP_M_GEN_CLK_SEL);
567 if (err)
568 return err;
569
570 return 0;
571 }
572
anx78xx_enable_interrupts(struct anx78xx * anx78xx)573 static int anx78xx_enable_interrupts(struct anx78xx *anx78xx)
574 {
575 int err;
576
577 /*
578 * BIT0: INT pin assertion polarity: 1 = assert high
579 * BIT1: INT pin output type: 0 = push/pull
580 */
581 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_INT_CTRL_REG, 0x01);
582 if (err)
583 return err;
584
585 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2],
586 SP_COMMON_INT_MASK4_REG, SP_HPD_LOST | SP_HPD_PLUG);
587 if (err)
588 return err;
589
590 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_MASK1_REG,
591 SP_TRAINING_FINISH);
592 if (err)
593 return err;
594
595 err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_INT_MASK1_REG,
596 SP_CKDT_CHG | SP_SCDT_CHG);
597 if (err)
598 return err;
599
600 return 0;
601 }
602
anx78xx_poweron(struct anx78xx * anx78xx)603 static void anx78xx_poweron(struct anx78xx *anx78xx)
604 {
605 struct anx78xx_platform_data *pdata = &anx78xx->pdata;
606 int err;
607
608 if (WARN_ON(anx78xx->powered))
609 return;
610
611 if (pdata->dvdd10) {
612 err = regulator_enable(pdata->dvdd10);
613 if (err) {
614 DRM_ERROR("Failed to enable DVDD10 regulator: %d\n",
615 err);
616 return;
617 }
618
619 usleep_range(1000, 2000);
620 }
621
622 gpiod_set_value_cansleep(pdata->gpiod_reset, 1);
623 usleep_range(1000, 2000);
624
625 gpiod_set_value_cansleep(pdata->gpiod_pd, 0);
626 usleep_range(1000, 2000);
627
628 gpiod_set_value_cansleep(pdata->gpiod_reset, 0);
629
630 /* Power on registers module */
631 anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
632 SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD | SP_LINK_PD);
633 anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
634 SP_REGISTER_PD | SP_TOTAL_PD);
635
636 anx78xx->powered = true;
637 }
638
anx78xx_poweroff(struct anx78xx * anx78xx)639 static void anx78xx_poweroff(struct anx78xx *anx78xx)
640 {
641 struct anx78xx_platform_data *pdata = &anx78xx->pdata;
642 int err;
643
644 if (WARN_ON(!anx78xx->powered))
645 return;
646
647 gpiod_set_value_cansleep(pdata->gpiod_reset, 1);
648 usleep_range(1000, 2000);
649
650 gpiod_set_value_cansleep(pdata->gpiod_pd, 1);
651 usleep_range(1000, 2000);
652
653 if (pdata->dvdd10) {
654 err = regulator_disable(pdata->dvdd10);
655 if (err) {
656 DRM_ERROR("Failed to disable DVDD10 regulator: %d\n",
657 err);
658 return;
659 }
660
661 usleep_range(1000, 2000);
662 }
663
664 anx78xx->powered = false;
665 }
666
anx78xx_start(struct anx78xx * anx78xx)667 static int anx78xx_start(struct anx78xx *anx78xx)
668 {
669 int err;
670
671 /* Power on all modules */
672 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
673 SP_POWERDOWN_CTRL_REG,
674 SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD |
675 SP_LINK_PD);
676
677 err = anx78xx_enable_interrupts(anx78xx);
678 if (err) {
679 DRM_ERROR("Failed to enable interrupts: %d\n", err);
680 goto err_poweroff;
681 }
682
683 err = anx78xx_rx_initialization(anx78xx);
684 if (err) {
685 DRM_ERROR("Failed receiver initialization: %d\n", err);
686 goto err_poweroff;
687 }
688
689 err = anx78xx_tx_initialization(anx78xx);
690 if (err) {
691 DRM_ERROR("Failed transmitter initialization: %d\n", err);
692 goto err_poweroff;
693 }
694
695 /*
696 * This delay seems to help keep the hardware in a good state. Without
697 * it, there are times where it fails silently.
698 */
699 usleep_range(10000, 15000);
700
701 return 0;
702
703 err_poweroff:
704 DRM_ERROR("Failed SlimPort transmitter initialization: %d\n", err);
705 anx78xx_poweroff(anx78xx);
706
707 return err;
708 }
709
anx78xx_init_pdata(struct anx78xx * anx78xx)710 static int anx78xx_init_pdata(struct anx78xx *anx78xx)
711 {
712 struct anx78xx_platform_data *pdata = &anx78xx->pdata;
713 struct device *dev = &anx78xx->client->dev;
714
715 /* 1.0V digital core power regulator */
716 pdata->dvdd10 = devm_regulator_get(dev, "dvdd10");
717 if (IS_ERR(pdata->dvdd10)) {
718 DRM_ERROR("DVDD10 regulator not found\n");
719 return PTR_ERR(pdata->dvdd10);
720 }
721
722 /* GPIO for HPD */
723 pdata->gpiod_hpd = devm_gpiod_get(dev, "hpd", GPIOD_IN);
724 if (IS_ERR(pdata->gpiod_hpd))
725 return PTR_ERR(pdata->gpiod_hpd);
726
727 /* GPIO for chip power down */
728 pdata->gpiod_pd = devm_gpiod_get(dev, "pd", GPIOD_OUT_HIGH);
729 if (IS_ERR(pdata->gpiod_pd))
730 return PTR_ERR(pdata->gpiod_pd);
731
732 /* GPIO for chip reset */
733 pdata->gpiod_reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
734
735 return PTR_ERR_OR_ZERO(pdata->gpiod_reset);
736 }
737
anx78xx_dp_link_training(struct anx78xx * anx78xx)738 static int anx78xx_dp_link_training(struct anx78xx *anx78xx)
739 {
740 u8 dp_bw, value;
741 int err;
742
743 err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_HDMI_MUTE_CTRL_REG,
744 0x0);
745 if (err)
746 return err;
747
748 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
749 SP_POWERDOWN_CTRL_REG,
750 SP_TOTAL_PD);
751 if (err)
752 return err;
753
754 err = drm_dp_dpcd_readb(&anx78xx->aux, DP_MAX_LINK_RATE, &dp_bw);
755 if (err < 0)
756 return err;
757
758 switch (dp_bw) {
759 case DP_LINK_BW_1_62:
760 case DP_LINK_BW_2_7:
761 case DP_LINK_BW_5_4:
762 break;
763
764 default:
765 DRM_DEBUG_KMS("DP bandwidth (%#02x) not supported\n", dp_bw);
766 return -EINVAL;
767 }
768
769 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
770 SP_VIDEO_MUTE);
771 if (err)
772 return err;
773
774 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2],
775 SP_VID_CTRL1_REG, SP_VIDEO_EN);
776 if (err)
777 return err;
778
779 /* Get DPCD info */
780 err = drm_dp_dpcd_read(&anx78xx->aux, DP_DPCD_REV,
781 &anx78xx->dpcd, DP_RECEIVER_CAP_SIZE);
782 if (err < 0) {
783 DRM_ERROR("Failed to read DPCD: %d\n", err);
784 return err;
785 }
786
787 /* Clear channel x SERDES power down */
788 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
789 SP_DP_ANALOG_POWER_DOWN_REG, SP_CH0_PD);
790 if (err)
791 return err;
792
793 /* Check link capabilities */
794 err = drm_dp_link_probe(&anx78xx->aux, &anx78xx->link);
795 if (err < 0) {
796 DRM_ERROR("Failed to probe link capabilities: %d\n", err);
797 return err;
798 }
799
800 /* Power up the sink */
801 err = drm_dp_link_power_up(&anx78xx->aux, &anx78xx->link);
802 if (err < 0) {
803 DRM_ERROR("Failed to power up DisplayPort link: %d\n", err);
804 return err;
805 }
806
807 /* Possibly enable downspread on the sink */
808 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
809 SP_DP_DOWNSPREAD_CTRL1_REG, 0);
810 if (err)
811 return err;
812
813 if (anx78xx->dpcd[DP_MAX_DOWNSPREAD] & DP_MAX_DOWNSPREAD_0_5) {
814 DRM_DEBUG("Enable downspread on the sink\n");
815 /* 4000PPM */
816 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
817 SP_DP_DOWNSPREAD_CTRL1_REG, 8);
818 if (err)
819 return err;
820
821 err = drm_dp_dpcd_writeb(&anx78xx->aux, DP_DOWNSPREAD_CTRL,
822 DP_SPREAD_AMP_0_5);
823 if (err < 0)
824 return err;
825 } else {
826 err = drm_dp_dpcd_writeb(&anx78xx->aux, DP_DOWNSPREAD_CTRL, 0);
827 if (err < 0)
828 return err;
829 }
830
831 /* Set the lane count and the link rate on the sink */
832 if (drm_dp_enhanced_frame_cap(anx78xx->dpcd))
833 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
834 SP_DP_SYSTEM_CTRL_BASE + 4,
835 SP_ENHANCED_MODE);
836 else
837 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
838 SP_DP_SYSTEM_CTRL_BASE + 4,
839 SP_ENHANCED_MODE);
840 if (err)
841 return err;
842
843 value = drm_dp_link_rate_to_bw_code(anx78xx->link.rate);
844 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0],
845 SP_DP_MAIN_LINK_BW_SET_REG, value);
846 if (err)
847 return err;
848
849 err = drm_dp_link_configure(&anx78xx->aux, &anx78xx->link);
850 if (err < 0) {
851 DRM_ERROR("Failed to configure DisplayPort link: %d\n", err);
852 return err;
853 }
854
855 /* Start training on the source */
856 err = regmap_write(anx78xx->map[I2C_IDX_TX_P0], SP_DP_LT_CTRL_REG,
857 SP_LT_EN);
858 if (err)
859 return err;
860
861 return 0;
862 }
863
anx78xx_config_dp_output(struct anx78xx * anx78xx)864 static int anx78xx_config_dp_output(struct anx78xx *anx78xx)
865 {
866 int err;
867
868 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
869 SP_VIDEO_MUTE);
870 if (err)
871 return err;
872
873 /* Enable DP output */
874 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_VID_CTRL1_REG,
875 SP_VIDEO_EN);
876 if (err)
877 return err;
878
879 return 0;
880 }
881
anx78xx_send_video_infoframe(struct anx78xx * anx78xx,struct hdmi_avi_infoframe * frame)882 static int anx78xx_send_video_infoframe(struct anx78xx *anx78xx,
883 struct hdmi_avi_infoframe *frame)
884 {
885 u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE];
886 int err;
887
888 err = hdmi_avi_infoframe_pack(frame, buffer, sizeof(buffer));
889 if (err < 0) {
890 DRM_ERROR("Failed to pack AVI infoframe: %d\n", err);
891 return err;
892 }
893
894 err = anx78xx_clear_bits(anx78xx->map[I2C_IDX_TX_P0],
895 SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_EN);
896 if (err)
897 return err;
898
899 err = regmap_bulk_write(anx78xx->map[I2C_IDX_TX_P2],
900 SP_INFOFRAME_AVI_DB1_REG, buffer,
901 frame->length);
902 if (err)
903 return err;
904
905 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
906 SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_UD);
907 if (err)
908 return err;
909
910 err = anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P0],
911 SP_PACKET_SEND_CTRL_REG, SP_AVI_IF_EN);
912 if (err)
913 return err;
914
915 return 0;
916 }
917
anx78xx_get_downstream_info(struct anx78xx * anx78xx)918 static int anx78xx_get_downstream_info(struct anx78xx *anx78xx)
919 {
920 u8 value;
921 int err;
922
923 err = drm_dp_dpcd_readb(&anx78xx->aux, DP_SINK_COUNT, &value);
924 if (err < 0) {
925 DRM_ERROR("Get sink count failed %d\n", err);
926 return err;
927 }
928
929 if (!DP_GET_SINK_COUNT(value)) {
930 DRM_ERROR("Downstream disconnected\n");
931 return -EIO;
932 }
933
934 return 0;
935 }
936
anx78xx_get_modes(struct drm_connector * connector)937 static int anx78xx_get_modes(struct drm_connector *connector)
938 {
939 struct anx78xx *anx78xx = connector_to_anx78xx(connector);
940 int err, num_modes = 0;
941
942 if (WARN_ON(!anx78xx->powered))
943 return 0;
944
945 if (anx78xx->edid)
946 return drm_add_edid_modes(connector, anx78xx->edid);
947
948 mutex_lock(&anx78xx->lock);
949
950 err = anx78xx_get_downstream_info(anx78xx);
951 if (err) {
952 DRM_ERROR("Failed to get downstream info: %d\n", err);
953 goto unlock;
954 }
955
956 anx78xx->edid = drm_get_edid(connector, &anx78xx->aux.ddc);
957 if (!anx78xx->edid) {
958 DRM_ERROR("Failed to read EDID\n");
959 goto unlock;
960 }
961
962 err = drm_connector_update_edid_property(connector,
963 anx78xx->edid);
964 if (err) {
965 DRM_ERROR("Failed to update EDID property: %d\n", err);
966 goto unlock;
967 }
968
969 num_modes = drm_add_edid_modes(connector, anx78xx->edid);
970
971 unlock:
972 mutex_unlock(&anx78xx->lock);
973
974 return num_modes;
975 }
976
977 static const struct drm_connector_helper_funcs anx78xx_connector_helper_funcs = {
978 .get_modes = anx78xx_get_modes,
979 };
980
anx78xx_detect(struct drm_connector * connector,bool force)981 static enum drm_connector_status anx78xx_detect(struct drm_connector *connector,
982 bool force)
983 {
984 struct anx78xx *anx78xx = connector_to_anx78xx(connector);
985
986 if (!gpiod_get_value(anx78xx->pdata.gpiod_hpd))
987 return connector_status_disconnected;
988
989 return connector_status_connected;
990 }
991
992 static const struct drm_connector_funcs anx78xx_connector_funcs = {
993 .fill_modes = drm_helper_probe_single_connector_modes,
994 .detect = anx78xx_detect,
995 .destroy = drm_connector_cleanup,
996 .reset = drm_atomic_helper_connector_reset,
997 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
998 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
999 };
1000
anx78xx_bridge_attach(struct drm_bridge * bridge)1001 static int anx78xx_bridge_attach(struct drm_bridge *bridge)
1002 {
1003 struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1004 int err;
1005
1006 if (!bridge->encoder) {
1007 DRM_ERROR("Parent encoder object not found");
1008 return -ENODEV;
1009 }
1010
1011 /* Register aux channel */
1012 anx78xx->aux.name = "DP-AUX";
1013 anx78xx->aux.dev = &anx78xx->client->dev;
1014 anx78xx->aux.transfer = anx78xx_aux_transfer;
1015
1016 err = drm_dp_aux_register(&anx78xx->aux);
1017 if (err < 0) {
1018 DRM_ERROR("Failed to register aux channel: %d\n", err);
1019 return err;
1020 }
1021
1022 err = drm_connector_init(bridge->dev, &anx78xx->connector,
1023 &anx78xx_connector_funcs,
1024 DRM_MODE_CONNECTOR_DisplayPort);
1025 if (err) {
1026 DRM_ERROR("Failed to initialize connector: %d\n", err);
1027 return err;
1028 }
1029
1030 drm_connector_helper_add(&anx78xx->connector,
1031 &anx78xx_connector_helper_funcs);
1032
1033 err = drm_connector_register(&anx78xx->connector);
1034 if (err) {
1035 DRM_ERROR("Failed to register connector: %d\n", err);
1036 return err;
1037 }
1038
1039 anx78xx->connector.polled = DRM_CONNECTOR_POLL_HPD;
1040
1041 err = drm_connector_attach_encoder(&anx78xx->connector,
1042 bridge->encoder);
1043 if (err) {
1044 DRM_ERROR("Failed to link up connector to encoder: %d\n", err);
1045 return err;
1046 }
1047
1048 return 0;
1049 }
1050
1051 static enum drm_mode_status
anx78xx_bridge_mode_valid(struct drm_bridge * bridge,const struct drm_display_mode * mode)1052 anx78xx_bridge_mode_valid(struct drm_bridge *bridge,
1053 const struct drm_display_mode *mode)
1054 {
1055 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1056 return MODE_NO_INTERLACE;
1057
1058 /* Max 1200p at 5.4 Ghz, one lane */
1059 if (mode->clock > 154000)
1060 return MODE_CLOCK_HIGH;
1061
1062 return MODE_OK;
1063 }
1064
anx78xx_bridge_disable(struct drm_bridge * bridge)1065 static void anx78xx_bridge_disable(struct drm_bridge *bridge)
1066 {
1067 struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1068
1069 /* Power off all modules except configuration registers access */
1070 anx78xx_set_bits(anx78xx->map[I2C_IDX_TX_P2], SP_POWERDOWN_CTRL_REG,
1071 SP_HDCP_PD | SP_AUDIO_PD | SP_VIDEO_PD | SP_LINK_PD);
1072 }
1073
anx78xx_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adjusted_mode)1074 static void anx78xx_bridge_mode_set(struct drm_bridge *bridge,
1075 const struct drm_display_mode *mode,
1076 const struct drm_display_mode *adjusted_mode)
1077 {
1078 struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1079 struct hdmi_avi_infoframe frame;
1080 int err;
1081
1082 if (WARN_ON(!anx78xx->powered))
1083 return;
1084
1085 mutex_lock(&anx78xx->lock);
1086
1087 err = drm_hdmi_avi_infoframe_from_display_mode(&frame,
1088 &anx78xx->connector,
1089 adjusted_mode);
1090 if (err) {
1091 DRM_ERROR("Failed to setup AVI infoframe: %d\n", err);
1092 goto unlock;
1093 }
1094
1095 err = anx78xx_send_video_infoframe(anx78xx, &frame);
1096 if (err)
1097 DRM_ERROR("Failed to send AVI infoframe: %d\n", err);
1098
1099 unlock:
1100 mutex_unlock(&anx78xx->lock);
1101 }
1102
anx78xx_bridge_enable(struct drm_bridge * bridge)1103 static void anx78xx_bridge_enable(struct drm_bridge *bridge)
1104 {
1105 struct anx78xx *anx78xx = bridge_to_anx78xx(bridge);
1106 int err;
1107
1108 err = anx78xx_start(anx78xx);
1109 if (err) {
1110 DRM_ERROR("Failed to initialize: %d\n", err);
1111 return;
1112 }
1113
1114 err = anx78xx_set_hpd(anx78xx);
1115 if (err)
1116 DRM_ERROR("Failed to set HPD: %d\n", err);
1117 }
1118
1119 static const struct drm_bridge_funcs anx78xx_bridge_funcs = {
1120 .attach = anx78xx_bridge_attach,
1121 .mode_valid = anx78xx_bridge_mode_valid,
1122 .disable = anx78xx_bridge_disable,
1123 .mode_set = anx78xx_bridge_mode_set,
1124 .enable = anx78xx_bridge_enable,
1125 };
1126
anx78xx_hpd_threaded_handler(int irq,void * data)1127 static irqreturn_t anx78xx_hpd_threaded_handler(int irq, void *data)
1128 {
1129 struct anx78xx *anx78xx = data;
1130 int err;
1131
1132 if (anx78xx->powered)
1133 return IRQ_HANDLED;
1134
1135 mutex_lock(&anx78xx->lock);
1136
1137 /* Cable is pulled, power on the chip */
1138 anx78xx_poweron(anx78xx);
1139
1140 err = anx78xx_enable_interrupts(anx78xx);
1141 if (err)
1142 DRM_ERROR("Failed to enable interrupts: %d\n", err);
1143
1144 mutex_unlock(&anx78xx->lock);
1145
1146 return IRQ_HANDLED;
1147 }
1148
anx78xx_handle_dp_int_1(struct anx78xx * anx78xx,u8 irq)1149 static int anx78xx_handle_dp_int_1(struct anx78xx *anx78xx, u8 irq)
1150 {
1151 int err;
1152
1153 DRM_DEBUG_KMS("Handle DP interrupt 1: %02x\n", irq);
1154
1155 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_STATUS1_REG,
1156 irq);
1157 if (err)
1158 return err;
1159
1160 if (irq & SP_TRAINING_FINISH) {
1161 DRM_DEBUG_KMS("IRQ: hardware link training finished\n");
1162 err = anx78xx_config_dp_output(anx78xx);
1163 }
1164
1165 return err;
1166 }
1167
anx78xx_handle_common_int_4(struct anx78xx * anx78xx,u8 irq)1168 static bool anx78xx_handle_common_int_4(struct anx78xx *anx78xx, u8 irq)
1169 {
1170 bool event = false;
1171 int err;
1172
1173 DRM_DEBUG_KMS("Handle common interrupt 4: %02x\n", irq);
1174
1175 err = regmap_write(anx78xx->map[I2C_IDX_TX_P2],
1176 SP_COMMON_INT_STATUS4_REG, irq);
1177 if (err) {
1178 DRM_ERROR("Failed to write SP_COMMON_INT_STATUS4 %d\n", err);
1179 return event;
1180 }
1181
1182 if (irq & SP_HPD_LOST) {
1183 DRM_DEBUG_KMS("IRQ: Hot plug detect - cable is pulled out\n");
1184 event = true;
1185 anx78xx_poweroff(anx78xx);
1186 /* Free cached EDID */
1187 kfree(anx78xx->edid);
1188 anx78xx->edid = NULL;
1189 } else if (irq & SP_HPD_PLUG) {
1190 DRM_DEBUG_KMS("IRQ: Hot plug detect - cable plug\n");
1191 event = true;
1192 }
1193
1194 return event;
1195 }
1196
anx78xx_handle_hdmi_int_1(struct anx78xx * anx78xx,u8 irq)1197 static void anx78xx_handle_hdmi_int_1(struct anx78xx *anx78xx, u8 irq)
1198 {
1199 unsigned int value;
1200 int err;
1201
1202 DRM_DEBUG_KMS("Handle HDMI interrupt 1: %02x\n", irq);
1203
1204 err = regmap_write(anx78xx->map[I2C_IDX_RX_P0], SP_INT_STATUS1_REG,
1205 irq);
1206 if (err) {
1207 DRM_ERROR("Write HDMI int 1 failed: %d\n", err);
1208 return;
1209 }
1210
1211 if ((irq & SP_CKDT_CHG) || (irq & SP_SCDT_CHG)) {
1212 DRM_DEBUG_KMS("IRQ: HDMI input detected\n");
1213
1214 err = regmap_read(anx78xx->map[I2C_IDX_RX_P0],
1215 SP_SYSTEM_STATUS_REG, &value);
1216 if (err) {
1217 DRM_ERROR("Read system status reg failed: %d\n", err);
1218 return;
1219 }
1220
1221 if (!(value & SP_TMDS_CLOCK_DET)) {
1222 DRM_DEBUG_KMS("IRQ: *** Waiting for HDMI clock ***\n");
1223 return;
1224 }
1225
1226 if (!(value & SP_TMDS_DE_DET)) {
1227 DRM_DEBUG_KMS("IRQ: *** Waiting for HDMI signal ***\n");
1228 return;
1229 }
1230
1231 err = anx78xx_dp_link_training(anx78xx);
1232 if (err)
1233 DRM_ERROR("Failed to start link training: %d\n", err);
1234 }
1235 }
1236
anx78xx_intp_threaded_handler(int unused,void * data)1237 static irqreturn_t anx78xx_intp_threaded_handler(int unused, void *data)
1238 {
1239 struct anx78xx *anx78xx = data;
1240 bool event = false;
1241 unsigned int irq;
1242 int err;
1243
1244 mutex_lock(&anx78xx->lock);
1245
1246 err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DP_INT_STATUS1_REG,
1247 &irq);
1248 if (err) {
1249 DRM_ERROR("Failed to read DP interrupt 1 status: %d\n", err);
1250 goto unlock;
1251 }
1252
1253 if (irq)
1254 anx78xx_handle_dp_int_1(anx78xx, irq);
1255
1256 err = regmap_read(anx78xx->map[I2C_IDX_TX_P2],
1257 SP_COMMON_INT_STATUS4_REG, &irq);
1258 if (err) {
1259 DRM_ERROR("Failed to read common interrupt 4 status: %d\n",
1260 err);
1261 goto unlock;
1262 }
1263
1264 if (irq)
1265 event = anx78xx_handle_common_int_4(anx78xx, irq);
1266
1267 /* Make sure we are still powered after handle HPD events */
1268 if (!anx78xx->powered)
1269 goto unlock;
1270
1271 err = regmap_read(anx78xx->map[I2C_IDX_RX_P0], SP_INT_STATUS1_REG,
1272 &irq);
1273 if (err) {
1274 DRM_ERROR("Failed to read HDMI int 1 status: %d\n", err);
1275 goto unlock;
1276 }
1277
1278 if (irq)
1279 anx78xx_handle_hdmi_int_1(anx78xx, irq);
1280
1281 unlock:
1282 mutex_unlock(&anx78xx->lock);
1283
1284 if (event)
1285 drm_helper_hpd_irq_event(anx78xx->connector.dev);
1286
1287 return IRQ_HANDLED;
1288 }
1289
unregister_i2c_dummy_clients(struct anx78xx * anx78xx)1290 static void unregister_i2c_dummy_clients(struct anx78xx *anx78xx)
1291 {
1292 unsigned int i;
1293
1294 for (i = 0; i < ARRAY_SIZE(anx78xx->i2c_dummy); i++)
1295 i2c_unregister_device(anx78xx->i2c_dummy[i]);
1296 }
1297
1298 static const struct regmap_config anx78xx_regmap_config = {
1299 .reg_bits = 8,
1300 .val_bits = 8,
1301 };
1302
1303 static const u16 anx78xx_chipid_list[] = {
1304 0x7812,
1305 0x7814,
1306 0x7818,
1307 };
1308
anx78xx_i2c_probe(struct i2c_client * client,const struct i2c_device_id * id)1309 static int anx78xx_i2c_probe(struct i2c_client *client,
1310 const struct i2c_device_id *id)
1311 {
1312 struct anx78xx *anx78xx;
1313 struct anx78xx_platform_data *pdata;
1314 unsigned int i, idl, idh, version;
1315 bool found = false;
1316 int err;
1317
1318 anx78xx = devm_kzalloc(&client->dev, sizeof(*anx78xx), GFP_KERNEL);
1319 if (!anx78xx)
1320 return -ENOMEM;
1321
1322 pdata = &anx78xx->pdata;
1323
1324 mutex_init(&anx78xx->lock);
1325
1326 #if IS_ENABLED(CONFIG_OF)
1327 anx78xx->bridge.of_node = client->dev.of_node;
1328 #endif
1329
1330 anx78xx->client = client;
1331 i2c_set_clientdata(client, anx78xx);
1332
1333 err = anx78xx_init_pdata(anx78xx);
1334 if (err) {
1335 DRM_ERROR("Failed to initialize pdata: %d\n", err);
1336 return err;
1337 }
1338
1339 pdata->hpd_irq = gpiod_to_irq(pdata->gpiod_hpd);
1340 if (pdata->hpd_irq < 0) {
1341 DRM_ERROR("Failed to get HPD IRQ: %d\n", pdata->hpd_irq);
1342 return -ENODEV;
1343 }
1344
1345 pdata->intp_irq = client->irq;
1346 if (!pdata->intp_irq) {
1347 DRM_ERROR("Failed to get CABLE_DET and INTP IRQ\n");
1348 return -ENODEV;
1349 }
1350
1351 /* Map slave addresses of ANX7814 */
1352 for (i = 0; i < I2C_NUM_ADDRESSES; i++) {
1353 anx78xx->i2c_dummy[i] = i2c_new_dummy(client->adapter,
1354 anx78xx_i2c_addresses[i] >> 1);
1355 if (!anx78xx->i2c_dummy[i]) {
1356 err = -ENOMEM;
1357 DRM_ERROR("Failed to reserve I2C bus %02x\n",
1358 anx78xx_i2c_addresses[i]);
1359 goto err_unregister_i2c;
1360 }
1361
1362 anx78xx->map[i] = devm_regmap_init_i2c(anx78xx->i2c_dummy[i],
1363 &anx78xx_regmap_config);
1364 if (IS_ERR(anx78xx->map[i])) {
1365 err = PTR_ERR(anx78xx->map[i]);
1366 DRM_ERROR("Failed regmap initialization %02x\n",
1367 anx78xx_i2c_addresses[i]);
1368 goto err_unregister_i2c;
1369 }
1370 }
1371
1372 /* Look for supported chip ID */
1373 anx78xx_poweron(anx78xx);
1374
1375 err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_IDL_REG,
1376 &idl);
1377 if (err)
1378 goto err_poweroff;
1379
1380 err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_IDH_REG,
1381 &idh);
1382 if (err)
1383 goto err_poweroff;
1384
1385 anx78xx->chipid = (u8)idl | ((u8)idh << 8);
1386
1387 err = regmap_read(anx78xx->map[I2C_IDX_TX_P2], SP_DEVICE_VERSION_REG,
1388 &version);
1389 if (err)
1390 goto err_poweroff;
1391
1392 for (i = 0; i < ARRAY_SIZE(anx78xx_chipid_list); i++) {
1393 if (anx78xx->chipid == anx78xx_chipid_list[i]) {
1394 DRM_INFO("Found ANX%x (ver. %d) SlimPort Transmitter\n",
1395 anx78xx->chipid, version);
1396 found = true;
1397 break;
1398 }
1399 }
1400
1401 if (!found) {
1402 DRM_ERROR("ANX%x (ver. %d) not supported by this driver\n",
1403 anx78xx->chipid, version);
1404 err = -ENODEV;
1405 goto err_poweroff;
1406 }
1407
1408 err = devm_request_threaded_irq(&client->dev, pdata->hpd_irq, NULL,
1409 anx78xx_hpd_threaded_handler,
1410 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1411 "anx78xx-hpd", anx78xx);
1412 if (err) {
1413 DRM_ERROR("Failed to request CABLE_DET threaded IRQ: %d\n",
1414 err);
1415 goto err_poweroff;
1416 }
1417
1418 err = devm_request_threaded_irq(&client->dev, pdata->intp_irq, NULL,
1419 anx78xx_intp_threaded_handler,
1420 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1421 "anx78xx-intp", anx78xx);
1422 if (err) {
1423 DRM_ERROR("Failed to request INTP threaded IRQ: %d\n", err);
1424 goto err_poweroff;
1425 }
1426
1427 anx78xx->bridge.funcs = &anx78xx_bridge_funcs;
1428
1429 drm_bridge_add(&anx78xx->bridge);
1430
1431 /* If cable is pulled out, just poweroff and wait for HPD event */
1432 if (!gpiod_get_value(anx78xx->pdata.gpiod_hpd))
1433 anx78xx_poweroff(anx78xx);
1434
1435 return 0;
1436
1437 err_poweroff:
1438 anx78xx_poweroff(anx78xx);
1439
1440 err_unregister_i2c:
1441 unregister_i2c_dummy_clients(anx78xx);
1442 return err;
1443 }
1444
anx78xx_i2c_remove(struct i2c_client * client)1445 static int anx78xx_i2c_remove(struct i2c_client *client)
1446 {
1447 struct anx78xx *anx78xx = i2c_get_clientdata(client);
1448
1449 drm_bridge_remove(&anx78xx->bridge);
1450
1451 unregister_i2c_dummy_clients(anx78xx);
1452
1453 kfree(anx78xx->edid);
1454
1455 return 0;
1456 }
1457
1458 static const struct i2c_device_id anx78xx_id[] = {
1459 { "anx7814", 0 },
1460 { /* sentinel */ }
1461 };
1462 MODULE_DEVICE_TABLE(i2c, anx78xx_id);
1463
1464 #if IS_ENABLED(CONFIG_OF)
1465 static const struct of_device_id anx78xx_match_table[] = {
1466 { .compatible = "analogix,anx7814", },
1467 { /* sentinel */ },
1468 };
1469 MODULE_DEVICE_TABLE(of, anx78xx_match_table);
1470 #endif
1471
1472 static struct i2c_driver anx78xx_driver = {
1473 .driver = {
1474 .name = "anx7814",
1475 .of_match_table = of_match_ptr(anx78xx_match_table),
1476 },
1477 .probe = anx78xx_i2c_probe,
1478 .remove = anx78xx_i2c_remove,
1479 .id_table = anx78xx_id,
1480 };
1481 module_i2c_driver(anx78xx_driver);
1482
1483 MODULE_DESCRIPTION("ANX78xx SlimPort Transmitter driver");
1484 MODULE_AUTHOR("Enric Balletbo i Serra <enric.balletbo@collabora.com>");
1485 MODULE_LICENSE("GPL v2");
1486
