projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[9610] usbpd change abnormal detection threshold/time
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / ccic / s2mu106-usbpd.c
CommitLineData
5073353a
JB		 1/*
2 driver/usbpd/s2mu106.c - s2mu106 USB PD(Power Delivery) device driver
3 *
4 * Copyright (C) 2018 Samsung Electronics
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18#include <linux/gpio.h>
19#include <linux/of_gpio.h>
20#include <linux/i2c.h>
21#include <linux/interrupt.h>
22#include <linux/slab.h>
23#include <linux/platform_device.h>
24#include <linux/module.h>
25#include <linux/delay.h>
26#include <linux/completion.h>
27
28#include <linux/ccic/usbpd.h>
29#include <linux/ccic/usbpd-s2mu106.h>
30
40798a41
JB		 31#if defined(CONFIG_PM_S2MU106)
32#include <linux/power/s2mu106_pmeter.h>
33#endif
34
5073353a
JB		 35#include <linux/muic/muic.h>
36#if defined(CONFIG_MUIC_NOTIFIER)
37#include <linux/muic/muic_notifier.h>
38#endif /* CONFIG_MUIC_NOTIFIER */
39#ifdef CONFIG_BATTERY_SAMSUNG
40#include <linux/sec_batt.h>
41#include <linux/battery/sec_charging_common.h>
42#else
43#include <linux/power_supply.h>
44#endif
45#if defined(CONFIG_USB_HOST_NOTIFY) || defined(CONFIG_USB_HW_PARAM)
46#include <linux/usb_notify.h>
47#endif
48#include <linux/regulator/consumer.h>
49
50#if (defined CONFIG_IFCONN_NOTIFIER || defined CONFIG_DUAL_ROLE_USB_INTF)
51#include <linux/ccic/usbpd_ext.h>
52#endif
53#if defined CONFIG_IFCONN_NOTIFIER
54struct pdic_notifier_data pd_noti;
55#endif
56/*
57*VARIABLE DEFINITION
58*/
59static usbpd_phy_ops_type s2mu106_ops;
60struct i2c_client *test_i2c;
61
62static enum power_supply_property ccic_props[] = {
63};
64
65static char *ccic_supplied_to[] = {
66 "battery",
67};
68/*
69*FUNCTION DEFINITION
70*/
71static int s2mu106_receive_message(void *data);
72static int s2mu106_check_port_detect(struct s2mu106_usbpd_data *pdic_data);
73static int s2mu106_usbpd_reg_init(struct s2mu106_usbpd_data *_data);
74static void s2mu106_dfp(struct i2c_client *i2c);
75static void s2mu106_ufp(struct i2c_client *i2c);
99e9c3ca 76static int s2mu106_usbpd_check_msg(void *_data, u64 *val);
5073353a
JB		 77static void s2mu106_src(struct i2c_client *i2c);
78static void s2mu106_snk(struct i2c_client *i2c);
79static void s2mu106_assert_rd(void *_data);
80static void s2mu106_assert_rp(void *_data);
8a38de7f 81static void s2mu106_assert_drp(void *_data);
5073353a
JB		 82static void s2mu106_usbpd_check_rid(struct s2mu106_usbpd_data *pdic_data);
83static int s2mu106_usbpd_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest);
84static int s2mu106_usbpd_write_reg(struct i2c_client *i2c, u8 reg, u8 value);
85#ifndef CONFIG_SEC_FACTORY
5073353a
JB		 86static void s2mu106_usbpd_notify_detach(struct s2mu106_usbpd_data *pdic_data);
87#endif
88static void s2mu106_usbpd_detach_init(struct s2mu106_usbpd_data *pdic_data);
89static int s2mu106_usbpd_set_cc_control(struct s2mu106_usbpd_data *pdic_data, int val);
8a38de7f
KT		 90static void s2mu106_usbpd_set_rp_scr_sel(struct s2mu106_usbpd_data *pdic_data,
91 CCIC_RP_SCR_SEL scr_sel);
5073353a
JB		 92
93char *rid_text[] = {
94 "UNDEFINED",
95 "RID ERROR",
96 "RID ERROR",
97 "RID 255K",
98 "RID 301K",
99 "RID 523K",
100 "RID 619K"
101};
102
103static void s2mu106_usbpd_test_read(struct s2mu106_usbpd_data *usbpd_data)
104{
105 struct i2c_client *i2c = usbpd_data->i2c;
106 u8 data[10];
107
108 s2mu106_usbpd_read_reg(i2c, 0x1, &data[0]);
109 s2mu106_usbpd_read_reg(i2c, 0x18, &data[1]);
110 s2mu106_usbpd_read_reg(i2c, 0x27, &data[2]);
111 s2mu106_usbpd_read_reg(i2c, 0x28, &data[3]);
112 s2mu106_usbpd_read_reg(i2c, 0x40, &data[4]);
113 s2mu106_usbpd_read_reg(i2c, 0xe2, &data[5]);
114 s2mu106_usbpd_read_reg(i2c, 0xb3, &data[6]);
115 s2mu106_usbpd_read_reg(i2c, 0xb4, &data[7]);
8a38de7f 116 s2mu106_usbpd_read_reg(i2c, 0xf7, &data[8]);
5073353a 117
8a38de7f
KT		 118 pr_info("%s, 0x1(%x) 0x18(%x) 0x27(%x) 0x28(%x) 0x40(%x) 0xe2(%x) 0xb3(%x) 0xb4(%x) 0xf7(%X)\n",
119 __func__, data[0], data[1], data[2], data[3], data[4],
120 data[5], data[6], data[7], data[8]);
5073353a
JB		 121}
122
123void s2mu106_rprd_mode_change(struct s2mu106_usbpd_data *usbpd_data, u8 mode)
124{
125 u8 data = 0;
126 struct i2c_client *i2c = usbpd_data->i2c;
8a38de7f
KT		 127 struct device *dev = &i2c->dev;
128 struct usbpd_data *pd_data = dev_get_drvdata(dev);
5073353a
JB		 129 pr_info("%s, mode=0x%x\n", __func__, mode);
130
0ef320fa 131 mutex_lock(&usbpd_data->_mutex);
5073353a
JB		 132 if (usbpd_data->lpm_mode)
133 goto skip;
134
0ef320fa 135 pr_info("%s, %d\n", __func__, __LINE__);
5073353a
JB		 136 switch (mode) {
137 case TYPE_C_ATTACH_DFP: /* SRC */
8a38de7f 138 s2mu106_usbpd_set_cc_control(usbpd_data, USBPD_CC_OFF);
8a38de7f
KT		 139 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP0);
140 s2mu106_assert_rp(pd_data);
0ef320fa
JB		 141 msleep(20);
142 s2mu106_usbpd_detach_init(usbpd_data);
143 s2mu106_usbpd_notify_detach(usbpd_data);
144 msleep(600);
8a38de7f 145 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP80);
5073353a 146 msleep(S2MU106_ROLE_SWAP_TIME_MS);
8a38de7f 147 s2mu106_assert_drp(pd_data);
0ef320fa
JB		 148 usbpd_data->status_reg |= PLUG_ATTACH;
149 schedule_delayed_work(&usbpd_data->plug_work, 0);
5073353a
JB		 150 break;
151 case TYPE_C_ATTACH_UFP: /* SNK */
8a38de7f
KT		 152 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_MUIC,
153 IFCONN_NOTIFY_ID_ROLE_SWAP,
0ef320fa 154 IFCONN_NOTIFY_EVENT_PD_SINK, NULL);
8a38de7f 155 s2mu106_usbpd_set_cc_control(usbpd_data, USBPD_CC_OFF);
8a38de7f
KT		 156 s2mu106_assert_rp(pd_data);
157 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP0);
0ef320fa
JB		 158 msleep(20);
159 s2mu106_usbpd_detach_init(usbpd_data);
160 s2mu106_usbpd_notify_detach(usbpd_data);
161 msleep(600);
8a38de7f
KT		 162 s2mu106_assert_rd(pd_data);
163 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP80);
5073353a 164 msleep(S2MU106_ROLE_SWAP_TIME_MS);
8a38de7f 165 s2mu106_assert_drp(pd_data);
0ef320fa
JB		 166 usbpd_data->status_reg |= PLUG_ATTACH;
167 schedule_delayed_work(&usbpd_data->plug_work, 0);
5073353a
JB		 168 break;
169 case TYPE_C_ATTACH_DRP: /* DRP */
170 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
171 data |= S2MU106_REG_PLUG_CTRL_DRP;
172 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
173 break;
174 };
175skip:
0ef320fa 176 mutex_unlock(&usbpd_data->_mutex);
5073353a
JB		 177}
178
8a38de7f
KT		 179void usbpd_charger_test_read(struct s2mu106_usbpd_data *usbpd_data)
180{
181 struct power_supply *psy_charger;
182 union power_supply_propval val;
183 int ret = 0;
184
185 psy_charger = power_supply_get_by_name("s2mu106-charger");
186
187 if (psy_charger) {
188 ret = psy_charger->desc->set_property(psy_charger,
189 POWER_SUPPLY_PROP_USBPD_TEST_READ, &val);
190 } else {
191 pr_err("%s: Fail to get psy battery\n", __func__);
192
193 return;
194 }
195}
196
5073353a
JB		 197void vbus_turn_on_ctrl(struct s2mu106_usbpd_data *usbpd_data, bool enable)
198{
199 struct power_supply *psy_otg;
200 union power_supply_propval val;
201 int on = !!enable;
202 int ret = 0, retry_cnt = 0;
203
204 pr_info("%s %d, enable=%d\n", __func__, __LINE__, enable);
40798a41
JB		 205
206 if (usbpd_data->detach_valid) {
207 dev_info(usbpd_data->dev, "%s, ignore vbus control\n", __func__);
208 return;
209 }
210
5073353a
JB		 211 psy_otg = power_supply_get_by_name("otg");
212
213 if (psy_otg) {
214 val.intval = enable;
215 usbpd_data->is_otg_vboost = enable;
216 ret = psy_otg->desc->set_property(psy_otg, POWER_SUPPLY_PROP_ONLINE, &val);
217 } else {
218 pr_err("%s: Fail to get psy battery\n", __func__);
219
220 return;
221 }
222 if (ret) {
223 pr_err("%s: fail to set power_suppy ONLINE property(%d)\n",
224 __func__, ret);
225 } else {
226 if (enable == VBUS_ON) {
227 for (retry_cnt = 0; retry_cnt < 5; retry_cnt++) {
228 psy_otg->desc->get_property(psy_otg, POWER_SUPPLY_PROP_ONLINE, &val);
229 if (val.intval == VBUS_OFF) {
230 msleep(100);
231 val.intval = enable;
232 psy_otg->desc->set_property(psy_otg, POWER_SUPPLY_PROP_ONLINE, &val);
233 } else
234 break;
235 }
236 }
237 pr_info("otg accessory power = %d\n", on);
238 }
239
240}
241
40798a41
JB		 242#ifdef CONFIG_PM_S2MU106
243static void s2mu106_usbpd_set_pmeter_mode(struct s2mu106_usbpd_data *pdic_data,
244 int mode)
245{
246 struct power_supply *psy_pm = pdic_data->psy_pm;
247 union power_supply_propval val;
248 int ret = 0;
249
250 pr_info("%s, mode=%d\n", __func__, mode);
251
252 if (psy_pm) {
253 val.intval = mode;
254 ret = psy_pm->desc->set_property(psy_pm,
255 POWER_SUPPLY_PROP_CO_ENABLE, &val);
256 } else {
257 pr_err("%s: Fail to get pmeter\n", __func__);
258 return;
259 }
260
261 if (ret) {
262 pr_err("%s: Fail to set pmeter\n", __func__);
263 return;
264 }
265}
266
267static int s2mu106_usbpd_get_pmeter_volt(struct s2mu106_usbpd_data *pdic_data)
268{
269
270 struct power_supply *psy_pm = pdic_data->psy_pm;
271 union power_supply_propval val;
272 int ret = 0;
273
8a38de7f 274 if (psy_pm)
40798a41 275 ret = psy_pm->desc->get_property(psy_pm, POWER_SUPPLY_PROP_VCHGIN, &val);
8a38de7f 276 else {
40798a41
JB		 277 pr_err("%s: Fail to get pmeter\n", __func__);
278 return -1;
279 }
280
281 if (ret) {
282 pr_err("%s: fail to set power_suppy pmeter property(%d)\n",
283 __func__, ret);
284 return -1;
285 }
286
287 pdic_data->pm_chgin = val.intval;
288
289 return 0;
290}
291
8a38de7f
KT		 292static int s2mu106_usbpd_get_pmeter_current(struct s2mu106_usbpd_data *pdic_data)
293{
294
295 struct power_supply *psy_pm = pdic_data->psy_pm;
296 union power_supply_propval val;
297 int ret = 0;
298
299 if (psy_pm)
300 psy_pm->desc->get_property(psy_pm, POWER_SUPPLY_PROP_ICHGIN, &val);
301 else {
302 pr_err("%s: Fail to get pmeter\n", __func__);
303 return -1;
304 }
305
306 if (ret) {
307 pr_err("%s: fail to set power_suppy pmeter property(%d)\n",
308 __func__, ret);
309 return -1;
310 }
311
312 pdic_data->pm_chgin_i = val.intval;
313
314 return 0;
315}
316
40798a41
JB		 317static int s2mu106_usbpd_check_vbus(struct s2mu106_usbpd_data *pdic_data,
318 int volt, CCIC_VBUS_SEL mode)
319{
40798a41
JB		 320 int ret = 0;
321
322 if (mode == VBUS_OFF) {
c967ccaf
JP		 323 ret = s2mu106_usbpd_get_pmeter_volt(pdic_data);
324 if (ret < 0)
325 return ret;
326
327 if (pdic_data->pm_chgin < volt) {
328 pr_info("%s chgin volt(%d) finish!\n", __func__,
329 pdic_data->pm_chgin);
330 return true;
331 } else {
332 pr_info("%s chgin volt(%d) waiting 400ms!\n",
333 __func__, pdic_data->pm_chgin);
334 msleep(400);
335 return true;
40798a41
JB		 336 }
337 } else if (mode == VBUS_ON) {
338 ret = s2mu106_usbpd_get_pmeter_volt(pdic_data);
339 if (ret < 0)
340 return ret;
0e05bc4a
JB		 341 if (pdic_data->pm_chgin > volt) {
342 pr_info("%s vbus volt(%d->%d) mode(%d)!\n",
343 __func__, volt, pdic_data->pm_chgin, mode);
40798a41 344 return true;
0e05bc4a
JB		 345 } else
346 return false;
40798a41
JB		 347 }
348
349 pr_info("%s failed check vbus volt(%d->%d) mode(%d)!\n",
350 __func__, volt, pdic_data->pm_chgin, mode);
351
352 return false;
353}
354#endif
355
356static int s2mu106_usbpd_check_accessory(struct s2mu106_usbpd_data *pdic_data)
357{
358 struct i2c_client *i2c = pdic_data->i2c;
359 u8 val, cc1_val, cc2_val;
360
361 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
362
363 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
364 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
365
366 if ((cc1_val == USBPD_Rd && cc2_val == USBPD_Rd) ||
367 (cc1_val == USBPD_Ra && cc2_val == USBPD_Ra))
368 return -1;
369
370 return 0;
371}
372
5073353a
JB		 373#if defined(CONFIG_IFCONN_NOTIFIER)
374static void process_dr_swap(struct s2mu106_usbpd_data *usbpd_data)
375{
0ef320fa 376 schedule_delayed_work(&usbpd_data->dr_work, msecs_to_jiffies(0));
5073353a
JB		 377}
378#endif
379
40798a41
JB		 380static void s2mu106_pr_swap(void *_data, int val)
381{
382 struct usbpd_data *data = (struct usbpd_data *) _data;
383 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
384
0ef320fa
JB		 385 if (val == USBPD_SINK_OFF) {
386 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
387 IFCONN_NOTIFY_ID_ROLE_SWAP,
388 IFCONN_NOTIFY_EVENT_PD_SOURCE, 0);
40798a41
JB		 389 ifconn_event_work(pdic_data, IFCONN_NOTIFY_BATTERY,
390 IFCONN_NOTIFY_ID_DETACH, 0, 0);
0ef320fa 391 } else if (val == USBPD_SOURCE_ON) {
40798a41
JB		 392#if defined(CONFIG_DUAL_ROLE_USB_INTF)
393 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SRC;
8a38de7f
KT		 394#elif defined(CONFIG_TYPEC)
395 pdic_data->typec_power_role = TYPEC_SOURCE;
8a38de7f 396#endif
40798a41
JB		 397 } else if (val == USBPD_SOURCE_OFF) {
398 ifconn_event_work(pdic_data, IFCONN_NOTIFY_BATTERY,
399 IFCONN_NOTIFY_ID_DETACH, 0, 0);
400#if defined(CONFIG_DUAL_ROLE_USB_INTF)
401 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SNK;
8a38de7f
KT		 402#elif defined(CONFIG_TYPEC)
403 pdic_data->typec_power_role = TYPEC_SINK;
8a38de7f 404#endif
40798a41 405 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
0ef320fa
JB		 406 IFCONN_NOTIFY_ID_ROLE_SWAP,
407 IFCONN_NOTIFY_EVENT_PD_SINK, 0);
40798a41 408 }
0ef320fa
JB		 409#if defined(CONFIG_TYPEC)
410 if (val == USBPD_PR_DONE) {
411 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
412 if (pdic_data->typec_try_state_change == TYPE_C_PR_SWAP)
413 complete(&pdic_data->role_reverse_completion);
414 }
415#endif
40798a41
JB		 416}
417
5073353a
JB		 418static int s2mu106_usbpd_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest)
419{
420 int ret;
421 struct device *dev = &i2c->dev;
422#if defined(CONFIG_USB_HW_PARAM)
423 struct otg_notify *o_notify = get_otg_notify();
424#endif
425
426 ret = i2c_smbus_read_byte_data(i2c, reg);
427 if (ret < 0) {
428 dev_err(dev, "%s reg(0x%x), ret(%d)\n", __func__, reg, ret);
429#if defined(CONFIG_USB_HW_PARAM)
430 if (o_notify)
431 inc_hw_param(o_notify, USB_CCIC_I2C_ERROR_COUNT);
432#endif
433 return ret;
434 }
435 ret &= 0xff;
436 *dest = ret;
437 return 0;
438}
439
440static int s2mu106_usbpd_bulk_read(struct i2c_client *i2c, u8 reg, int count, u8 *buf)
441{
442 int ret;
443 struct device *dev = &i2c->dev;
444#if defined(CONFIG_USB_HW_PARAM)
445 struct otg_notify *o_notify = get_otg_notify();
446#endif
447#ifdef CONFIG_SEC_FACTORY
448 int retry = 0;
449#endif
450
451 ret = i2c_smbus_read_i2c_block_data(i2c, reg, count, buf);
452#ifdef CONFIG_SEC_FACTORY
453 for (retry = 0; retry < 5; retry++) {
454 if (ret < 0) {
455 dev_err(dev, "%s reg(0x%x), ret(%d) retry(%d) after now\n",
456 __func__, reg, ret, retry);
457 msleep(40);
458 ret = i2c_smbus_read_i2c_block_data(i2c, reg, count, buf);
459 } else
460 break;
461 }
462
463 if (ret < 0) {
464 dev_err(dev, "%s failed to read reg, ret(%d)\n", __func__, ret);
465#else
466 if (ret < 0) {
467 dev_err(dev, "%s reg(0x%x), ret(%d)\n", __func__, reg, ret);
468#endif
469
470#if defined(CONFIG_USB_HW_PARAM)
471 if (o_notify)
472 inc_hw_param(o_notify, USB_CCIC_I2C_ERROR_COUNT);
473#endif
474 return ret;
475 }
476
477 return 0;
478}
479
480static int s2mu106_usbpd_write_reg(struct i2c_client *i2c, u8 reg, u8 value)
481{
482 int ret;
483 struct device *dev = &i2c->dev;
484#if defined(CONFIG_USB_HW_PARAM)
485 struct otg_notify *o_notify = get_otg_notify();
486#endif
487
488 ret = i2c_smbus_write_byte_data(i2c, reg, value);
489 if (ret < 0) {
490 dev_err(dev, "%s reg(0x%x), ret(%d)\n", __func__, reg, ret);
491#if defined(CONFIG_USB_HW_PARAM)
492 if (o_notify)
493 inc_hw_param(o_notify, USB_CCIC_I2C_ERROR_COUNT);
494#endif
495 }
496 return ret;
497}
498
499static int s2mu106_usbpd_bulk_write(struct i2c_client *i2c, u8 reg, int count, u8 *buf)
500{
501 int ret;
502 struct device *dev = &i2c->dev;
503#if defined(CONFIG_USB_HW_PARAM)
504 struct otg_notify *o_notify = get_otg_notify();
505#endif
506
507 ret = i2c_smbus_write_i2c_block_data(i2c, reg, count, buf);
508 if (ret < 0) {
509 dev_err(dev, "%s reg(0x%x), ret(%d)\n", __func__, reg, ret);
510#if defined(CONFIG_USB_HW_PARAM)
511 if (o_notify)
512 inc_hw_param(o_notify, USB_CCIC_I2C_ERROR_COUNT);
513#endif
514 return ret;
515 }
516 return 0;
517}
518
519static int s2mu106_usbpd_update_bit(struct i2c_client *i2c,
520 u8 reg, u8 mask, u8 shift, u8 value)
521{
522 int ret;
523 u8 reg_val = 0;
524
525 ret = s2mu106_usbpd_read_reg(i2c, reg, &reg_val);
526 if (ret < 0) {
527 pr_err("%s: Reg = 0x%X, val = 0x%X, read err : %d\n",
528 __func__, reg, reg_val, ret);
529 }
530 reg_val &= ~mask;
531 reg_val |= value << shift;
532 ret = s2mu106_usbpd_write_reg(i2c, reg, reg_val);
533 if (ret < 0) {
534 pr_err("%s: Reg = 0x%X, mask = 0x%X, val = 0x%X, write err : %d\n",
535 __func__, reg, mask, value, ret);
536 }
537
538 return ret;
539}
540
99e9c3ca
JB		 541static int s2mu106_write_msg_all(struct i2c_client *i2c, int count, u8 *buf)
542{
543 int ret;
544
545 ret = s2mu106_usbpd_bulk_write(i2c, S2MU106_REG_MSG_TX_HEADER_L,
546 2 + (count * 4), buf);
547
548 return ret;
549}
550#if 0
5073353a
JB		 551static int s2mu106_write_msg_header(struct i2c_client *i2c, u8 *buf)
552{
553 int ret;
554
555 ret = s2mu106_usbpd_bulk_write(i2c, S2MU106_REG_MSG_TX_HEADER_L, 2, buf);
556
557 return ret;
558}
559
560static int s2mu106_write_msg_obj(struct i2c_client *i2c, int count, data_obj_type *obj)
561{
562 int ret = 0;
563 int i = 0;
564 struct device *dev = &i2c->dev;
565
566 if (count > S2MU106_MAX_NUM_MSG_OBJ)
567 dev_err(dev, "%s, not invalid obj count number\n", __func__);
568 else
569 for (i = 0; i < count; i++) {
570 ret = s2mu106_usbpd_bulk_write(i2c,
571 S2MU106_REG_MSG_TX_OBJECT0_0_L + (4 * i),
572 4, obj[i].byte);
573 }
574
575 return ret;
576}
99e9c3ca 577#endif
5073353a
JB		 578static int s2mu106_send_msg(struct i2c_client *i2c)
579{
580 int ret;
581 u8 reg = S2MU106_REG_MSG_SEND_CON;
582 u8 val = S2MU106_REG_MSG_SEND_CON_OP_MODE
583 | S2MU106_REG_MSG_SEND_CON_SEND_MSG_EN;
584
585 s2mu106_usbpd_write_reg(i2c, reg, val);
586
99e9c3ca
JB		 587 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_OP_MODE |
588 S2MU106_REG_MSG_SEND_CON_HARD_EN);
5073353a
JB		 589
590 return ret;
591}
592
593static int s2mu106_read_msg_header(struct i2c_client *i2c, msg_header_type *header)
594{
595 int ret;
596
597 ret = s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_MSG_RX_HEADER_L, 2, header->byte);
598
599 return ret;
600}
601
602static int s2mu106_read_msg_obj(struct i2c_client *i2c, int count, data_obj_type *obj)
603{
604 int ret = 0;
605 int i = 0;
606 struct device *dev = &i2c->dev;
607
608 if (count > S2MU106_MAX_NUM_MSG_OBJ) {
609 dev_err(dev, "%s, not invalid obj count number\n", __func__);
610 ret = -EINVAL; /*TODO: check fail case */
611 } else {
612 for (i = 0; i < count; i++) {
613 ret = s2mu106_usbpd_bulk_read(i2c,
614 S2MU106_REG_MSG_RX_OBJECT0_0_L + (4 * i),
615 4, obj[i].byte);
616 }
617 }
618
619 return ret;
620}
621
622static void s2mu106_set_irq_enable(struct s2mu106_usbpd_data *_data,
623 u8 int0, u8 int1, u8 int2, u8 int3, u8 int4, u8 int5)
624{
625 u8 int_mask[S2MU106_MAX_NUM_INT_STATUS]
626 = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
627 int ret = 0;
628 struct i2c_client *i2c = _data->i2c;
629 struct device *dev = &i2c->dev;
630
631 int_mask[0] &= ~int0;
632 int_mask[1] &= ~int1;
633 int_mask[2] &= ~int2;
634 int_mask[3] &= ~int3;
635 int_mask[4] &= ~int4;
636 int_mask[5] &= ~int5;
637
638 ret = i2c_smbus_write_i2c_block_data(i2c, S2MU106_REG_INT_MASK0,
639 S2MU106_MAX_NUM_INT_STATUS, int_mask);
640
641 if (ret < 0)
642 dev_err(dev, "err write interrupt mask \n");
643}
644
645static void s2mu106_self_soft_reset(struct i2c_client *i2c)
646{
647 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_ETC,
648 S2MU106_REG_ETC_SOFT_RESET_EN);
649 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_ETC,
650 S2MU106_REG_ETC_SOFT_RESET_DIS);
651}
652
653static void s2mu106_driver_reset(void *_data)
654{
655 struct usbpd_data *data = (struct usbpd_data *) _data;
656 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
657 int i;
658
659 pdic_data->status_reg = 0;
660 data->wait_for_msg_arrived = 0;
661 pdic_data->header.word = 0;
662 for (i = 0; i < S2MU106_MAX_NUM_MSG_OBJ; i++)
663 pdic_data->obj[i].object = 0;
664
665 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
666 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
667}
668
669static void s2mu106_assert_drp(void *_data)
670{
671 struct usbpd_data *data = (struct usbpd_data *) _data;
672 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
673 struct i2c_client *i2c = pdic_data->i2c;
674 u8 val;
675
676 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &val);
677 val &= ~S2MU106_REG_PLUG_CTRL_FSM_MANUAL_EN;
678 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, val);
679
680 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &val);
681 val &= ~S2MU106_REG_PLUG_CTRL_FSM_MANUAL_INPUT_MASK;
682 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, val);
683}
684
685static void s2mu106_assert_rd(void *_data)
686{
687 struct usbpd_data *data = (struct usbpd_data *) _data;
688 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
689 struct i2c_client *i2c = pdic_data->i2c;
690 u8 val;
0ef320fa 691#if 0
5073353a
JB		 692 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
693
694 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
695 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
0ef320fa 696#endif
5073353a 697
0ef320fa 698 if (pdic_data->cc1_val == USBPD_Rd) {
5073353a
JB		 699 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &val);
700 val = (val & ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK) |
701 S2MU106_REG_PLUG_CTRL_CC1_MANUAL_ON;
702 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, val);
703
704 if (pdic_data->vconn_en) {
705 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &val);
706 val = (val & ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK) |
707 S2MU106_REG_PLUG_CTRL_RpRd_CC2_VCONN |
708 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
709 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, val);
710 }
711 }
712
0ef320fa 713 if (pdic_data->cc2_val == USBPD_Rd) {
5073353a
JB		 714 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &val);
715 val = (val & ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK) |
716 S2MU106_REG_PLUG_CTRL_CC2_MANUAL_ON;
717 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, val);
718
719 if (pdic_data->vconn_en) {
720 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &val);
721 val = (val & ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK) |
722 S2MU106_REG_PLUG_CTRL_RpRd_CC1_VCONN |
723 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
724 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, val);
725 }
726 }
727
728 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &val);
729 val &= ~S2MU106_REG_PLUG_CTRL_FSM_MANUAL_INPUT_MASK;
730 val |= S2MU106_REG_PLUG_CTRL_FSM_ATTACHED_SNK;
731 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, val);
732
733 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &val);
734 val |= S2MU106_REG_PLUG_CTRL_FSM_MANUAL_EN;
735 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, val);
736}
737
738static void s2mu106_assert_rp(void *_data)
739{
740 struct usbpd_data *data = (struct usbpd_data *) _data;
741 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
742 struct i2c_client *i2c = pdic_data->i2c;
743 u8 val;
744
745 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &val);
746 val &= ~S2MU106_REG_PLUG_CTRL_FSM_MANUAL_INPUT_MASK;
747 val |= S2MU106_REG_PLUG_CTRL_FSM_ATTACHED_SRC;
748 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, val);
749
750 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &val);
751 val |= S2MU106_REG_PLUG_CTRL_FSM_MANUAL_EN;
752 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, val);
753}
754
755static unsigned s2mu106_get_status(void *_data, unsigned flag)
756{
757 unsigned ret;
758 struct usbpd_data *data = (struct usbpd_data *) _data;
759 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
760
761 if (pdic_data->status_reg & flag) {
762 ret = pdic_data->status_reg & flag;
763 pdic_data->status_reg &= ~flag; /* clear the flag */
764 return ret;
765 } else {
766 return 0;
767 }
768}
769
770static bool s2mu106_poll_status(void *_data)
771{
772 struct usbpd_data *data = (struct usbpd_data *) _data;
5073353a
JB		 773 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
774 struct i2c_client *i2c = pdic_data->i2c;
775 struct device *dev = &i2c->dev;
776 u8 intr[S2MU106_MAX_NUM_INT_STATUS] = {0};
777 int ret = 0, retry = 0;
778 u64 status_reg_val = 0;
99e9c3ca
JB		 779 msg_header_type header;
780 int data_obj_num = 0;
5073353a
JB		 781
782 ret = s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
783 S2MU106_MAX_NUM_INT_STATUS, intr);
784
785 dev_info(dev, "%s status[0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x]\n",
786 __func__, intr[0], intr[1], intr[2], intr[3], intr[4], intr[5], intr[6]);
787
99e9c3ca 788 if ((intr[0] | intr[1] | intr[2] | intr[3] | intr[4] | intr[5]) == 0)
5073353a 789 goto out;
5073353a
JB		 790
791 if ((intr[2] & S2MU106_REG_INT_STATUS2_WAKEUP) ||
792 (intr[4] & S2MU106_REG_INT_STATUS4_CC12_DET_IRQ))
793 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
794 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
795
5073353a
JB		 796 /* when occur detach & attach atomic */
797 if (intr[4] & S2MU106_REG_INT_STATUS4_USB_DETACH) {
798 status_reg_val |= PLUG_DETACH;
799 }
800
801 mutex_lock(&pdic_data->lpm_mutex);
802 if ((intr[4] & S2MU106_REG_INT_STATUS4_PLUG_IRQ) &&
803 !pdic_data->lpm_mode && !pdic_data->is_water_detect)
804 status_reg_val |= PLUG_ATTACH;
805 else if (pdic_data->lpm_mode &&
806 (intr[4] & S2MU106_REG_INT_STATUS4_PLUG_IRQ) &&
807 !pdic_data->is_water_detect)
808 retry = 1;
809 mutex_unlock(&pdic_data->lpm_mutex);
810
811 if (retry) {
812 msleep(40);
813 mutex_lock(&pdic_data->lpm_mutex);
814 if ((intr[4] & S2MU106_REG_INT_STATUS4_PLUG_IRQ) &&
815 !pdic_data->lpm_mode && !pdic_data->is_water_detect)
816 status_reg_val |= PLUG_ATTACH;
817 mutex_unlock(&pdic_data->lpm_mutex);
818 }
819
99e9c3ca
JB		 820 if (intr[5] & S2MU106_REG_INT_STATUS5_HARD_RESET)
821 status_reg_val |= MSG_HARDRESET;
5073353a 822
99e9c3ca 823 if (intr[0] & S2MU106_REG_INT_STATUS0_MSG_GOODCRC)
5073353a
JB		 824 status_reg_val |= MSG_GOODCRC;
825
99e9c3ca
JB		 826 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PR_SWAP)
827 status_reg_val |= MSG_PR_SWAP;
5073353a 828
99e9c3ca
JB		 829 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_SOFTRESET)
830 status_reg_val |= MSG_SOFTRESET;
5073353a 831
99e9c3ca
JB		 832 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_DR_SWAP)
833 status_reg_val |= MSG_DR_SWAP;
5073353a 834
8a38de7f
KT		 835 if (intr[0] & S2MU106_REG_INT_STATUS0_MSG_ACCEPT)
836 status_reg_val |= MSG_ACCEPT;
837
99e9c3ca
JB		 838 /* function that support dp control */
839 if (intr[4] & S2MU106_REG_INT_STATUS4_MSG_PASS) {
840 if (intr[3] & S2MU106_REG_INT_STATUS3_UNS_CMD_DATA)
841 status_reg_val |= MSG_RID;
842 else {
843 usbpd_protocol_rx(data);
8a38de7f
KT		 844 if (data->msg_received == 0)
845 goto out;
846
99e9c3ca
JB		 847 header = data->protocol_rx.msg_header;
848 data_obj_num = header.num_data_objs;
5073353a 849
99e9c3ca
JB		 850 if (data_obj_num > 0)
851 s2mu106_usbpd_check_msg(data, &status_reg_val);
5073353a 852
99e9c3ca
JB		 853 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PSRDY)
854 status_reg_val |= MSG_PSRDY;
5073353a 855
99e9c3ca
JB		 856 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_REQUEST)
857 status_reg_val |= MSG_REQUEST;
5073353a 858
99e9c3ca
JB		 859 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_REJECT)
860 status_reg_val |= MSG_REJECT;
5073353a 861
99e9c3ca
JB		 862 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_WAIT)
863 status_reg_val |= MSG_WAIT;
5073353a 864
99e9c3ca
JB		 865 if (intr[4] & S2MU106_REG_INT_STATUS4_MSG_ERROR)
866 status_reg_val |= MSG_ERROR;
5073353a 867
99e9c3ca
JB		 868 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PING)
869 status_reg_val |= MSG_PING;
5073353a 870
99e9c3ca
JB		 871 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_GETSNKCAP)
872 status_reg_val |= MSG_GET_SNK_CAP;
5073353a 873
99e9c3ca
JB		 874 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_GETSRCCAP)
875 status_reg_val |= MSG_GET_SRC_CAP;
5073353a 876
99e9c3ca
JB		 877 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_VCONN_SWAP)
878 status_reg_val |= MSG_VCONN_SWAP;
879 }
5073353a 880 }
5073353a
JB		 881out:
882 pdic_data->status_reg |= status_reg_val;
883
884 /* complete wait msg */
885 if (pdic_data->status_reg & data->wait_for_msg_arrived) {
886 data->wait_for_msg_arrived = 0;
887 complete(&data->msg_arrived);
888 }
889
890 return 0;
891}
892
40798a41
JB		 893static void s2mu106_soft_reset(void *_data)
894{
895 struct usbpd_data *data = (struct usbpd_data *) _data;
896 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
897 struct i2c_client *i2c = pdic_data->i2c;
898
899 s2mu106_self_soft_reset(i2c);
900}
901
5073353a
JB		 902static int s2mu106_hard_reset(void *_data)
903{
904 struct usbpd_data *data = (struct usbpd_data *) _data;
905 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
906 struct i2c_client *i2c = pdic_data->i2c;
907 int ret;
908 u8 reg;
40798a41 909 u8 Read_Value = 0;
5073353a
JB		 910
911 if (pdic_data->rid != REG_RID_UNDF && pdic_data->rid != REG_RID_MAX)
912 return 0;
913
914 reg = S2MU106_REG_MSG_SEND_CON;
915
916 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_SOP_HardRST
917 | S2MU106_REG_MSG_SEND_CON_OP_MODE);
918 if (ret < 0)
919 goto fail;
40798a41 920
5073353a
JB		 921 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_SOP_HardRST
922 | S2MU106_REG_MSG_SEND_CON_OP_MODE
923 | S2MU106_REG_MSG_SEND_CON_SEND_MSG_EN);
924 if (ret < 0)
925 goto fail;
40798a41
JB		 926
927 /* USB PD CC Off*/
928 Read_Value &= ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK;
929 Read_Value |= S2MU106_REG_PLUG_CTRL_CC_MANUAL_EN;
930 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, Read_Value);
931
932 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_OP_MODE
933 | S2MU106_REG_MSG_SEND_CON_HARD_EN);
5073353a 934 udelay(1);
40798a41 935 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_HARD_EN);
5073353a
JB		 936 if (ret < 0)
937 goto fail;
938
939 s2mu106_self_soft_reset(i2c);
940
941 pdic_data->status_reg = 0;
942
943 return 0;
944
945fail:
946 return -EIO;
947}
948
949static int s2mu106_receive_message(void *data)
950{
951 struct s2mu106_usbpd_data *pdic_data = data;
952 struct i2c_client *i2c = pdic_data->i2c;
953 struct device *dev = &i2c->dev;
954 int obj_num = 0;
955 int ret = 0;
956
957 ret = s2mu106_read_msg_header(i2c, &pdic_data->header);
958 if (ret < 0)
959 dev_err(dev, "%s read msg header error\n", __func__);
960
9b736c3b
JB		 961 if (pdic_data->header.spec_revision < 2 &&
962 pdic_data->header.num_data_objs > 0 &&
963 pdic_data->header.msg_type == 6) {
964 usleep_range(500, 900);
965 ret = s2mu106_read_msg_header(i2c, &pdic_data->header);
966 if (ret < 0)
967 dev_err(dev, "%s read msg header error\n", __func__);
968 }
969
5073353a
JB		 970 obj_num = pdic_data->header.num_data_objs;
971
972 if (obj_num > 0) {
973 ret = s2mu106_read_msg_obj(i2c,
974 obj_num, &pdic_data->obj[0]);
975 }
976
977 return ret;
978}
979
980static int s2mu106_tx_msg(void *_data,
981 msg_header_type *header, data_obj_type *obj)
982{
983 struct usbpd_data *data = (struct usbpd_data *) _data;
984 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
985 struct i2c_client *i2c = pdic_data->i2c;
986 int ret = 0;
99e9c3ca 987 int i = 0;
5073353a 988 int count = 0;
99e9c3ca
JB		 989 u8 send_msg[30];
990
991 pr_info("%s, \n", __func__);
5073353a 992
5073353a
JB		 993 /* if there is no attach, skip tx msg */
994 if (pdic_data->detach_valid)
995 goto done;
996
99e9c3ca 997#if 0
5073353a
JB		 998 /* using msg id counter at s2mu106 */
999 s2mu106_usbpd_read_reg(pdic_data->i2c, S2MU106_REG_ID_MONITOR, &reg_data);
1000 msg_id = reg_data & S2MU106_REG_ID_MONITOR_MSG_ID_MASK;
1001 header->msg_id = msg_id;
99e9c3ca
JB		 1002#endif
1003 send_msg[0] = header->byte[0];
1004 send_msg[1] = header->byte[1];
5073353a
JB		 1005
1006 count = header->num_data_objs;
1007
99e9c3ca
JB		 1008 for (i = 0; i < count; i++) {
1009 send_msg[2 + (i * 4)] = obj[i].byte[0];
1010 send_msg[3 + (i * 4)] = obj[i].byte[1];
1011 send_msg[4 + (i * 4)] = obj[i].byte[2];
1012 send_msg[5 + (i * 4)] = obj[i].byte[3];
5073353a
JB		 1013 }
1014
99e9c3ca
JB		 1015 ret = s2mu106_write_msg_all(i2c, count, send_msg);
1016 if (ret < 0)
1017 goto done;
1018
5073353a
JB		 1019 s2mu106_send_msg(i2c);
1020
5073353a 1021done:
5073353a
JB		 1022 return ret;
1023}
1024
1025static int s2mu106_rx_msg(void *_data,
1026 msg_header_type *header, data_obj_type *obj)
1027{
1028 struct usbpd_data *data = (struct usbpd_data *) _data;
1029 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1030 int i;
1031 int count = 0;
1032
1033 if (!s2mu106_receive_message(pdic_data)) {
1034 header->word = pdic_data->header.word;
1035 count = pdic_data->header.num_data_objs;
1036 if (count > 0) {
1037 for (i = 0; i < count; i++)
1038 obj[i].object = pdic_data->obj[i].object;
1039 }
1040 pdic_data->header.word = 0; /* To clear for duplicated call */
1041 return 0;
1042 } else {
1043 return -EINVAL;
1044 }
1045}
1046
1047static int s2mu106_set_otg_control(void *_data, int val)
1048{
1049 struct usbpd_data *data = (struct usbpd_data *) _data;
1050 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1051
40798a41 1052 mutex_lock(&pdic_data->cc_mutex);
5073353a
JB		 1053 if (val)
1054 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
1055 else
1056 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
40798a41 1057 mutex_unlock(&pdic_data->cc_mutex);
5073353a
JB		 1058
1059 return 0;
1060}
1061
1062static int s2mu106_set_cc_control(void *_data, int val)
40798a41
JB		 1063{
1064 struct usbpd_data *data = (struct usbpd_data *) _data;
1065 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1066 int ret = 0;
1067
1068 mutex_lock(&pdic_data->cc_mutex);
1069 ret = s2mu106_usbpd_set_cc_control(pdic_data, val);
1070 mutex_unlock(&pdic_data->cc_mutex);
1071
1072 return ret;
1073}
1074
7158ce20
JB		 1075static int s2mu106_set_rp_control(void *_data, int val)
1076{
1077 struct usbpd_data *data = (struct usbpd_data *) _data;
1078 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1079
1080 mutex_lock(&pdic_data->cc_mutex);
1081 s2mu106_usbpd_set_rp_scr_sel(pdic_data, val);
1082 mutex_unlock(&pdic_data->cc_mutex);
1083
1084 return 0;
1085}
1086
40798a41 1087static int s2mu106_vbus_on_check(void *_data)
5073353a
JB		 1088{
1089 struct usbpd_data *data = (struct usbpd_data *) _data;
1090 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1091
cc5ffbfb 1092 return s2mu106_usbpd_check_vbus(pdic_data, 3500, VBUS_ON);
40798a41
JB		 1093}
1094
0ef320fa
JB		 1095static void s2mu106_set_pwr_opmode(void *_data, int mode)
1096{
1097 struct usbpd_data *data = (struct usbpd_data *) _data;
1098 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1099
1100 typec_set_pwr_opmode(pdic_data->port, mode);
1101}
1102
5073353a
JB		 1103#if defined(CONFIG_CHECK_CTYPE_SIDE) || defined(CONFIG_CCIC_SYSFS)
1104static int s2mu106_get_side_check(void *_data)
1105{
1106 struct usbpd_data *data = (struct usbpd_data *) _data;
1107 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1108 struct i2c_client *i2c = pdic_data->i2c;
1109 u8 val, cc1_val, cc2_val;
1110
1111 s2mu106_usbpd_test_read(pdic_data);
1112
1113 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
1114
1115 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
1116 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1117
1118 if (cc1_val == USBPD_Rd)
1119 return USBPD_UP_SIDE;
1120 else if (cc2_val == USBPD_Rd)
1121 return USBPD_DOWN_SIDE;
1122 else
1123 return USBPD_UNDEFFINED_SIDE;
1124}
1125#endif
1126static int s2mu106_set_vconn_source(void *_data, int val)
1127{
1128 struct usbpd_data *data = (struct usbpd_data *) _data;
1129 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1130 struct i2c_client *i2c = pdic_data->i2c;
1131 u8 reg_data = 0, reg_val = 0, cc1_val = 0, cc2_val = 0;
1132
1133 if (!pdic_data->vconn_en) {
1134 pr_err("%s, not support vconn source\n", __func__);
1135 return -1;
1136 }
1137
1138 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &reg_val);
1139 cc1_val = (reg_val & S2MU106_REG_CTRL_MON_CC1_MASK) >> S2MU106_REG_CTRL_MON_CC1_SHIFT;
1140 cc2_val = (reg_val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1141
1142 if (val == USBPD_VCONN_ON) {
1143 if (cc1_val == USBPD_Rd) {
1144 if (cc2_val == USBPD_Ra) {
1145 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1146 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1147 reg_data |= (S2MU106_REG_PLUG_CTRL_RpRd_CC2_VCONN |
1148 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN);
1149 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1150 }
1151 }
1152 if (cc2_val == USBPD_Rd) {
1153 if (cc1_val == USBPD_Ra) {
1154 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1155 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1156 reg_data |= (S2MU106_REG_PLUG_CTRL_RpRd_CC1_VCONN |
1157 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN);
1158 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1159 }
1160 }
1161 } else if (val == USBPD_VCONN_OFF) {
1162 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1163 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1164 reg_data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
1165 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1166 } else
1167 return(-1);
1168
1169 pdic_data->vconn_source = val;
1170 return 0;
1171}
1172
1173static void s2mu106_usbpd_set_vconn_manual(struct s2mu106_usbpd_data *pdic_data, bool enable)
1174{
1175 u8 reg_data = 0;
1176
1177 s2mu106_usbpd_read_reg(pdic_data->i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1178 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1179
1180 if (enable)
1181 reg_data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
1182
1183 s2mu106_usbpd_write_reg(pdic_data->i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1184}
1185
1186static int s2mu106_get_vconn_source(void *_data, int *val)
1187{
1188 struct usbpd_data *data = (struct usbpd_data *) _data;
1189 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1190
1191 /* TODO
1192 set s2mu106 pdic register control */
1193
1194 if (pdic_data->vconn_source != *val) {
1195 dev_info(pdic_data->dev, "%s, vconn_source(%d) != gpio val(%d)\n",
1196 __func__, pdic_data->vconn_source, *val);
1197 pdic_data->vconn_source = *val;
1198 }
1199
1200 return 0;
1201}
1202
1203/* val : sink(0) or source(1) */
1204static int s2mu106_set_power_role(void *_data, int val)
1205{
1206 struct usbpd_data *data = (struct usbpd_data *) _data;
1207 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1208
1209 pr_info("%s, power_role(%d)\n", __func__, val);
1210
1211 if (val == USBPD_SINK) {
1212 pdic_data->is_pr_swap = true;
1213 s2mu106_assert_rd(data);
1214 s2mu106_snk(pdic_data->i2c);
1215 } else if (val == USBPD_SOURCE) {
1216 pdic_data->is_pr_swap = true;
1217 s2mu106_assert_rp(data);
1218 s2mu106_src(pdic_data->i2c);
1219 } else if (val == USBPD_DRP) {
1220 pdic_data->is_pr_swap = false;
1221 s2mu106_assert_drp(data);
1222 return 0;
1223 } else
1224 return(-1);
1225
1226 pdic_data->power_role = val;
1227 return 0;
1228}
1229
1230static int s2mu106_get_power_role(void *_data, int *val)
1231{
1232 struct usbpd_data *data = (struct usbpd_data *) _data;
1233 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1234
1235 *val = pdic_data->power_role;
1236
1237 return 0;
1238}
1239
1240static int s2mu106_set_data_role(void *_data, int val)
1241{
1242 struct usbpd_data *data = (struct usbpd_data *) _data;
1243 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1244 struct i2c_client *i2c = pdic_data->i2c;
1245 u8 val_port, data_role;
1246
1247 /* DATA_ROLE (0x18[2])
1248 * 0 : UFP
1249 * 1 : DFP
1250 */
1251 if (val == USBPD_UFP) {
1252 data_role = S2MU106_REG_MSG_DATA_ROLE_UFP;
1253 s2mu106_ufp(i2c);
1254 } else {/* (val == USBPD_DFP) */
1255 data_role = S2MU106_REG_MSG_DATA_ROLE_DFP;
1256 s2mu106_dfp(i2c);
1257 }
1258
1259 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &val_port);
1260 val_port = (val_port & ~S2MU106_REG_MSG_DATA_ROLE_MASK) | data_role;
1261 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, val_port);
1262
1263 pdic_data->data_role = val;
1264
1265#if defined(CONFIG_IFCONN_NOTIFIER)
1266 process_dr_swap(pdic_data);
1267#endif
1268 return 0;
1269}
1270
1271static int s2mu106_get_data_role(void *_data, int *val)
1272{
1273 struct usbpd_data *data = (struct usbpd_data *) _data;
1274 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1275 *val = pdic_data->data_role;
1276 return 0;
1277}
1278
5073353a
JB		 1279static int s2mu106_set_check_msg_pass(void *_data, int val)
1280{
1281 struct usbpd_data *data = (struct usbpd_data *) _data;
1282 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1283
1284 dev_info(pdic_data->dev, "%s: check_msg_pass val(%d)\n", __func__, val);
1285
1286 pdic_data->check_msg_pass = val;
1287
1288 return 0;
1289}
e29da9fd
JB		 1290
1291static void s2mu106_usbpd_set_threshold(struct s2mu106_usbpd_data *pdic_data,
1292 CCIC_RP_RD_SEL port_sel, CCIC_THRESHOLD_SEL threshold_sel)
1293{
1294 struct i2c_client *i2c = pdic_data->i2c;
1295
1296 if (threshold_sel > S2MU106_THRESHOLD_MAX)
1297 dev_err(pdic_data->dev, "%s : threshold overflow!!\n", __func__);
1298 else {
1299 if (port_sel == PLUG_CTRL_RD)
1300 s2mu106_usbpd_write_reg(i2c,
1301 S2MU106_REG_PLUG_CTRL_SET_RD, threshold_sel);
1302 else if (port_sel == PLUG_CTRL_RP)
1303 s2mu106_usbpd_write_reg(i2c,
1304 S2MU106_REG_PLUG_CTRL_SET_RP, threshold_sel);
1305 }
1306}
1307
5073353a 1308#ifndef CONFIG_SEC_FACTORY
5073353a
JB		 1309static void s2mu106_usbpd_set_rp_scr_sel(struct s2mu106_usbpd_data *pdic_data,
1310 CCIC_RP_SCR_SEL scr_sel)
1311{
1312 struct i2c_client *i2c = pdic_data->i2c;
1313 u8 data = 0;
1314 pr_info("%s: scr_sel : (%d)\n", __func__, scr_sel);
1315 switch (scr_sel) {
8a38de7f
KT		 1316 case PLUG_CTRL_RP0:
1317 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1318 data &= ~S2MU106_REG_PLUG_CTRL_RP_SEL_MASK;
1319 data |= S2MU106_REG_PLUG_CTRL_RP0;
1320 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1321 break;
5073353a
JB		 1322 case PLUG_CTRL_RP80:
1323 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1324 data &= ~S2MU106_REG_PLUG_CTRL_RP_SEL_MASK;
1325 data |= S2MU106_REG_PLUG_CTRL_RP80;
1326 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
5073353a
JB		 1327 break;
1328 case PLUG_CTRL_RP180:
1329 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1330 data &= ~S2MU106_REG_PLUG_CTRL_RP_SEL_MASK;
1331 data |= S2MU106_REG_PLUG_CTRL_RP180;
1332 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
5073353a
JB		 1333 break;
1334 default:
1335 break;
1336 }
1337 return;
1338}
1339#endif
1340
99e9c3ca 1341int s2mu106_usbpd_check_msg(void *_data, u64 *val)
5073353a
JB		 1342{
1343 struct usbpd_data *data = (struct usbpd_data *) _data;
99e9c3ca
JB		 1344 int data_type = 0;
1345 int msg_type = 0;
1346 int vdm_type = 0;
1347 int vdm_command = 0;
5073353a 1348
99e9c3ca 1349 dev_info(data->dev, "%s\n", __func__);
5073353a 1350
99e9c3ca
JB		 1351 if (data->protocol_rx.msg_header.num_data_objs == 0)
1352 data_type = USBPD_CTRL_MSG;
1353 else
1354 data_type = USBPD_DATA_MSG;
40798a41 1355
99e9c3ca
JB		 1356 msg_type = data->protocol_rx.msg_header.msg_type;
1357
1358 if (data_type == USBPD_CTRL_MSG)
5073353a 1359 return 0;
5073353a 1360
99e9c3ca
JB		 1361 if (data_type == USBPD_DATA_MSG) {
1362 switch (msg_type) {
1363 case USBPD_Source_Capabilities:
1364 *val |= MSG_SRC_CAP;
1365 break;
1366 case USBPD_Request:
1367 *val |= MSG_REQUEST;
1368 break;
1369 case USBPD_Sink_Capabilities:
1370 *val |= MSG_SNK_CAP;
1371 break;
1372 case USBPD_BIST:
1373 *val |= MSG_BIST;
1374 break;
1375 case USBPD_Vendor_Defined:
1376 vdm_command = data->protocol_rx.data_obj[0].structured_vdm.command;
1377 vdm_type = data->protocol_rx.data_obj[0].structured_vdm.vdm_type;
5073353a 1378
99e9c3ca
JB		 1379 if (vdm_type == Unstructured_VDM) {
1380 dev_info(data->dev, "%s : uvdm msg received!\n", __func__);
1381 *val |= UVDM_MSG;
1382 break;
1383 }
5073353a 1384
99e9c3ca 1385 switch (vdm_command) {
0ef320fa
JB		 1386 case DisplayPort_Status_Update:
1387 *val |= VDM_DP_STATUS_UPDATE;
1388 break;
1389 case DisplayPort_Configure:
1390 *val |= VDM_DP_CONFIGURE;
1391 break;
1392 case Attention:
1393 *val |= VDM_ATTENTION;
1394 break;
1395 case Exit_Mode:
1396 *val |= VDM_EXIT_MODE;
1397 break;
1398 case Enter_Mode:
1399 *val |= VDM_ENTER_MODE;
1400 break;
1401 case Discover_Modes:
1402 *val |= VDM_ENTER_MODE;
1403 break;
1404 case Discover_SVIDs:
1405 *val |= VDM_DISCOVER_SVID;
1406 break;
1407 case Discover_Identity:
1408 *val |= VDM_DISCOVER_IDENTITY;
1409 break;
1410 default:
1411 break;
99e9c3ca
JB		 1412 }
1413 break;
1414 default:
1415 break;
1416 }
5073353a 1417 }
99e9c3ca
JB		 1418
1419 dev_info(data->dev, "%s: msg status(%lld)\n", __func__, *val);
5073353a
JB		 1420
1421 return 0;
1422}
5073353a
JB		 1423
1424static int s2mu106_usbpd_set_cc_control(struct s2mu106_usbpd_data *pdic_data, int val)
1425{
1426 struct i2c_client *i2c = pdic_data->i2c;
1427 u8 data = 0;
1428
1429 dev_info(pdic_data->dev, "%s, (%d)\n", __func__, val);
5073353a 1430
40798a41
JB		 1431 if (pdic_data->detach_valid) {
1432 dev_info(pdic_data->dev, "%s, ignore cc control\n", __func__);
1433 return 0;
1434 }
5073353a
JB		 1435
1436 if (val) {
1437 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &data);
1438 data &= ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK;
1439 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, data);
40798a41
JB		 1440
1441 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL, &data);
1442 data |= S2MU106_REG_PLUG_CTRL_ECO_SRC_CAP_RDY;
1443 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
5073353a
JB		 1444 } else {
1445 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &data);
1446 data &= ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK;
1447 data |= S2MU106_REG_PLUG_CTRL_CC_MANUAL_EN;
1448 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, data);
40798a41
JB		 1449
1450 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL, &data);
1451 data &= ~S2MU106_REG_PLUG_CTRL_ECO_SRC_CAP_RDY;
1452 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
5073353a 1453 }
5073353a
JB		 1454
1455 return 0;
1456}
1457
1458static void s2mu106_dfp(struct i2c_client *i2c)
1459{
1460 u8 data;
1461
1462 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1463 data |= S2MU106_REG_MSG_DATA_ROLE_MASK;
1464 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1465}
1466
1467static void s2mu106_ufp(struct i2c_client *i2c)
1468{
1469 u8 data;
1470 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1471 data &= ~S2MU106_REG_MSG_DATA_ROLE_MASK;
1472 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1473}
1474
1475static void s2mu106_src(struct i2c_client *i2c)
1476{
1477 u8 data;
1478
1479 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1480 data = (data & ~S2MU106_REG_MSG_POWER_ROLE_MASK) | S2MU106_REG_MSG_POWER_ROLE_SOURCE;
1481 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1482}
1483
1484static void s2mu106_snk(struct i2c_client *i2c)
1485{
1486 u8 data;
1487
1488 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1489 data = (data & ~S2MU106_REG_MSG_POWER_ROLE_MASK) | S2MU106_REG_MSG_POWER_ROLE_SINK;
1490 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1491}
1492
1493#if defined(CONFIG_IFCONN_NOTIFIER)
1494static void s2mu106_notify_pdic_rid(struct s2mu106_usbpd_data *pdic_data, int rid)
1495{
1496 pdic_data->is_factory_mode = false;
1497 if (rid == RID_523K)
1498 pdic_data->is_factory_mode = true;
1499 /* rid */
1500 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
1501 IFCONN_NOTIFY_ID_RID, rid, NULL);
1502
1503 if (rid == REG_RID_523K || rid == REG_RID_619K || rid == REG_RID_OPEN) {
1504 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1505 IFCONN_NOTIFY_EVENT_ATTACH, NULL);
1506 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB,
1507 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
1508 pdic_data->is_host = HOST_OFF;
1509 pdic_data->is_client = CLIENT_OFF;
1510 } else if (rid == REG_RID_301K) {
1511 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1512 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
1513 pdic_data->is_host = HOST_OFF;
1514 pdic_data->is_client = CLIENT_ON;
1515 }
1516
1517 dev_info(pdic_data->dev, "%s : attached rid state(%d)", __func__, rid);
1518}
1519#endif
1520
1521static void s2mu106_usbpd_check_rid(struct s2mu106_usbpd_data *pdic_data)
1522{
1523 struct i2c_client *i2c = pdic_data->i2c;
1524 u8 rid;
1525 int prev_rid = pdic_data->rid;
1526
1527 msleep(200);
1528
1529 if (pdic_data->check_rid_wa)
1530 rid = REG_RID_619K;
1531 else {
1532 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_ADC_STATUS, &rid);
1533 rid = (rid & S2MU106_PDIC_RID_MASK) >> S2MU106_PDIC_RID_SHIFT;
1534 }
1535 dev_info(pdic_data->dev, "%s : attached rid state(%d)", __func__, rid);
1536
1537 if (rid) {
1538 if (pdic_data->rid != rid) {
1539 pdic_data->rid = rid;
1540 if (prev_rid >= REG_RID_OPEN && rid >= REG_RID_OPEN)
1541 dev_err(pdic_data->dev,
1542 "%s : rid is not changed, skip notify(%d)", __func__, rid);
1543 else
1544 s2mu106_notify_pdic_rid(pdic_data, rid);
1545 }
1546
1547 if (rid >= REG_RID_MAX) {
1548 dev_err(pdic_data->dev, "%s : overflow rid value", __func__);
1549 return;
1550 }
1551 }
1552}
1553
5073353a
JB		 1554int s2mu106_set_normal_mode(struct s2mu106_usbpd_data *pdic_data)
1555{
1556 u8 data;
1557 u8 data_lpm;
1558 int ret = 0;
1559 struct i2c_client *i2c = pdic_data->i2c;
1560 struct device *dev = &i2c->dev;
1561
1562 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1563 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
0ef320fa 1564 data |= S2MU106_REG_PLUG_CTRL_DRP | S2MU106_REG_PLUG_CTRL_RP80;
5073353a
JB		 1565
1566 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1567 data_lpm &= ~S2MU106_REG_LPM_EN;
1568
1569 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1570 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1571
1572 pdic_data->lpm_mode = false;
1573
99e9c3ca
JB		 1574 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
1575 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
5073353a
JB		 1576
1577 dev_info(dev, "%s s2mu106 exit lpm mode\n", __func__);
1578
1579 return ret;
1580}
1581
1582int s2mu106_usbpd_lpm_check(struct s2mu106_usbpd_data *pdic_data)
1583{
1584 u8 data_lpm = 0;
1585 struct i2c_client *i2c = pdic_data->i2c;
1586
1587 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1588
1589 return (data_lpm & S2MU106_REG_LPM_EN);
1590}
1591
1592void s2mu106_usbpd_set_mode(struct s2mu106_usbpd_data *pdic_data,
1593 CCIC_LPM_MODE_SEL mode)
1594{
1595 u8 data_lpm = 0;
1596 struct i2c_client *i2c = pdic_data->i2c;
1597
1598 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1599 if (mode == PD_LPM_MODE)
1600 data_lpm |= S2MU106_REG_LPM_EN;
1601 else if (mode == PD_NORMAL_MODE)
1602 data_lpm &= ~S2MU106_REG_LPM_EN;
1603 else {
1604 pr_info("%s mode val(%d) is invalid\n", __func__, mode);
1605 return;
1606 }
1607
1608 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1609}
1610
1611void s2mu106_usbpd_set_vbus_wakeup(struct s2mu106_usbpd_data *pdic_data,
1612 CCIC_VBUS_WAKEUP_SEL sel)
1613{
1614 struct i2c_client *i2c = pdic_data->i2c;
1615 u8 data = 0;
1616
1617 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_TRIM, &data);
1618 if (sel == VBUS_WAKEUP_ENABLE)
1619 data &= ~S2MU106_REG_VBUS_WAKEUP_DIS;
1620 else if (sel == VBUS_WAKEUP_DISABLE)
1621 data |= S2MU106_REG_VBUS_WAKEUP_DIS;
1622 else {
1623 pr_info("%s sel val(%d) is invalid\n", __func__, sel);
1624 return;
1625 }
1626
1627 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_TRIM, data);
1628}
1629
1630int s2mu106_get_plug_monitor(struct s2mu106_usbpd_data *pdic_data, u8 *data)
1631{
1632 u8 reg_val;
1633 int ret = 0;
1634 struct i2c_client *i2c = pdic_data->i2c;
1635
1636 if (&data[0] == NULL || &data[1] == NULL) {
1637 pr_err("%s NULL point data\n", __func__);
1638 return -1;
1639 }
1640
1641 ret = s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &reg_val);
1642 if (ret < 0) {
1643 pr_err("%s: S2MU106_REG_PLUG_MON1 Read err : %d\n", __func__, ret);
1644 return ret;
1645 }
1646
1647 data[0] = reg_val & S2MU106_REG_CTRL_MON_CC1_MASK;
1648 data[1] = (reg_val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1649 pr_info("%s, water cc mon cc1 : 0x%X, cc2 : 0x%X\n", __func__, data[0], data[1]);
1650
1651 return ret;
1652}
1653
1654int s2mu106_set_lpm_mode(struct s2mu106_usbpd_data *pdic_data)
1655{
1656 u8 data, data_lpm;
1657 int ret = 0;
1658 struct i2c_client *i2c = pdic_data->i2c;
1659 struct device *dev = &i2c->dev;
1660 u8 intr[S2MU106_MAX_NUM_INT_STATUS] = {0};
1661
1662 pdic_data->lpm_mode = true;
1663
1664 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1665 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1666 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP0;
1667 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1668 data_lpm |= S2MU106_REG_LPM_EN;
1669
1670 s2mu106_set_irq_enable(pdic_data, 0, 0, 0, 0, 0, 0);
1671
1672 ret = s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
1673 S2MU106_MAX_NUM_INT_STATUS, intr);
1674
1675 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1676 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1677
1678 if (pdic_data->detach_valid == false) {
1679 s2mu106_usbpd_detach_init(pdic_data);
1680 s2mu106_usbpd_notify_detach(pdic_data);
1681 }
1682
1683 dev_info(dev, "%s s2mu106 enter lpm mode\n", __func__);
1684
1685 return ret;
1686}
1687
1688void s2mu106_set_water_detect_pre_cond(struct s2mu106_usbpd_data *pdic_data)
1689{
1690 int i;
1691 u8 cc_val[2] = {0,};
1692
1693 s2mu106_set_normal_mode(pdic_data);
1694 mdelay(10);
1695
1696 for (i = 0; i < 14; i++) {
1697 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1698 pr_info("%s abnormal", __func__);
1699 mdelay(10);
1700 } else {
1701 if (IS_CC_RP(cc_val[0], cc_val[1]))
1702 break;
1703 else {
1704 pr_info("%s Not Rp yet. ", __func__);
1705 mdelay(10);
1706 }
1707 }
1708 }
1709}
1710
1711void s2mu106_set_water_1st_detect(struct s2mu106_usbpd_data *pdic_data)
1712{
1713 u8 data, data_lpm;
1714 struct i2c_client *i2c = pdic_data->i2c;
1715 struct device *dev = &i2c->dev;
1716
1717 pdic_data->lpm_mode = true;
1718 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP, S2MU106_THRESHOLD_MAX);
1719
1720 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1721 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1722 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP80
1723 | S2MU106_REG_PLUG_CTRL_DETECT_BAT_DISABLE_MASK
1724 | S2MU106_REG_PLUG_CTRL_DETECT_OCP_DISABLE_MASK;
1725 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1726 data_lpm |= S2MU106_REG_LPM_EN;
1727
1728 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1729 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1730
1731 s2mu106_set_irq_enable(pdic_data, 0, 0, 0, 0, 0, 0);
1732
1733 usleep_range(500, 900);
1734
1735 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1736 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP0;
1737 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1738
1739 dev_info(dev, "%s s2mu106 enter water chk lpm mode\n", __func__);
1740}
1741
1742static bool s2mu106_is_water_detected_2nd_seq(struct s2mu106_usbpd_data *pdic_data, u8 *cc_val)
1743{
1744 struct i2c_client *i2c = pdic_data->i2c;
1745 u8 cc_chk[2] = {0,};
1746
1747 if (cc_val[0] == USBPD_Rp)
1748 cc_chk[0] = 1;
1749 if (cc_val[1] == USBPD_Rp)
1750 cc_chk[1] = 1;
1751
1752 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1753 S2MU106_THRESHOLD_214MV);
1754 s2mu106_set_lpm_mode(pdic_data);
1755 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1756 S2MU106_REG_LPM_EN, 0, 0);
1757 msleep(300);
1758
1759 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1760 pr_err("%s Failed to get the plug monitor.\n", __func__);
1761 return false;
1762 }
1763
1764 /* Rd is detected due to the water CAPACITOR. */
1765 if (((cc_chk[0] && !cc_chk[1]) && (cc_val[0] == USBPD_Rd)) ||
1766 ((cc_chk[1] && !cc_chk[0]) && (cc_val[1] == USBPD_Rd)) ||
1767 ((cc_chk[0] && cc_chk[1]) && ((cc_val[0] == USBPD_Rd) && (cc_val[1] == USBPD_Rd)))) {
1768 return true;
1769 }
1770
1771 return false;
1772}
1773
1774static void _S2MU106_PDIC_enter_to_water(struct s2mu106_usbpd_data *pdic_data)
1775{
1776 struct i2c_client *i2c = pdic_data->i2c;
1777#if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
1778 struct otg_notify *o_notify = get_otg_notify();
1779#endif
1780
1781#if defined(CONFIG_CCIC_NOTIFIER)
1782 ccic_event_work(pdic_data,
1783 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_ATTACH, 0);
1784#endif
1785 pdic_data->is_water_detect = true;
1786 pdic_data->water_detect_cnt = 0;
1787 s2mu106_set_lpm_mode(pdic_data);
1788 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1789 S2MU106_REG_LPM_EN, 0, 0);
1790#if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
1791 if (o_notify)
1792 inc_hw_param(o_notify, USB_CCIC_WATER_INT_COUNT);
1793#endif
1794}
1795
1796static void S2MU106_PDIC_water_detect_handler(struct work_struct *work)
1797{
1798 struct s2mu106_usbpd_data *pdic_data =
1799 container_of(work, struct s2mu106_usbpd_data, water_detect_handler.work);
1800 struct i2c_client *i2c = pdic_data->i2c;
1801
1802 u8 cc_val[2] = {0,};
1803
1804 pr_info("%s enter", __func__);
1805 mutex_lock(&pdic_data->_mutex);
1806
1807 /*
1808 * Cancel the detect handler,
1809 * in case the muic notifies cable attach or dry signal,
1810 * or the water chk cnt is over,
1811 * or ccic already detected the water.
1812 */
1813 if (!pdic_data->is_muic_water_detect
1814 || pdic_data->water_detect_cnt > WATER_CHK_RETRY_CNT
1815 || pdic_data->is_water_detect) {
1816 pr_info("%s: detect handler is canceled", __func__);
1817 goto WATER_OUT;
1818 }
1819
1820 s2mu106_set_water_detect_pre_cond(pdic_data);
1821 s2mu106_set_water_1st_detect(pdic_data);
1822 msleep(400);
1823
1824 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1825 pr_err("%s Failed to get the plug monitor.\n", __func__);
1826 goto WATER_MODE_OUT;
1827 }
1828
1829 if (IS_CC_WATER(cc_val[0], cc_val[1])) {
1830 pr_info("%s, water is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1831 __func__, cc_val[0], cc_val[1]);
1832 _S2MU106_PDIC_enter_to_water(pdic_data);
1833 goto WATER_MODE_OUT;
1834 } else {
1835 pr_info("%s, 1st chk is not water, cc1 : 0x%X, cc2 : 0x%X\n",
1836 __func__, cc_val[0], cc_val[1]);
1837 if (s2mu106_is_water_detected_2nd_seq(pdic_data, cc_val)) {
1838 pr_info("%s, 2nd seq, water is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1839 __func__, cc_val[0], cc_val[1]);
1840 _S2MU106_PDIC_enter_to_water(pdic_data);
1841 goto WATER_MODE_OUT;
1842 }
1843
1844 pr_info("%s, 2nd chk : not water, cc1 : 0x%X, cc2 : 0x%X\n",
1845 __func__, cc_val[0], cc_val[1]);
1846
1847 if (pdic_data->water_detect_cnt++ >= WATER_CHK_RETRY_CNT) {
1848 pdic_data->is_water_detect = false;
1849 pdic_data->water_detect_cnt = 0;
1850#if defined(CONFIG_CCIC_NOTIFIER)
1851 ccic_event_work(pdic_data,
1852 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
1853#endif
1854 } else {
1855 /*
1856 * Retry the cc check,
1857 * in case of invalid status.
1858 * (200ms interval + 175ms check duration) * 5 times
1859 */
1860 cancel_delayed_work(&pdic_data->water_detect_handler);
1861 schedule_delayed_work(&pdic_data->water_detect_handler,
1862 msecs_to_jiffies(S2MU106_WATER_CHK_INTERVAL_TIME));
1863 }
1864 }
1865WATER_MODE_OUT:
1866 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1867 S2MU106_THRESHOLD_428MV);
1868 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP,
1869 S2MU106_THRESHOLD_2057MV);
1870WATER_OUT:
1871 mutex_unlock(&pdic_data->_mutex);
1872 return;
1873}
1874
1875static void S2MU106_PDIC_water_dry_handler(struct work_struct *work)
1876{
1877 struct s2mu106_usbpd_data *pdic_data =
1878 container_of(work, struct s2mu106_usbpd_data, water_dry_handler.work);
1879 struct i2c_client *i2c = pdic_data->i2c;
1880 u8 cc_val[2] = {0,};
1881
1882 pr_info("%s enter", __func__);
1883 mutex_lock(&pdic_data->_mutex);
1884
1885 s2mu106_set_water_detect_pre_cond(pdic_data);
1886 s2mu106_set_water_1st_detect(pdic_data);
1887 msleep(400);
1888
1889 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1890 pr_err("%s Failed to get the plug monitor.\n", __func__);
1891 }
1892
1893 if (IS_CC_RP(cc_val[0], cc_val[1])) {
1894 pr_info("%s, 1st, water DRY is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1895 __func__, cc_val[0], cc_val[1]);
1896
1897 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1898 S2MU106_THRESHOLD_428MV);
1899 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP,
1900 S2MU106_THRESHOLD_2057MV);
1901#if defined(CONFIG_CCIC_NOTIFIER)
1902 ccic_event_work(pdic_data,
1903 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
1904#endif
1905 } else {
1906 pr_info("%s, It is not DRIED yet, cc1 : 0x%X, cc2 : 0x%X\n",
1907 __func__, cc_val[0], cc_val[1]);
1908
1909#if defined(CONFIG_CCIC_NOTIFIER)
1910 ccic_event_work(pdic_data,
1911 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_ATTACH, 0);
1912#endif
1913 s2mu106_set_lpm_mode(pdic_data);
1914 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1915 S2MU106_REG_LPM_EN, 0, 0);
1916 }
1917
1918 mutex_unlock(&pdic_data->_mutex);
1919 return;
1920}
1921
1922static void s2mu106_usbpd_otg_attach(struct s2mu106_usbpd_data *pdic_data)
1923{
1924 struct i2c_client *i2c = pdic_data->i2c;
1925 struct device *dev = &i2c->dev;
40798a41 1926
5073353a
JB		 1927 /* otg */
1928 pdic_data->is_host = HOST_ON;
1929#if defined(CONFIG_DUAL_ROLE_USB_INTF)
1930 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SRC;
8a38de7f
KT		 1931#elif defined(CONFIG_TYPEC)
1932 pdic_data->typec_power_role = TYPEC_SOURCE;
1933 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
5073353a
JB		 1934#endif
1935#if defined(CONFIG_IFCONN_NOTIFIER)
1936 /* USB */
1937 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1938 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP, NULL);
40798a41
JB		 1939#endif
1940#ifdef CONFIG_PM_S2MU106
1941 s2mu106_usbpd_check_vbus(pdic_data, 80, VBUS_OFF);
5073353a
JB		 1942#endif
1943 /* add to turn on external 5V */
1944 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
1945
1946 usbpd_manager_acc_handler_cancel(dev);
1947}
1948
1949#if defined(CONFIG_MUIC_NOTIFIER)
1950static int type3_handle_notification(struct notifier_block *nb,
1951 unsigned long action, void *data)
1952{
1953#if defined(CONFIG_CCIC_NOTIFIER)
1954 CC_NOTI_ATTACH_TYPEDEF *p_noti = (CC_NOTI_ATTACH_TYPEDEF *)data;
1955 muic_attached_dev_t attached_dev = p_noti->cable_type;
1956#else
1957 muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data;
1958#endif
1959 struct s2mu106_usbpd_data *pdic_data =
1960 container_of(nb, struct s2mu106_usbpd_data,
1961 type3_nb);
1962 struct i2c_client *i2c = pdic_data->i2c;
1963 u8 reg_data = 0;
1964
1965#if (defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)) || \
1966 (!defined(CONFIG_SEC_FACTORY) && defined(CONFIG_USB_HOST_NOTIFY))
1967 struct otg_notify *o_notify = get_otg_notify();
1968#endif
1969 mutex_lock(&pdic_data->lpm_mutex);
1970 pr_info("%s action:%d, attached_dev:%d, lpm:%d, pdic_data->is_otg_vboost:%d, pdic_data->is_otg_reboost:%d\n",
1971 __func__, (int)action, (int)attached_dev, pdic_data->lpm_mode,
1972 (int)pdic_data->is_otg_vboost, (int)pdic_data->is_otg_reboost);
1973
1974 if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1975 (attached_dev == ATTACHED_DEV_TYPE3_MUIC)) {
1976 pdic_data->is_muic_water_detect = false;
1977 pdic_data->water_detect_cnt = 0;
1978 if (pdic_data->lpm_mode) {
1979 pr_info("%s try to exit lpm mode-->\n", __func__);
1980 s2mu106_set_normal_mode(pdic_data);
1981 pr_info("%s after exit lpm mode<--\n", __func__);
1982 }
1983 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1984 attached_dev == ATTACHED_DEV_CHK_WATER_REQ) {
1985 pr_info("%s, ATTACH : MUIC REQUESTED WATER CHECK\n", __func__);
1986 s2mu106_usbpd_set_vconn_manual(pdic_data, true);
1987 pdic_data->is_muic_water_detect = true;
1988 pdic_data->water_detect_cnt = 0;
1989 pdic_data->is_water_detect = false;
1990 cancel_delayed_work(&pdic_data->water_detect_handler);
1991 schedule_delayed_work(&pdic_data->water_detect_handler, msecs_to_jiffies(100));
1992 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1993 attached_dev == ATTACHED_DEV_CHK_WATER_DRY_REQ) {
1994 pr_info("%s, ATTACH : MUIC REQUESTED WATER DRY CHECK\n", __func__);
1995 cancel_delayed_work(&pdic_data->water_dry_handler);
1996 schedule_delayed_work(&pdic_data->water_dry_handler, msecs_to_jiffies(100));
1997 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1998 attached_dev == ATTACHED_DEV_OTG_MUIC) {
1999 s2mu106_usbpd_otg_attach(pdic_data);
2000 } else if ((action == MUIC_PDIC_NOTIFY_CMD_DETACH) &&
2001 attached_dev == ATTACHED_DEV_UNDEFINED_RANGE_MUIC) {
2002 pr_info("%s, DETACH : ATTACHED_DEV_UNDEFINED_RANGE_MUIC(Water DRY)\n", __func__);
2003 pdic_data->is_muic_water_detect = false;
2004 pdic_data->water_detect_cnt = 0;
2005 pdic_data->is_water_detect = false;
2006 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &reg_data);
2007 reg_data |= S2MU106_REG_LPM_EN;
2008 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, reg_data);
2009#if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
2010 if (o_notify)
2011 inc_hw_param(o_notify, USB_CCIC_DRY_INT_COUNT);
2012#endif
2013#if defined(CONFIG_CCIC_NOTIFIER)
2014 ccic_event_work(pdic_data,
2015 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
2016#endif
2017 } else if (action == MUIC_PDIC_NOTIFY_CMD_DETACH) {
2018 if (!pdic_data->lpm_mode) {
2019 pr_info("%s try to enter lpm mode-->\n", __func__);
2020 s2mu106_set_lpm_mode(pdic_data);
2021 pr_info("%s after enter lpm mode<--\n", __func__);
2022 }
2023 }
2024#if !defined(CONFIG_SEC_FACTORY) && defined(CONFIG_USB_HOST_NOTIFY)
2025 else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH)
2026 && (attached_dev == ATTACHED_DEV_CHECK_OCP)
2027 && pdic_data->is_otg_vboost
2028 && pdic_data->data_role_dual ==
2029 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP) {
2030 if (o_notify) {
2031 if (is_blocked(o_notify, NOTIFY_BLOCK_TYPE_HOST)) {
2032 pr_info("%s, upsm mode, skip OCP handling\n", __func__);
2033 goto EOH;
2034 }
2035 }
2036 if (pdic_data->is_otg_reboost) {
2037 /* todo : over current event to platform */
2038 pr_info("%s, CHECK_OCP, Can't afford it(OVERCURRENT)\n", __func__);
2039 if (o_notify)
2040 send_otg_notify(o_notify, NOTIFY_EVENT_OVERCURRENT, 0);
2041 goto EOH;
2042 }
2043 ccic_event_work(pdic_data,
2044 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_ATTACH, 1/*attach*/, 1/*rprd*/);
2045
2046 pr_info("%s, CHECK_OCP, start OCP W/A\n", __func__);
2047 pdic_data->is_otg_reboost = true;
2048 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &reg_data);
2049 reg_data |= S2MU106_REG_PLUG_CTRL_CC_HOLD_BIT;
2050 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, reg_data);
2051
2052 s2mu106_usbpd_set_rp_scr_sel(pdic_data, PLUG_CTRL_RP80);
2053 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2054 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
2055
2056 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &reg_data);
2057 reg_data &= ~S2MU106_REG_PLUG_CTRL_CC_HOLD_BIT;
2058 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, reg_data);
2059 }
2060EOH:
2061#endif
2062 mutex_unlock(&pdic_data->lpm_mutex);
2063
2064 return 0;
2065}
2066#endif
2067
5073353a 2068static void s2mu106_usbpd_prevent_watchdog_reset(
40798a41 2069 struct s2mu106_usbpd_data *pdic_data)
5073353a
JB		 2070{
2071 struct i2c_client *i2c = pdic_data->i2c;
2072 u8 val = 0;
2073
2074 mutex_lock(&pdic_data->lpm_mutex);
2075 wake_lock(&pdic_data->wake_lock);
2076 if (!pdic_data->lpm_mode) {
2077 if (s2mu106_usbpd_lpm_check(pdic_data) == 0) {
2078 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2079 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2080 pr_info("%s force to lpm mode\n", __func__);
2081 s2mu106_usbpd_set_mode(pdic_data, PD_LPM_MODE);
2082 /* enable wakeup to check prevent function */
2083 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2084 ENABLED_INT_2_WAKEUP, ENABLED_INT_3, ENABLED_INT_4,
2085 ENABLED_INT_5);
2086 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
40798a41 2087 usleep_range(1000, 1200);
5073353a
JB		 2088 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2089 if (val & S2MU106_REG_INT_STATUS2_WAKEUP)
2090 pr_info("%s auto wakeup success\n", __func__);
8a38de7f
KT		 2091 else {
2092 msleep(22);
2093 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2094 usleep_range(1000, 1200);
2095 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
2096 usleep_range(1000, 1200);
2097 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2098 if (val & S2MU106_REG_INT_STATUS2_WAKEUP)
2099 pr_info("%s auto wakeup success\n", __func__);
0ef320fa
JB		 2100 else
2101 s2mu106_usbpd_set_mode(pdic_data, PD_NORMAL_MODE);
8a38de7f
KT		 2102 }
2103
40798a41
JB		 2104 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2105 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4,
5073353a
JB		 2106 ENABLED_INT_5);
2107 }
2108 }
2109 wake_unlock(&pdic_data->wake_lock);
2110 mutex_unlock(&pdic_data->lpm_mutex);
2111}
2112
e29da9fd
JB		 2113static int s2mu106_usbpd_check_abnormal_attach(struct s2mu106_usbpd_data *pdic_data)
2114{
2115 struct i2c_client *i2c = pdic_data->i2c;
2116 u8 data = 0;
2117
68da0823
J		 2118 pr_info("%s, try val=1100mV\n", __func__);
2119
2120 s2mu106_usbpd_set_threshold(pdic_data, PLUG_CTRL_RP, 30);
2121 msleep(80);
e29da9fd
JB		 2122
2123 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2124 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE)
2125 return true;
2126 else
2127 return false;
2128}
2129
86753b80
JB		 2130static void s2mu106_usbpd_rp_current_check(struct s2mu106_usbpd_data *pdic_data)
2131{
2132 struct i2c_client *i2c = pdic_data->i2c;
2133 struct device *dev = pdic_data->dev;
2134 u8 val = 0;
2135 u8 cc1_val = 0, cc2_val = 0;
2136 u8 rp_currentlvl = 0;
2137
2138 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_FSM_MON, &val);
2139
2140 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
2141 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
2142
2143 dev_info(dev, "%s, rp check : cc1_val(%x), cc2_val(%x)\n",
2144 __func__, cc1_val, cc2_val);
2145
2146 if (cc1_val == USBPD_10k || cc2_val == USBPD_10k)
2147 rp_currentlvl = RP_CURRENT_LEVEL3;
2148 else if (cc1_val == USBPD_22k || cc2_val == USBPD_22k)
2149 rp_currentlvl = RP_CURRENT_LEVEL2;
2150 else if (cc1_val == USBPD_56k || cc2_val == USBPD_56k)
2151 rp_currentlvl = RP_CURRENT_LEVEL_DEFAULT;
2152
2153 pd_noti.sink_status.rp_currentlvl = rp_currentlvl;
2154 pd_noti.event = IFCONN_NOTIFY_EVENT_RP_ATTACH;
2155 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MANAGER,
2156 IFCONN_NOTIFY_ID_POWER_STATUS, IFCONN_NOTIFY_EVENT_ATTACH, &pd_noti);
2157}
2158
5073353a
JB		 2159static void s2mu106_usbpd_detach_init(struct s2mu106_usbpd_data *pdic_data)
2160{
2161 struct device *dev = pdic_data->dev;
2162 struct usbpd_data *pd_data = dev_get_drvdata(dev);
5073353a
JB		 2163 int ret = 0;
2164
2165 dev_info(dev, "%s\n", __func__);
2166
40798a41 2167 mutex_lock(&pdic_data->cc_mutex);
5073353a 2168 s2mu106_usbpd_set_cc_control(pdic_data, USBPD_CC_OFF);
40798a41
JB		 2169#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2170 if (pdic_data->power_role_dual == DUAL_ROLE_PROP_PR_SRC) {
2171 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2172 }
8a38de7f
KT		 2173#elif defined(CONFIG_TYPEC)
2174 if (pdic_data->typec_power_role == TYPEC_SOURCE) {
2175 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2176 }
0ef320fa 2177 pd_data->pd_support = 0;
40798a41
JB		 2178#endif
2179 pdic_data->detach_valid = true;
2180 mutex_unlock(&pdic_data->cc_mutex);
5073353a 2181 usbpd_manager_plug_detach(dev, 0);
40798a41
JB		 2182
2183 /* wait flushing policy engine work */
2184 usbpd_cancel_policy_work(dev);
f0beeda5 2185 s2mu106_self_soft_reset(pdic_data->i2c);
40798a41 2186
5073353a
JB		 2187 pdic_data->status_reg = 0;
2188 usbpd_reinit(dev);
5073353a
JB		 2189 pdic_data->rid = REG_RID_MAX;
2190 pdic_data->check_rid_wa = false;
5073353a
JB		 2191 pdic_data->is_factory_mode = false;
2192 pdic_data->is_pr_swap = false;
5073353a
JB		 2193 if (pdic_data->regulator_en)
2194 ret = regulator_disable(pdic_data->regulator);
2195#ifdef CONFIG_BATTERY_SAMSUNG
2196#ifdef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
2197 pd_noti.sink_status.current_pdo_num = 0;
2198 pd_noti.sink_status.selected_pdo_num = 0;
2199 pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_NONE;
2200#endif
2201#endif
2202 s2mu106_usbpd_reg_init(pdic_data);
2203 s2mu106_set_vconn_source(pd_data, USBPD_VCONN_OFF);
2204}
2205
2206static void s2mu106_usbpd_notify_detach(struct s2mu106_usbpd_data *pdic_data)
2207{
2208 struct device *dev = pdic_data->dev;
5073353a 2209#if defined(CONFIG_IFCONN_NOTIFIER)
c4d58085 2210 /* MUIC */
2211 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC, IFCONN_NOTIFY_ID_ATTACH,
2212 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2213
2214 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC, IFCONN_NOTIFY_ID_RID,
2215 IFCONN_NOTIFY_EVENT_DETACH, NULL);
5073353a
JB		 2216
2217 if (pdic_data->is_host > HOST_OFF || pdic_data->is_client > CLIENT_OFF) {
2218#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2219 if (pdic_data->is_host > HOST_OFF ||
2220 pdic_data->power_role_dual == DUAL_ROLE_PROP_PR_SRC) {
2221#else
2222 if (pdic_data->is_host > HOST_OFF) {
2223#endif
2224 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2225 }
2226 usbpd_manager_acc_detach(dev);
5073353a
JB		 2227 /* usb or otg */
2228 dev_info(dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2229 __LINE__, pdic_data->is_host, pdic_data->is_client);
2230 pdic_data->is_host = HOST_OFF;
2231 pdic_data->is_client = CLIENT_OFF;
2232#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2233 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
8a38de7f 2234#elif defined(CONFIG_TYPEC)
0ef320fa
JB		 2235 if (pdic_data->partner) {
2236 pr_info("%s, %d\n", __func__, __LINE__);
2237 if (!IS_ERR(pdic_data->partner)) {
2238 typec_unregister_partner(pdic_data->partner);
2239 pdic_data->partner = NULL;
2240 }
2241 }
8a38de7f 2242 pdic_data->typec_power_role = TYPEC_SINK;
8a38de7f 2243 pdic_data->typec_data_role = TYPEC_DEVICE;
8f7769bf 2244#endif
c4d58085 2245 /* USB */
2246 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2247 IFCONN_NOTIFY_EVENT_DETACH, NULL);
5073353a
JB		 2248 }
2249#else
2250 usbpd_manager_plug_detach(dev, 1);
2251#endif
2252}
2253#ifdef CONFIG_CCIC_TRY_SNK
2254static void s2mu106_usbpd_try_snk(struct s2mu106_usbpd_data *pdic_data)
2255{
2256 struct device *dev = pdic_data->dev;
2257 struct i2c_client *i2c = pdic_data->i2c;
2258 u8 data;
2259 u8 intr[S2MU106_MAX_NUM_INT_STATUS] = {0};
2260
2261 dev_info(dev, "%s\n", __func__);
2262
2263 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
40798a41 2264 data &= ~S2MU106_REG_PLUG_CTRL_MODE_MASK;
5073353a
JB		 2265 data |= S2MU106_REG_PLUG_CTRL_UFP;
2266 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2267
2268 msleep(250);
2269
2270 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2271 if ((data & S2MU106_PR_MASK) != S2MU106_PDIC_SINK) {
2272 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
40798a41 2273 data &= ~S2MU106_REG_PLUG_CTRL_MODE_MASK;
5073353a
JB		 2274 data |= S2MU106_REG_PLUG_CTRL_DFP;
2275 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2276
2277 msleep(200);
2278 }
2279
2280 s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
2281 S2MU106_MAX_NUM_INT_STATUS, intr);
2282}
2283#endif
2284static void s2mu106_usbpd_check_host(struct s2mu106_usbpd_data *pdic_data,
2285 CCIC_HOST_REASON host)
2286{
5073353a 2287 if (host == HOST_ON && pdic_data->is_host == HOST_ON) {
5073353a
JB		 2288 dev_info(pdic_data->dev, "%s %d: turn off host\n", __func__, __LINE__);
2289 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2290 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2291#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2292 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
8a38de7f
KT		 2293#elif defined(CONFIG_TYPEC)
2294 pdic_data->typec_power_role = TYPEC_SINK;
2295 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
5073353a
JB		 2296#endif
2297 /* add to turn off external 5V */
2298 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2299 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2300 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2301 pdic_data->is_host = HOST_OFF;
2302 msleep(300);
2303 } else if (host == HOST_OFF && pdic_data->is_host == HOST_OFF) {
2304 /* muic */
2305 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2306 IFCONN_NOTIFY_ID_OTG, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
2307 s2mu106_usbpd_otg_attach(pdic_data);
2308 }
2309}
2310
2311static void s2mu106_usbpd_check_client(struct s2mu106_usbpd_data *pdic_data,
2312 CCIC_DEVICE_REASON client)
2313{
2314 if (client == CLIENT_ON && pdic_data->is_client == CLIENT_ON) {
2315 dev_info(pdic_data->dev, "%s %d: turn off client\n", __func__, __LINE__);
2316 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2317 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2318#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2319 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
8a38de7f
KT		 2320#elif defined(CONFIG_TYPEC)
2321 pdic_data->typec_power_role = TYPEC_SINK;
2322 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
5073353a
JB		 2323#endif
2324 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB,
2325 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2326 pdic_data->is_client = CLIENT_OFF;
2327 }
2328}
2329
2330static int s2mu106_check_port_detect(struct s2mu106_usbpd_data *pdic_data)
2331{
2332 struct i2c_client *i2c = pdic_data->i2c;
2333 struct device *dev = &i2c->dev;
2334 struct usbpd_data *pd_data = dev_get_drvdata(dev);
2335 u8 data, val;
2336 u8 cc1_val = 0, cc2_val = 0;
2337 int ret = 0;
2338
2339 ret = s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2340 if (ret < 0)
2341 dev_err(dev, "%s, i2c read PLUG_MON2 error\n", __func__);
2342
2343 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
2344
2345 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
2346 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
2347
0ef320fa
JB		 2348 pdic_data->cc1_val = cc1_val;
2349 pdic_data->cc2_val = cc2_val;
2350
5073353a
JB		 2351 dev_info(dev, "%s, attach cc pin check cc1_val(%x), cc2_val(%x)\n",
2352 __func__, cc1_val, cc2_val);
2353
2354#ifdef CONFIG_CCIC_DP
2355 if (cc1_val == USBPD_Rd)
2356 gpio_direction_output(pdic_data->usb_sw_sel, 1);
2357 else if (cc2_val == USBPD_Rd)
2358 gpio_direction_output(pdic_data->usb_sw_sel, 0);
2359#endif
2360#ifdef CONFIG_CCIC_TRY_SNK
2361 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE) {
2362#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2363 if (!pdic_data->try_state_change) {
2364 s2mu106_usbpd_try_snk(pdic_data);
2365 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2366 }
2367#else
2368 s2mu106_usbpd_try_snk(pdic_data);
2369 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2370#endif
2371 }
2372#endif
2373 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SINK) {
2374 dev_info(dev, "SINK\n");
40798a41 2375 pdic_data->detach_valid = false;
5073353a
JB		 2376 pdic_data->power_role = PDIC_SINK;
2377 pdic_data->data_role = USBPD_UFP;
2378 s2mu106_snk(i2c);
2379 s2mu106_ufp(i2c);
2380 s2mu106_usbpd_prevent_watchdog_reset(pdic_data);
2381 usbpd_policy_reset(pd_data, PLUG_EVENT);
2382#if defined(CONFIG_IFCONN_NOTIFIER)
2383 dev_info(&i2c->dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2384 __LINE__, pdic_data->is_host, pdic_data->is_client);
2385 if (pdic_data->regulator_en) {
2386 ret = regulator_enable(pdic_data->regulator);
2387 if (ret)
2388 dev_err(&i2c->dev, "Failed to enable vconn LDO: %d\n", ret);
2389 }
2390
2391 s2mu106_usbpd_check_host(pdic_data, HOST_ON);
2392 /* muic */
2393 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2394 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
9a7aa468
KT		 2395 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2396 IFCONN_NOTIFY_ID_TA, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
5073353a
JB		 2397 if (!(pdic_data->rid == REG_RID_523K || pdic_data->rid == REG_RID_619K)) {
2398 if (pdic_data->is_client == CLIENT_OFF && pdic_data->is_host == HOST_OFF) {
2399 /* usb */
2400 pdic_data->is_client = CLIENT_ON;
2401#if defined(CONFIG_DUAL_ROLE_USB_INTF)
2402 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SNK;
8a38de7f
KT		 2403#elif defined(CONFIG_TYPEC)
2404 pdic_data->typec_power_role = TYPEC_SINK;
2405 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
5073353a
JB		 2406#endif
2407 ifconn_event_work(pdic_data,
2408 IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2409 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
2410 }
2411 }
2412#endif
86753b80 2413 s2mu106_usbpd_rp_current_check(pdic_data);
5073353a
JB		 2414 } else if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE) {
2415 dev_info(dev, "SOURCE\n");
e29da9fd
JB		 2416 ret = s2mu106_usbpd_check_abnormal_attach(pdic_data);
2417 if (ret == false) {
2418 dev_err(&i2c->dev, "%s, abnormal attach\n", __func__);
2419 return -1;
2420 }
68da0823 2421 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP, S2MU106_THRESHOLD_2057MV);
40798a41
JB		 2422 ret = s2mu106_usbpd_check_accessory(pdic_data);
2423 if (ret < 0) {
2424 dev_info(&i2c->dev, "%s attach accessory\n", __func__);
2425 return -1;
2426 }
2427 pdic_data->detach_valid = false;
5073353a
JB		 2428 pdic_data->power_role = PDIC_SOURCE;
2429 pdic_data->data_role = USBPD_DFP;
2430 s2mu106_dfp(i2c);
2431 s2mu106_src(i2c);
2432 usbpd_policy_reset(pd_data, PLUG_EVENT);
2433#if defined(CONFIG_IFCONN_NOTIFIER)
2434 dev_info(&i2c->dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2435 __LINE__, pdic_data->is_host, pdic_data->is_client);
2436 s2mu106_usbpd_check_client(pdic_data, CLIENT_ON);
2437 s2mu106_usbpd_check_host(pdic_data, HOST_OFF);
2438#endif
2439 if (pdic_data->regulator_en) {
2440 ret = regulator_enable(pdic_data->regulator);
2441 if (ret)
2442 dev_err(&i2c->dev, "Failed to enable vconn LDO: %d\n", ret);
2443 }
2444
40798a41 2445 msleep(100);
5073353a
JB		 2446 } else {
2447 dev_err(dev, "%s, PLUG Error\n", __func__);
2448#ifdef CONFIG_CCIC_TRY_SNK
2449 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
2450 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
0ef320fa 2451 data |= S2MU106_REG_PLUG_CTRL_DRP | S2MU106_REG_PLUG_CTRL_RP80;
5073353a
JB		 2452 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2453#endif
2454 return -1;
2455 }
2456
5073353a
JB		 2457 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2458 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
2459
2460 return ret;
2461}
2462
2463#if defined(CONFIG_SEC_FACTORY)
2464static int s2mu106_usbpd_check_619k(struct s2mu106_usbpd_data *pdic_data)
2465{
2466 u8 rid = 0;
2467
2468 if (pdic_data->rid != REG_RID_619K)
2469 return false;
2470
2471 msleep(250);
2472 s2mu106_usbpd_read_reg(pdic_data->i2c, S2MU106_REG_ADC_STATUS, &rid);
2473 rid = (rid & S2MU106_PDIC_RID_MASK) >> S2MU106_PDIC_RID_SHIFT;
2474 dev_info(pdic_data->dev, "%s %d: Detached, check if still 619K? => 0x%X\n",
2475 __func__, __LINE__, rid);
2476
2477 if (rid == REG_RID_619K)
2478 return true;
2479 return false;
2480}
2481#endif
2482
5073353a
JB		 2483static irqreturn_t s2mu106_irq_thread(int irq, void *data)
2484{
2485 struct s2mu106_usbpd_data *pdic_data = data;
2486 struct i2c_client *i2c = pdic_data->i2c;
2487 struct device *dev = &i2c->dev;
2488 struct usbpd_data *pd_data = dev_get_drvdata(dev);
2489 int ret = 0;
2490 unsigned attach_status = 0, rid_status = 0;
2491
2492 dev_info(dev, "%s\n", __func__);
2493
99e9c3ca
JB		 2494 mutex_lock(&pd_data->accept_mutex);
2495 mutex_unlock(&pd_data->accept_mutex);
2496
5073353a
JB		 2497 mutex_lock(&pdic_data->_mutex);
2498
2499 s2mu106_poll_status(pd_data);
2500
2501#ifndef CONFIG_SEC_FACTORY
2502 if (pdic_data->lpcharge_water)
2503 goto out;
2504#endif
2505
99e9c3ca 2506 if (pdic_data->status_reg == 0)
5073353a
JB		 2507 goto out;
2508
5073353a
JB		 2509 if (s2mu106_get_status(pd_data, MSG_SOFTRESET))
2510 usbpd_rx_soft_reset(pd_data);
2511
2512 if (s2mu106_get_status(pd_data, PLUG_DETACH)) {
2513#if defined(CONFIG_SEC_FACTORY)
2514 ret = s2mu106_usbpd_check_619k(pdic_data);
2515 if (ret)
2516 goto skip_detach;
2517#endif /* CONFIG_SEC_FACTORY */
0ef320fa 2518 s2mu106_usbpd_set_rp_scr_sel(pdic_data, PLUG_CTRL_RP80);
5073353a
JB		 2519 attach_status = s2mu106_get_status(pd_data, PLUG_ATTACH);
2520 rid_status = s2mu106_get_status(pd_data, MSG_RID);
2521 s2mu106_usbpd_detach_init(pdic_data);
8a38de7f 2522 s2mu106_usbpd_notify_detach(pdic_data);
5073353a
JB		 2523 if (attach_status) {
2524 ret = s2mu106_check_port_detect(pdic_data);
2525 if (ret >= 0) {
2526 if (rid_status) {
2527 pdic_data->check_rid_wa = true;
2528 s2mu106_usbpd_check_rid(pdic_data);
2529 }
2530 goto hard_reset;
2531 }
2532 }
8a38de7f 2533#if 0
5073353a
JB		 2534 mutex_lock(&pdic_data->lpm_mutex);
2535 if (!pdic_data->lpm_mode) {
2536 if (s2mu106_usbpd_lpm_check(pdic_data) > 0) {
2537 pr_info("%s force to normal mode\n", __func__);
2538 s2mu106_usbpd_set_mode(pdic_data, PD_NORMAL_MODE);
2539 }
2540 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2541 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
2542 }
2543 mutex_unlock(&pdic_data->lpm_mutex);
8a38de7f 2544#endif
5073353a
JB		 2545 goto out;
2546 }
40798a41
JB		 2547
2548 if (s2mu106_get_status(pd_data, MSG_HARDRESET)) {
2549 mutex_lock(&pdic_data->cc_mutex);
2550 s2mu106_usbpd_set_cc_control(pdic_data, USBPD_CC_OFF);
2551 mutex_unlock(&pdic_data->cc_mutex);
2552 s2mu106_self_soft_reset(i2c);
2553 pdic_data->status_reg = 0;
99e9c3ca
JB		 2554 if (pdic_data->power_role == PDIC_SOURCE)
2555 s2mu106_dfp(i2c);
2556 else
2557 s2mu106_ufp(i2c);
40798a41
JB		 2558 usbpd_rx_hard_reset(dev);
2559 usbpd_kick_policy_work(dev);
2560 goto out;
2561 }
2562
5073353a
JB		 2563#if defined(CONFIG_SEC_FACTORY)
2564skip_detach:
2565#endif /* CONFIG_SEC_FACTORY */
2566 if (s2mu106_get_status(pd_data, PLUG_ATTACH) && !pdic_data->is_pr_swap) {
2567 if (s2mu106_check_port_detect(data) < 0)
2568 goto out;
2569 }
2570
2571 if (s2mu106_get_status(pd_data, MSG_RID)) {
2572 pdic_data->check_rid_wa = true;
2573 s2mu106_usbpd_check_rid(pdic_data);
2574 }
2575
2576hard_reset:
2577 mutex_lock(&pdic_data->lpm_mutex);
2578 if (!pdic_data->lpm_mode)
2579 usbpd_kick_policy_work(dev);
2580 mutex_unlock(&pdic_data->lpm_mutex);
2581out:
2582 mutex_unlock(&pdic_data->_mutex);
1bad7ece 2583
5073353a
JB		 2584 return IRQ_HANDLED;
2585}
2586
0ef320fa
JB		 2587static void s2mu106_usbpd_plug_work(struct work_struct *work)
2588{
2589 struct s2mu106_usbpd_data *pdic_data =
2590 container_of(work, struct s2mu106_usbpd_data, plug_work.work);
2591
2592 s2mu106_irq_thread(-1, pdic_data);
2593}
2594
2595static void s2mu106_usbpd_dr_work(struct work_struct *work)
2596{
2597 struct s2mu106_usbpd_data *usbpd_data =
2598 container_of(work, struct s2mu106_usbpd_data, dr_work.work);
2599 struct i2c_client *i2c = usbpd_data->i2c;
2600
2601 dev_info(&i2c->dev, "%s : before - is_host : %d, is_client : %d\n",
2602 __func__, usbpd_data->is_host, usbpd_data->is_client);
2603 if (usbpd_data->is_host == HOST_ON) {
2604 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB,
2605 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2606
2607 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2608 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
2609 usbpd_data->is_host = HOST_OFF;
2610 usbpd_data->is_client = CLIENT_ON;
2611 } else if (usbpd_data->is_client == CLIENT_ON) {
2612 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2613 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2614
2615 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2616 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP, NULL);
2617 usbpd_data->is_host = HOST_ON;
2618 usbpd_data->is_client = CLIENT_OFF;
2619 }
2620 dev_info(&i2c->dev, "%s : after - is_host : %d, is_client : %d\n",
2621 __func__, usbpd_data->is_host, usbpd_data->is_client);
2622}
2623
5073353a
JB		 2624static int s2mu106_usbpd_get_property(struct power_supply *psy,
2625 enum power_supply_property psp,
2626 union power_supply_propval *val)
2627{
2628 switch (psp) {
2629 case POWER_SUPPLY_PROP_AUTHENTIC:
2630 break;
2631 default:
2632 return -EINVAL;
2633 }
2634
2635 return 0;
2636}
2637
2638static int s2mu106_usbpd_set_property(struct power_supply *psy,
2639 enum power_supply_property psp,
2640 const union power_supply_propval *val)
2641{
2642 struct s2mu106_usbpd_data *pdic_data =
2643 power_supply_get_drvdata(psy);
2644 struct i2c_client *i2c = pdic_data->i2c;
2645 u8 data = 0;
2646
2647 switch (psp) {
40798a41
JB		 2648 case POWER_SUPPLY_PROP_AUTHENTIC:
2649 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, &data);
2650 data &= ~(S2MU106_REG_RD_OR_VBUS_MUX_SEL);
2651 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, data);
2652 break;
2653 case POWER_SUPPLY_PROP_USBPD_RESET:
2654 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2655 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
2656 break;
2657 default:
2658 return -EINVAL;
5073353a
JB		 2659 }
2660 return 0;
2661}
2662
2663int s2mu106_usbpd_psy_init(struct s2mu106_usbpd_data *_data, struct device *parent)
2664{
2665 struct power_supply_config psy_cfg = {};
2666 int ret = 0;
2667
2668 if (_data == NULL || parent == NULL) {
2669 pr_err("%s NULL data\n", __func__);
2670 return -1;
2671 }
2672
2673 _data->ccic_desc.name = "s2mu106-usbpd";
2674 _data->ccic_desc.type = POWER_SUPPLY_TYPE_UNKNOWN;
2675 _data->ccic_desc.get_property = s2mu106_usbpd_get_property;
2676 _data->ccic_desc.set_property = s2mu106_usbpd_set_property;
2677 _data->ccic_desc.properties = ccic_props;
2678 _data->ccic_desc.num_properties = ARRAY_SIZE(ccic_props);
2679
2680 psy_cfg.drv_data = _data;
2681 psy_cfg.supplied_to = ccic_supplied_to;
2682 psy_cfg.num_supplicants = ARRAY_SIZE(ccic_supplied_to);
2683
2684 _data->psy_ccic = power_supply_register(parent, &_data->ccic_desc, &psy_cfg);
2685 if (IS_ERR(_data->psy_ccic)) {
2686 ret = (int)PTR_ERR(_data->psy_ccic);
2687 pr_err("%s: Failed to Register psy_ccic, ret : %d\n", __func__, ret);
2688 }
2689 return ret;
2690}
2691
2692static int s2mu106_usbpd_reg_init(struct s2mu106_usbpd_data *_data)
2693{
2694 struct i2c_client *i2c = _data->i2c;
2695 u8 data = 0;
2696
5073353a
JB		 2697 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PHY_CTRL_IFG, &data);
2698 data |= S2MU106_PHY_IFG_35US << S2MU106_REG_IFG_SHIFT;
2699 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PHY_CTRL_IFG, data);
2700
40798a41
JB		 2701 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_MSG_SEND_CON, &data);
2702 data |= S2MU106_REG_MSG_SEND_CON_HARD_EN;
2703 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_MSG_SEND_CON, data);
2704
2705 /* for SMPL issue */
2706 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_ANALOG_OTP_0A, &data);
2707 data |= S2MU106_REG_OVP_ON;
2708 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_ANALOG_OTP_0A, data);
2709
5073353a
JB		 2710 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL_2, &data);
2711 data &= ~S2MU106_REG_CC_OCP_MASK;
2712 data |= S2MU106_CC_OCP_575MV << S2MU106_REG_CC_OCP_SHIFT;
2713 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL_2, data);
2714
40798a41
JB		 2715 /* enable Rd monitor status when cc is attached at sink */
2716 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_MON, &data);
2717 data |= S2MU106_REG_PLUG_CTRL_SET_MON_RD;
2718 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_MON, data);
2719
2720 /* diable rd or vbus mux */
5073353a 2721 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, &data);
40798a41 2722 data &= ~S2MU106_REG_RD_OR_VBUS_MUX_SEL;
5073353a
JB		 2723 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, data);
2724
40798a41
JB		 2725 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PHY_CTRL_00, 0x80);
2726 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_BMC_CTRL, &data);
2727 data |= 0x01 << 2;
2728 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_BMC_CTRL, data);
2729
2730 /* set debounce time
2731 devide by 300 and unit is ms */
2732 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_TIMER1, 0xe4);
2733 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_TIMER2, 0x0c);
2734
2735 /* enable support acc */
2736 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &data);
2737 data |= S2MU106_REG_PLUG_CTRL_SUPPORT_ACC;
2738 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, data);
2739
2740 /* fix trim code */
2741 s2mu106_usbpd_read_reg(i2c, 0x00, &data);
2742 data |= 0x1 | 0x3 << 2;
2743 s2mu106_usbpd_write_reg(i2c, 0x00, data);
2744
2745 data = 0;
2746 data |= (S2MU106_REG_PLUG_CTRL_SSM_DISABLE |
2747 S2MU106_REG_PLUG_CTRL_VDM_DISABLE);
5073353a
JB		 2748 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
2749
2750 /* set Rd threshold to 400mV */
2751 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD_2, S2MU106_THRESHOLD_600MV);
2752 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP_2, S2MU106_THRESHOLD_1200MV);
40798a41 2753 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD, S2MU106_THRESHOLD_300MV | 0x40);
5073353a
JB		 2754 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP, S2MU106_THRESHOLD_2057MV);
2755
2756 if (_data->vconn_en) {
2757 /* Off Manual Rd setup & On Manual Vconn setup */
2758 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &data);
2759 data &= ~(S2MU106_REG_PLUG_CTRL_RpRd_MANUAL_EN_MASK);
2760 data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
2761 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, data);
2762 }
40798a41
JB		 2763#ifdef CONFIG_PM_S2MU106
2764 s2mu106_usbpd_set_pmeter_mode(_data, PM_TYPE_VCHGIN);
2765#endif
5073353a 2766
5073353a
JB		 2767 s2mu106_usbpd_set_vconn_manual(_data, true);
2768
2769 return 0;
2770}
2771
2772static irqreturn_t s2mu106_irq_isr(int irq, void *data)
2773{
2774 return IRQ_WAKE_THREAD;
2775}
2776
2777static int s2mu106_usbpd_irq_init(struct s2mu106_usbpd_data *_data)
2778{
2779 struct i2c_client *i2c = _data->i2c;
2780 struct device *dev = &i2c->dev;
2781 int ret = 0;
2782
2783 if (!_data->irq_gpio) {
2784 dev_err(dev, "%s No interrupt specified\n", __func__);
2785 return -ENXIO;
2786 }
2787
2788/* s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
2789 S2MU106_MAX_NUM_INT_STATUS, intr);
2790
2791 pr_info("%s status[0x%x 0x%x 0x%x 0x%x 0x%x]\n",
2792 __func__, intr[0], intr[1], intr[2], intr[3], intr[4]);
2793*/
2794 i2c->irq = gpio_to_irq(_data->irq_gpio);
2795
2796 if (i2c->irq) {
2797 ret = request_threaded_irq(i2c->irq, s2mu106_irq_isr,
2798 s2mu106_irq_thread,
ff24394b 2799 (IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_NO_SUSPEND),
5073353a
JB		 2800 "s2mu106-usbpd", _data);
2801 if (ret < 0) {
2802 dev_err(dev, "%s failed to request irq(%d)\n",
2803 __func__, i2c->irq);
2804 return ret;
2805 }
2806
2807 ret = enable_irq_wake(i2c->irq);
2808 if (ret < 0)
2809 dev_err(dev, "%s failed to enable wakeup src\n",
2810 __func__);
2811 }
2812
2813 if (_data->lpm_mode)
2814 s2mu106_set_irq_enable(_data, 0, 0, 0, 0, 0, 0);
2815 else
99e9c3ca
JB		 2816 s2mu106_set_irq_enable(_data, ENABLED_INT_0, ENABLED_INT_1,
2817 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
5073353a
JB		 2818
2819 return ret;
2820}
2821
2822static void s2mu106_usbpd_init_configure(struct s2mu106_usbpd_data *_data)
2823{
8a38de7f
KT		 2824 s2mu106_usbpd_test_read(_data);
2825 s2mu106_usbpd_get_pmeter_volt(_data);
2826 s2mu106_usbpd_get_pmeter_current(_data);
2827 pr_info("%s, chgin(%d), chgin_i(%d)\n", __func__,
2828 _data->pm_chgin, _data->pm_chgin_i);
2829 usbpd_charger_test_read(_data);
5073353a 2830 s2mu106_set_normal_mode(_data);
8a38de7f
KT		 2831 pr_info("%s, usbpd irq gpio value(%d)\n", __func__,
2832 gpio_get_value(_data->irq_gpio));
5073353a
JB		 2833 msleep(25);
2834 _data->detach_valid = true;
f0beeda5 2835 s2mu106_self_soft_reset(_data->i2c);
5073353a
JB		 2836 s2mu106_set_lpm_mode(_data);
2837 _data->detach_valid = false;
2838 s2mu106_usbpd_set_cc_control(_data, USBPD_CC_OFF);
2839 _data->lpm_mode = true;
8dfccaba
JB		 2840 if (_data->pm_chgin > 4800 && _data->pm_chgin_i > 1000)
2841 msleep(500); /* for abnormal PD TA */
2842 else
2843 msleep(150);
5073353a
JB		 2844 _data->is_factory_mode = false;
2845 s2mu106_set_normal_mode(_data);
2846 _data->lpm_mode = false;
2847}
2848
2849static void s2mu106_usbpd_pdic_data_init(struct s2mu106_usbpd_data *_data)
2850{
2851 _data->check_msg_pass = false;
2852 _data->vconn_source = USBPD_VCONN_OFF;
2853 _data->rid = REG_RID_MAX;
2854 _data->is_host = 0;
2855 _data->is_client = 0;
2856 _data->data_role_dual = 0;
2857 _data->power_role_dual = 0;
2858 _data->is_water_detect = false;
2859 _data->is_muic_water_detect = false;
2860 _data->detach_valid = true;
2861 _data->is_otg_vboost = false;
2862 _data->is_otg_reboost = false;
2863 _data->is_pr_swap = false;
40798a41 2864 _data->vbus_access = false;
5073353a
JB		 2865#ifndef CONFIG_SEC_FACTORY
2866 _data->lpcharge_water = false;
2867#endif
2868 _data->check_rid_wa = false;
8a38de7f
KT		 2869#if defined(CONFIG_TYPEC)
2870 _data->typec_power_role = TYPEC_SINK;
2871 _data->typec_data_role = TYPEC_DEVICE;
2872#endif
5073353a
JB		 2873}
2874
2875static int of_s2mu106_dt(struct device *dev,
2876 struct s2mu106_usbpd_data *_data)
2877{
2878 struct device_node *np_usbpd = dev->of_node;
2879 int ret = 0;
2880
2881 if (np_usbpd == NULL) {
2882 dev_err(dev, "%s np NULL\n", __func__);
2883 return -EINVAL;
2884 } else {
2885 _data->irq_gpio = of_get_named_gpio(np_usbpd,
2886 "usbpd,usbpd_int", 0);
2887 if (_data->irq_gpio < 0) {
2888 dev_err(dev, "error reading usbpd irq = %d\n",
2889 _data->irq_gpio);
2890 _data->irq_gpio = 0;
2891 }
8a38de7f
KT		 2892 ret = gpio_get_value(_data->irq_gpio);
2893 pr_info("%s, usbpd irq gpio value(%d)\n", __func__, ret);
5073353a
JB		 2894 if (of_find_property(np_usbpd, "vconn-en", NULL))
2895 _data->vconn_en = true;
2896 else
2897 _data->vconn_en = false;
2898
2899 if (of_find_property(np_usbpd, "regulator-en", NULL))
2900 _data->regulator_en = true;
2901 else
2902 _data->regulator_en = false;
2903#ifdef CONFIG_CCIC_DP
2904 _data->usb_sw_sel = of_get_named_gpio(np_usbpd, "usb_sw_sel", 0);
2905
2906 if (!gpio_is_valid(_data->usb_sw_sel))
2907 dev_err(dev, "failed to get gpio usb_sw_sel\n");
2908#endif
2909 }
2910 return ret;
2911}
2912
2913static int s2mu106_usbpd_probe(struct i2c_client *i2c,
2914 const struct i2c_device_id *id)
2915{
2916 struct i2c_adapter *adapter = to_i2c_adapter(i2c->dev.parent);
2917 struct s2mu106_usbpd_data *pdic_data;
2918 struct device *dev = &i2c->dev;
2919 int ret = 0;
2920
2921 dev_info(dev, "%s\n", __func__);
2922 test_i2c = i2c;
2923
2924 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
2925 dev_err(dev, "%s: i2c functionality check error\n", __func__);
2926 ret = -EIO;
2927 goto err_return;
2928 }
2929
2930 pdic_data = kzalloc(sizeof(struct s2mu106_usbpd_data), GFP_KERNEL);
2931 if (!pdic_data) {
2932 dev_err(dev, "%s: failed to allocate driver data\n", __func__);
2933 ret = -ENOMEM;
2934 goto err_return;
2935 }
2936
2937 /* save platfom data for gpio control functions */
2938 pdic_data->dev = &i2c->dev;
2939 pdic_data->i2c = i2c;
2940 i2c_set_clientdata(i2c, pdic_data);
2941
2942 ret = of_s2mu106_dt(&i2c->dev, pdic_data);
2943 if (ret < 0)
2944 dev_err(dev, "%s: not found dt!\n", __func__);
2945
2946 mutex_init(&pdic_data->_mutex);
2947 mutex_init(&pdic_data->lpm_mutex);
2948 mutex_init(&pdic_data->cc_mutex);
2949 wake_lock_init(&pdic_data->wake_lock, WAKE_LOCK_SUSPEND, "pdic_wake");
2950
8a38de7f
KT		 2951#ifdef CONFIG_PM_S2MU106
2952 pdic_data->psy_pm = power_supply_get_by_name("s2mu106_pmeter");
2953 if (!pdic_data->psy_pm)
2954 pr_err("%s: Fail to get pmeter\n", __func__);
2955 s2mu106_usbpd_set_pmeter_mode(pdic_data, PM_TYPE_VCHGIN);
2956 s2mu106_usbpd_set_pmeter_mode(pdic_data, PM_TYPE_ICHGIN);
2957#endif
2958
5073353a
JB		 2959 s2mu106_usbpd_init_configure(pdic_data);
2960 s2mu106_usbpd_pdic_data_init(pdic_data);
2961
2962 if (pdic_data->regulator_en) {
2963 pdic_data->regulator = devm_regulator_get(dev, "vconn");
2964 if (IS_ERR(pdic_data->regulator)) {
2965 dev_err(dev, "%s: not found regulator vconn\n", __func__);
2966 pdic_data->regulator_en = false;
2967 } else
2968 ret = regulator_disable(pdic_data->regulator);
2969 }
2970
2971 ret = usbpd_init(dev, pdic_data);
2972 if (ret < 0) {
2973 dev_err(dev, "failed on usbpd_init\n");
2974 goto err_return;
2975 }
2976
2977 usbpd_set_ops(dev, &s2mu106_ops);
2978
2979 s2mu106_usbpd_reg_init(pdic_data);
2980
2981 pdic_data->pdic_queue =
2982 alloc_workqueue(dev_name(dev), WQ_MEM_RECLAIM, 1);
2983 if (!pdic_data->pdic_queue) {
2984 dev_err(dev,
2985 "%s: Fail to Create Workqueue\n", __func__);
2986 goto err_return;
2987 }
2988
2989#if defined(CONFIG_IFCONN_NOTIFIER)
2990 /* Create a work queue for the ccic irq thread */
2991 pdic_data->ifconn_wq
2992 = create_singlethread_workqueue("ifconn_notify_event");
2993 if (!pdic_data->ifconn_wq) {
2994 pr_err("%s failed to create work queue for ccic notifier\n",
2995 __func__);
2996 goto err_return;
2997 }
2998#endif
2999 if (pdic_data->rid == REG_RID_UNDF)
3000 pdic_data->rid = REG_RID_MAX;
8a38de7f
KT		 3001#if defined(CONFIG_TYPEC)
3002 ret = typec_init(pdic_data);
3003 if (ret < 0) {
3004 pr_err("failed to init typec\n");
3005 goto err_return;
3006 }
3007#endif
5073353a
JB		 3008
3009 ret = s2mu106_usbpd_irq_init(pdic_data);
3010 if (ret) {
3011 dev_err(dev, "%s: failed to init irq(%d)\n", __func__, ret);
3012 goto fail_init_irq;
3013 }
3014 INIT_DELAYED_WORK(&pdic_data->water_detect_handler, S2MU106_PDIC_water_detect_handler);
3015 INIT_DELAYED_WORK(&pdic_data->water_dry_handler, S2MU106_PDIC_water_dry_handler);
0ef320fa
JB		 3016 INIT_DELAYED_WORK(&pdic_data->water_dry_handler, S2MU106_PDIC_water_dry_handler);
3017 INIT_DELAYED_WORK(&pdic_data->plug_work, s2mu106_usbpd_plug_work);
3018 INIT_DELAYED_WORK(&pdic_data->dr_work, s2mu106_usbpd_dr_work);
5073353a
JB		 3019
3020 if (pdic_data->detach_valid) {
3021 mutex_lock(&pdic_data->_mutex);
3022 s2mu106_check_port_detect(pdic_data);
3023 s2mu106_usbpd_check_rid(pdic_data);
3024 mutex_unlock(&pdic_data->_mutex);
3025 }
3026
3027 s2mu106_irq_thread(-1, pdic_data);
3028
3029#if defined(CONFIG_MUIC_NOTIFIER)
3030 muic_ccic_notifier_register(&pdic_data->type3_nb,
3031 type3_handle_notification,
3032 MUIC_NOTIFY_DEV_PDIC);
3033#endif
3034#if defined(CONFIG_DUAL_ROLE_USB_INTF)
3035 ret = dual_role_init(pdic_data);
3036 if (ret < 0) {
3037 pr_err("unable to allocate dual role descriptor\n");
3038 goto fail_init_irq;
3039 }
3040
3041#endif
3042 ret = s2mu106_usbpd_psy_init(pdic_data, &i2c->dev);
3043 if (ret < 0) {
3044 pr_err("faled to register the ccic psy.\n");
3045 }
3046
3047 dev_info(dev, "%s s2mu106 usbpd driver uploaded!\n", __func__);
3048
3049 return 0;
3050
3051fail_init_irq:
3052 if (i2c->irq)
3053 free_irq(i2c->irq, pdic_data);
3054err_return:
3055 return ret;
3056}
3057
3058#if defined CONFIG_PM
3059static int s2mu106_usbpd_suspend(struct device *dev)
3060{
3061 struct usbpd_data *_data = dev_get_drvdata(dev);
3062 struct s2mu106_usbpd_data *pdic_data = _data->phy_driver_data;
3063
3064 if (device_may_wakeup(dev))
3065 enable_irq_wake(pdic_data->i2c->irq);
3066
3067#ifndef CONFIG_SEC_FACTORY
3068 disable_irq(pdic_data->i2c->irq);
3069#endif
3070 return 0;
3071}
3072
3073static int s2mu106_usbpd_resume(struct device *dev)
3074{
3075 struct usbpd_data *_data = dev_get_drvdata(dev);
3076 struct s2mu106_usbpd_data *pdic_data = _data->phy_driver_data;
3077
3078 if (device_may_wakeup(dev))
3079 disable_irq_wake(pdic_data->i2c->irq);
3080
3081#ifndef CONFIG_SEC_FACTORY
3082 enable_irq(pdic_data->i2c->irq);
3083#endif
3084 return 0;
3085}
3086#else
3087#define s2mu106_muic_suspend NULL
3088#define s2mu106_muic_resume NULL
3089#endif
3090
3091static int s2mu106_usbpd_remove(struct i2c_client *i2c)
3092{
3093 struct s2mu106_usbpd_data *_data = i2c_get_clientdata(i2c);
3094
3095 if (_data) {
3096#if defined(CONFIG_DUAL_ROLE_USB_INTF)
3097 devm_dual_role_instance_unregister(_data->dev,
3098 _data->dual_role);
3099 devm_kfree(_data->dev, _data->desc);
8a38de7f
KT		 3100#elif defined(CONFIG_TYPEC)
3101 typec_unregister_port(_data->port);
5073353a
JB		 3102#endif
3103 disable_irq_wake(_data->i2c->irq);
3104 free_irq(_data->i2c->irq, _data);
3105 mutex_destroy(&_data->_mutex);
3106 i2c_set_clientdata(_data->i2c, NULL);
3107 kfree(_data);
3108 }
3109 return 0;
3110}
3111
3112static const struct i2c_device_id s2mu106_usbpd_i2c_id[] = {
3113 { USBPD_DEV_NAME, 1 },
3114 {}
3115};
3116MODULE_DEVICE_TABLE(i2c, s2mu106_i2c_id);
3117
3118static struct of_device_id sec_usbpd_i2c_dt_ids[] = {
3119 { .compatible = "sec-usbpd,i2c" },
3120 { }
3121};
3122
3123static void s2mu106_usbpd_shutdown(struct i2c_client *i2c)
3124{
3125 struct s2mu106_usbpd_data *_data = i2c_get_clientdata(i2c);
3126
3127 if (!_data->i2c)
3128 return;
3129}
3130
3131static usbpd_phy_ops_type s2mu106_ops = {
3132 .tx_msg = s2mu106_tx_msg,
3133 .rx_msg = s2mu106_rx_msg,
3134 .hard_reset = s2mu106_hard_reset,
40798a41 3135 .soft_reset = s2mu106_soft_reset,
5073353a
JB		 3136 .set_power_role = s2mu106_set_power_role,
3137 .get_power_role = s2mu106_get_power_role,
3138 .set_data_role = s2mu106_set_data_role,
3139 .get_data_role = s2mu106_get_data_role,
3140 .set_vconn_source = s2mu106_set_vconn_source,
3141 .get_vconn_source = s2mu106_get_vconn_source,
3142 .set_check_msg_pass = s2mu106_set_check_msg_pass,
3143 .get_status = s2mu106_get_status,
3144 .poll_status = s2mu106_poll_status,
3145 .driver_reset = s2mu106_driver_reset,
3146 .set_otg_control = s2mu106_set_otg_control,
5073353a
JB		 3147 .set_cc_control = s2mu106_set_cc_control,
3148 .get_side_check = s2mu106_get_side_check,
40798a41
JB		 3149 .pr_swap = s2mu106_pr_swap,
3150 .vbus_on_check = s2mu106_vbus_on_check,
0ef320fa 3151 .set_pwr_opmode = s2mu106_set_pwr_opmode,
7158ce20 3152 .set_rp_control = s2mu106_set_rp_control,
5073353a
JB		 3153};
3154
3155#if defined CONFIG_PM
3156const struct dev_pm_ops s2mu106_usbpd_pm = {
3157 .suspend = s2mu106_usbpd_suspend,
3158 .resume = s2mu106_usbpd_resume,
3159};
3160#endif
3161
3162static struct i2c_driver s2mu106_usbpd_driver = {
3163 .driver = {
3164 .name = USBPD_DEV_NAME,
3165 .of_match_table = sec_usbpd_i2c_dt_ids,
3166#if defined CONFIG_PM
3167 .pm = &s2mu106_usbpd_pm,
3168#endif /* CONFIG_PM */
3169 },
3170 .probe = s2mu106_usbpd_probe,
3171 .remove = s2mu106_usbpd_remove,
3172 .shutdown = s2mu106_usbpd_shutdown,
3173 .id_table = s2mu106_usbpd_i2c_id,
3174};
3175
3176static int __init s2mu106_usbpd_init(void)
3177{
3178 return i2c_add_driver(&s2mu106_usbpd_driver);
3179}
3180late_initcall(s2mu106_usbpd_init);
3181
3182static void __exit s2mu106_usbpd_exit(void)
3183{
3184 i2c_del_driver(&s2mu106_usbpd_driver);
3185}
3186module_exit(s2mu106_usbpd_exit);
3187
3188MODULE_DESCRIPTION("s2mu106 USB PD driver");
3189MODULE_LICENSE("GPL");