1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
|
/*
* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#ifndef __SECDP_H
#define __SECDP_H
#include <linux/usb/typec/manager/usb_typec_manager_notifier.h>
#include <linux/usb/typec/common/pdic_notifier.h>
#include <linux/secdp_logger.h>
#include <linux/pm_wakeup.h>
#include <linux/sched/clock.h>
#include "dp_hpd.h"
#include "dp_power.h"
#include "dp_panel.h"
#include "dp_catalog.h"
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
extern unsigned int lpcharge;
#endif
/*defined at kmodule/usb/typec/common/pdic_core.h*/
#define SAMSUNG_VENDOR_ID 0x04E8
#define DEXDOCK_PRODUCT_ID 0xA020 /* EE-MG950, DeX station */
#define HG950_PRODUCT_ID 0xA025 /* EE-HG950 */
#define MPA2_PRODUCT_ID 0xA027 /* EE-P5000 */
#define DEXPAD_PRODUCT_ID 0xA029 /* EE-M5100 */
#define DEXCABLE_PRODUCT_ID 0xA048 /* EE-I3100 */
#define MPA3_PRODUCT_ID 0xA056 /* EE-P3200 */
#define SECDP_ENUM_STR(x) #x
#define SECDP_USB_CONCURRENCY
#define SECDP_USE_WAKELOCK
#define SECDP_MAX_HBR2
#define SECDP_OPTIMAL_LINK_RATE /* use optimum link_rate, not max link_rate */
#define SECDP_LIMIT_REFRESH_RATE /* needs to be DISABLED once android has menu for user to change DP resolution */
/*#define SECDP_AUDIO_CTS*/
/*#define SECDP_HDCP_DISABLE*/
/*#define SECDP_EVENT_THREAD*/
/*#define SECDP_TEST_HDCP2P2_REAUTH*/
/*#define NOT_SUPPORT_DEX_RES_CHANGE*/
/*#define SECDP_IGNORE_PREFER_IF_DEX_RES_EXIST*/
#define LEN_BRANCH_REV 3
#define DPCD_BRANCH_HW_REV 0x509
#define DPCD_BRANCH_SW_REV_MAJOR 0x50A
#define DPCD_BRANCH_SW_REV_MINOR 0x50B
#define MAX_CNT_LINK_STATUS_UPDATE 4
#define MAX_CNT_HDCP_RETRY 10
/* MST: max resolution, max refresh rate, max pclk */
#define MST_MAX_COLS 3840
#define MST_MAX_ROWS 2160
#define MST_MAX_FPS 30
#define MST_MAX_PCLK 300000
#define PDIC_DP_NOTI_REG_DELAY 1000
#ifdef SECDP_EVENT_THREAD
struct secdp_event {
struct dp_display_private *dp;
u32 id;
};
#define SECDP_EVENT_Q_MAX 4
struct secdp_event_data {
wait_queue_head_t event_q;
u32 pndx;
u32 gndx;
struct secdp_event event_list[SECDP_EVENT_Q_MAX];
spinlock_t event_lock;
};
#endif
/* displayport self test */
#if defined(CONFIG_SEC_DISPLAYPORT) && defined(CONFIG_SEC_DISPLAYPORT_ENG)
#define SECDP_SELF_TEST
#endif
#ifdef SECDP_SELF_TEST
#define ST_EDID_SIZE 256
#define ST_ARG_CNT 20
enum {
ST_CLEAR_CMD,
ST_LANE_CNT,
ST_LINK_RATE,
ST_CONNECTION_TEST,
ST_HDCP_TEST,
ST_EDID,
ST_PREEM_TUN,
ST_VOLTAGE_TUN,
ST_MAX,
};
struct secdp_sef_test_item {
char cmd_str[20];
int arg[ST_ARG_CNT];
int arg_cnt;
char arg_str[100];
bool enabled;
void (*clear)(void);
};
int secdp_self_test_status(int cmd);
void secdp_self_test_start_reconnect(void (*func)(void));
void secdp_self_test_start_hdcp_test(void (*func_on)(void),
void (*func_off)(void));
u8 *secdp_self_test_get_edid(void);
void secdp_self_register_clear_func(int cmd, void (*func)(void));
int *secdp_self_test_get_arg(int cmd);
#endif/*SECDP_SELF_TEST*/
/* monitor aspect ratio */
enum mon_aspect_ratio_t {
MON_RATIO_NA = -1,
MON_RATIO_3_2,
MON_RATIO_4_3,
MON_RATIO_5_3,
MON_RATIO_5_4,
MON_RATIO_10P5_9,
MON_RATIO_11_10,
MON_RATIO_16_9,
MON_RATIO_16_10,
MON_RATIO_21_9,
MON_RATIO_21_10,
MON_RATIO_32_9,
MON_RATIO_32_10,
};
static inline char *secdp_aspect_ratio_to_string(enum mon_aspect_ratio_t ratio)
{
switch (ratio) {
case MON_RATIO_3_2: return DP_ENUM_STR(MON_RATIO_3_2);
case MON_RATIO_4_3: return DP_ENUM_STR(MON_RATIO_4_3);
case MON_RATIO_5_3: return DP_ENUM_STR(MON_RATIO_5_3);
case MON_RATIO_5_4: return DP_ENUM_STR(MON_RATIO_5_4);
case MON_RATIO_10P5_9: return DP_ENUM_STR(MON_RATIO_10P5_9);
case MON_RATIO_11_10: return DP_ENUM_STR(MON_RATIO_11_10);
case MON_RATIO_16_9: return DP_ENUM_STR(MON_RATIO_16_9);
case MON_RATIO_16_10: return DP_ENUM_STR(MON_RATIO_16_10);
case MON_RATIO_21_9: return DP_ENUM_STR(MON_RATIO_21_9);
case MON_RATIO_21_10: return DP_ENUM_STR(MON_RATIO_21_10);
case MON_RATIO_32_9: return DP_ENUM_STR(MON_RATIO_32_9);
case MON_RATIO_32_10: return DP_ENUM_STR(MON_RATIO_32_10);
case MON_RATIO_NA: return DP_ENUM_STR(MON_RATIO_NA);
default: return "unknown";
}
}
/* adapter type : SST or MST */
enum secdp_adapter_t {
SECDP_ADT_UNKNOWN = -1,
SECDP_ADT_SST = 10,
SECDP_ADT_MST = 11,
};
/* dex supported resolutions */
enum dex_support_res_t {
DEX_RES_NOT_SUPPORT = 0,
DEX_RES_1600X900, /* HD+ */
DEX_RES_1920X1080, /* FHD */
DEX_RES_1920X1200, /* WUXGA */
DEX_RES_2560X1080, /* UW-UXGA */
DEX_RES_2560X1440, /* QHD */
DEX_RES_2560X1600, /* WQXGA */
DEX_RES_3440X1440, /* UW-QHD */
DEX_RES_END,
};
static inline char *secdp_dex_res_to_string(int res)
{
switch (res) {
case DEX_RES_NOT_SUPPORT:
return DP_ENUM_STR(DEX_RES_NOT_SUPPORT);
case DEX_RES_1920X1080:
return DP_ENUM_STR(DEX_RES_1920X1080);
case DEX_RES_1920X1200:
return DP_ENUM_STR(DEX_RES_1920X1200);
case DEX_RES_2560X1080:
return DP_ENUM_STR(DEX_RES_2560X1080);
case DEX_RES_2560X1440:
return DP_ENUM_STR(DEX_RES_2560X1440);
case DEX_RES_2560X1600:
return DP_ENUM_STR(DEX_RES_2560X1600);
case DEX_RES_3440X1440:
return DP_ENUM_STR(DEX_RES_3440X1440);
default:
return "unknown";
}
}
#define DEX_RES_DFT DEX_RES_1920X1080 /* DeX default resolution */
#define DEX_DFT_COL 1920
#define DEX_DFT_ROW 1080
#define DEX_RES_MAX DEX_RES_3440X1440 /* DeX max resolution */
#define DEX_MAX_COL 3440
#define DEX_MAX_ROW 1440
#define DEX_FPS_MIN 50 /* DeX min refresh rate */
#define DEX_FPS_MAX 60 /* DeX max refresh rate */
enum DEX_STATUS {
DEX_DISABLED = 0,
DEX_ENABLED,
DEX_DURING_MODE_CHANGE,
};
/** redriver devices */
enum secdp_redrv_dev {
SECDP_REDRV_NONE = 0,
SECDP_REDRV_PTN36502, /* don't need AUX_SEL control */
SECDP_REDRV_PS5169, /* need AUX_SEL control */
};
static inline char *secdp_redrv_to_string(int res)
{
switch (res) {
case SECDP_REDRV_NONE:
return DP_ENUM_STR(SECDP_REDRV_NONE);
case SECDP_REDRV_PTN36502:
return DP_ENUM_STR(SECDP_REDRV_PTN36502);
case SECDP_REDRV_PS5169:
return DP_ENUM_STR(SECDP_REDRV_PS5169);
default:
return "unknown";
}
}
enum secdp_hw_ver_t {
DP_HW_LEGACY,
DP_HW_V123_HBR2_HBR3,
DP_HW_V123_HBR_RBR,
DP_HW_MAX,
};
static inline char *secdp_hw_to_string(int hw)
{
switch (hw) {
case DP_HW_LEGACY:
return DP_ENUM_STR(DP_HW_LEGACY);
case DP_HW_V123_HBR2_HBR3:
return DP_ENUM_STR(DP_HW_V123_HBR2_HBR3);
case DP_HW_V123_HBR_RBR:
return DP_ENUM_STR(DP_HW_V123_HBR_RBR);
default:
return "unknown";
}
}
enum secdp_phy_param_t {
DP_PARAM_VX, /* voltage swing */
DP_PARAM_PX, /* pre-emphasis */
DP_PARAM_MAX,
};
static inline char *secdp_phy_type_to_string(int param)
{
switch (param) {
case DP_PARAM_VX:
return DP_ENUM_STR(DP_PARAM_VX);
case DP_PARAM_PX:
return DP_ENUM_STR(DP_PARAM_PX);
default:
return "unknown";
}
}
#define EV_USBPD_ATTENTION BIT(13)
static inline char *secdp_ev_event_to_string(int event)
{
switch (event) {
case EV_USBPD_ATTENTION:
return DP_ENUM_STR(EV_USBPD_ATTENTION);
default:
return "unknown";
}
}
struct secdp_attention_node {
PD_NOTI_TYPEDEF noti;
struct list_head list;
};
struct secdp_adapter {
uint ven_id;
uint prod_id;
};
#define MON_NAME_LEN 14 /* monitor name length, max 13 chars + null */
#define MAX_NUM_HMD 32
#define DEX_TAG_HMD "HMD"
struct secdp_sink_dev {
uint ven_id; /* vendor id from PDIC */
uint prod_id; /* product id from PDIC */
char monitor_name[MON_NAME_LEN]; /* from EDID */
};
struct secdp_pdic_noti {
struct delayed_work reg_work;
struct notifier_block nb;
bool registered;
};
struct secdp_prefer {
enum mon_aspect_ratio_t ratio;
bool exist; /* true if preferred resolution */
bool ignore; /* true if larger refresh rate exists */
int hdisp; /* horizontal pixel of preferred resolution */
int vdisp; /* vertical pixel of preferred resolution */
int refresh; /* refresh rate of preferred resolution */
};
struct secdp_dex {
struct class *sysfs_class;
enum dex_support_res_t res; /* dex supported resolution */
enum DEX_STATUS prev; /* previously known as "dex_now" */
enum DEX_STATUS curr; /* previously known as "dex_en" */
int setting_ui; /* "dex_set", true if setting has Dex mode */
/*
* 2 if resolution is changed during dex mode change.
* And once dex framework reads the dex_node_stauts using dex node,
* it's assigned to same value with curr.
*/
enum DEX_STATUS status; /* previously known as "dex_node_status" */
char fw_ver[10]; /* firmware ver, 0:h/w, 1:s/w major, 2:s/w minor */
bool reconnecting; /* true if dex is under reconnecting */
#ifdef SECDP_IGNORE_PREFER_IF_DEX_RES_EXIST
bool res_exist; /* true if dex resolution exists */
#endif
};
struct secdp_display_timing {
u32 active_h;
u32 active_v;
u32 refresh_rate;
bool interlaced;
int clock; /* pixel clock, refer to "struct drm_display_mode" */
enum dex_support_res_t dex_res; /* dex supported resolution */
enum mon_aspect_ratio_t mon_ratio; /* monitor aspect ratio */
int supported; /* for unit test */
};
struct secdp_mst {
bool exist; /* true if MST receiver, false otherwise(SST) */
int hpd_count; /* avoid successive hpd low/high/low/.. from MST */
};
struct secdp_hmd {
struct secdp_sink_dev list[MAX_NUM_HMD]; /* supported HMD dev list */
struct mutex lock;
bool exist; /* true if connected sink is known HMD device */
};
struct secdp_hdcp {
struct delayed_work start_work;
int retry; /* count if dp link is unstable during hdcp */
};
struct secdp_hpd {
struct delayed_work noti_work;
bool noti_deferred;
atomic_t val; /* 1 if hpd high, 0 if hpd low" */
};
struct secdp_debug {
bool prefer_check_skip;
};
struct secdp_misc {
struct delayed_work link_status_work;
struct delayed_work poor_discon_work;
bool cable_connected; /* previously known as "cable_connected_phy" */
bool link_conf; /* previously known as "sec_link_conf" */
struct secdp_hpd hpd;
struct secdp_adapter adapter;
struct secdp_pdic_noti pdic_noti;
struct secdp_display_timing prf_timing; /* preferred timing */
struct secdp_display_timing mrr_timing; /* max "mirror" timing */
struct secdp_display_timing dex_timing; /* max "dex" timing */
struct secdp_prefer prefer;
struct secdp_hdcp hdcp;
struct secdp_debug debug;
struct secdp_sysfs *sysfs;
struct secdp_dex dex;
struct secdp_mst mst;
struct secdp_hmd hmd;
struct completion dp_off_comp;
struct completion dp_discon_comp;
bool dp_disconnecting;
struct mutex notify_lock;
struct mutex attention_lock;
struct mutex notifier_lock;
atomic_t noti_status;
struct notifier_block reboot_nb;
bool reboot; /* true if rebooted or shutdown */
#ifdef SECDP_USE_WAKELOCK
struct wakeup_source *ws;
#endif
#ifdef SECDP_EVENT_THREAD
/* for PDIC event handler */
struct secdp_event_data dp_event;
struct task_struct *ev_thread;
struct workqueue_struct *workq;
struct list_head attention_head;
#endif
#ifdef SECDP_SELF_TEST
struct delayed_work self_test_reconnect_work;
struct delayed_work self_test_hdcp_test_work;
void (*self_test_reconnect_callback)(void);
void (*self_test_hdcp_on_callback)(void);
void (*self_test_hdcp_off_callback)(void);
u8 self_test_edid[ST_EDID_SIZE];
#endif
};
bool secdp_check_if_lpm_mode(void);
int secdp_send_deferred_hpd_noti(void);
bool secdp_get_clk_status(enum dp_pm_type type);
void secdp_send_poor_connection_event(void);
int secdp_pdic_noti_register_ex(struct secdp_misc *sec, bool retry);
bool secdp_get_power_status(void);
bool secdp_get_cable_status(void);
bool secdp_get_hpd_irq_status(void);
int secdp_get_hpd_status(void);
bool secdp_get_poor_connection_status(void);
bool secdp_get_link_train_status(void);
struct dp_panel *secdp_get_panel_info(void);
struct drm_connector *secdp_get_connector(void);
void secdp_redriver_onoff(bool enable, int lane);
int secdp_is_mst_receiver(void);
int secdp_power_request_gpios(struct dp_power *dp_power);
void secdp_config_gpios_factory(int aux_sel, bool out_en);
enum dp_hpd_plug_orientation secdp_get_plug_orientation(void);
bool secdp_get_reboot_status(void);
bool secdp_check_hmd_dev(const char *name_to_search);
int secdp_store_hmd_dev(char *buf, size_t len, int num);
void secdp_timing_init(void);
void secdp_dex_do_reconnecting(void);
bool secdp_check_dex_reconnect(void);
bool secdp_check_dex_mode(void);
enum dex_support_res_t secdp_get_dex_res(void);
void secdp_clear_link_status_cnt(struct dp_link *dp_link);
void secdp_reset_link_status(struct dp_link *dp_link);
bool secdp_check_link_stable(struct dp_link *dp_link);
bool secdp_panel_hdr_supported(void);
#ifdef CONFIG_SEC_DISPLAYPORT_ENG
enum secdp_hw_preshoot_t {
DP_HW_PRESHOOT_0,
DP_HW_PRESHOOT_1,
DP_HW_PRESHOOT_MAX,
};
static inline char *secdp_preshoot_to_string(int hw)
{
switch (hw) {
case DP_HW_PRESHOOT_0:
return DP_ENUM_STR(DP_HW_PRESHOOT_0);
case DP_HW_PRESHOOT_1:
return DP_ENUM_STR(DP_HW_PRESHOOT_1);
default:
return "unknown";
}
}
int secdp_show_hmd_dev(char *buf);
int secdp_show_phy_param(char *buf);
/* preshoot adjustment */
int secdp_catalog_preshoot_show(char *buf);
void secdp_catalog_preshoot_store(char *buf);
/* voltage swing, pre-emphasis */
int secdp_parse_vxpx_show(enum secdp_hw_ver_t hw,
enum secdp_phy_param_t vxpx, char *buf);
int secdp_parse_vxpx_store(enum secdp_hw_ver_t hw,
enum secdp_phy_param_t vxpx, char *buf);
/* AUX configuration */
int secdp_aux_cfg_show(char *buf);
int secdp_aux_cfg_store(char *buf);
/* preferred resolution debug */
int secdp_debug_prefer_skip_show(void);
void secdp_debug_prefer_skip_store(bool skip);
int secdp_debug_prefer_ratio_show(void);
void secdp_debug_prefer_ratio_store(int ratio);
#endif/*CONFIG_SEC_DISPLAYPORT_ENG*/
#endif/*__SECDP_H*/
|