projects / GitHub / moto-9609 / android_kernel_motorola_exynos9610.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
usb:Balance the enable/disable in secure mode
[GitHub/moto-9609/android_kernel_motorola_exynos9610.git] / drivers / ccic / s2mu106-usbpd.c
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
31 #if defined(CONFIG_PM_S2MU106)
32 #include <linux/power/s2mu106_pmeter.h>
33 #endif
34
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
54 struct pdic_notifier_data pd_noti;
55 #endif
56 /*
57 *VARIABLE DEFINITION
58 */
59 static usbpd_phy_ops_type s2mu106_ops;
60 struct i2c_client *test_i2c;
61
62 static enum power_supply_property ccic_props[] = {
63 };
64
65 static char *ccic_supplied_to[] = {
66 "battery",
67 };
68 /*
69 *FUNCTION DEFINITION
70 */
71 static int s2mu106_receive_message(void *data);
72 static int s2mu106_check_port_detect(struct s2mu106_usbpd_data *pdic_data);
73 static int s2mu106_usbpd_reg_init(struct s2mu106_usbpd_data *_data);
74 static void s2mu106_dfp(struct i2c_client *i2c);
75 static void s2mu106_ufp(struct i2c_client *i2c);
76 static int s2mu106_usbpd_check_msg(void *_data, u64 *val);
77 static void s2mu106_src(struct i2c_client *i2c);
78 static void s2mu106_snk(struct i2c_client *i2c);
79 static void s2mu106_assert_rd(void *_data);
80 static void s2mu106_assert_rp(void *_data);
81 static void s2mu106_assert_drp(void *_data);
82 static void s2mu106_usbpd_check_rid(struct s2mu106_usbpd_data *pdic_data);
83 static int s2mu106_usbpd_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest);
84 static int s2mu106_usbpd_write_reg(struct i2c_client *i2c, u8 reg, u8 value);
85 #ifndef CONFIG_SEC_FACTORY
86 static void s2mu106_usbpd_notify_detach(struct s2mu106_usbpd_data *pdic_data);
87 #endif
88 static void s2mu106_usbpd_detach_init(struct s2mu106_usbpd_data *pdic_data);
89 static int s2mu106_usbpd_set_cc_control(struct s2mu106_usbpd_data *pdic_data, int val);
90 static void s2mu106_usbpd_set_rp_scr_sel(struct s2mu106_usbpd_data *pdic_data,
91 CCIC_RP_SCR_SEL scr_sel);
92
93 char *rid_text[] = {
94 "UNDEFINED",
95 "RID ERROR",
96 "RID ERROR",
97 "RID 255K",
98 "RID 301K",
99 "RID 523K",
100 "RID 619K"
101 };
102
103 static 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]);
116 s2mu106_usbpd_read_reg(i2c, 0xf7, &data[8]);
117
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]);
121 }
122
123 void 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;
127 struct device *dev = &i2c->dev;
128 struct usbpd_data *pd_data = dev_get_drvdata(dev);
129 pr_info("%s, mode=0x%x\n", __func__, mode);
130
131 mutex_lock(&usbpd_data->_mutex);
132 if (usbpd_data->lpm_mode)
133 goto skip;
134
135 pr_info("%s, %d\n", __func__, __LINE__);
136 switch (mode) {
137 case TYPE_C_ATTACH_DFP: /* SRC */
138 s2mu106_usbpd_set_cc_control(usbpd_data, USBPD_CC_OFF);
139 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP0);
140 s2mu106_assert_rp(pd_data);
141 msleep(20);
142 s2mu106_usbpd_detach_init(usbpd_data);
143 s2mu106_usbpd_notify_detach(usbpd_data);
144 msleep(600);
145 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP80);
146 msleep(S2MU106_ROLE_SWAP_TIME_MS);
147 s2mu106_assert_drp(pd_data);
148 usbpd_data->status_reg |= PLUG_ATTACH;
149 schedule_delayed_work(&usbpd_data->plug_work, 0);
150 break;
151 case TYPE_C_ATTACH_UFP: /* SNK */
152 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_MUIC,
153 IFCONN_NOTIFY_ID_ROLE_SWAP,
154 IFCONN_NOTIFY_EVENT_PD_SINK, NULL);
155 s2mu106_usbpd_set_cc_control(usbpd_data, USBPD_CC_OFF);
156 s2mu106_assert_rp(pd_data);
157 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP0);
158 msleep(20);
159 s2mu106_usbpd_detach_init(usbpd_data);
160 s2mu106_usbpd_notify_detach(usbpd_data);
161 msleep(600);
162 s2mu106_assert_rd(pd_data);
163 s2mu106_usbpd_set_rp_scr_sel(usbpd_data, PLUG_CTRL_RP80);
164 msleep(S2MU106_ROLE_SWAP_TIME_MS);
165 s2mu106_assert_drp(pd_data);
166 usbpd_data->status_reg |= PLUG_ATTACH;
167 schedule_delayed_work(&usbpd_data->plug_work, 0);
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 };
175 skip:
176 mutex_unlock(&usbpd_data->_mutex);
177 }
178
179 void 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
197 void 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);
205
206 if (usbpd_data->detach_valid) {
207 dev_info(usbpd_data->dev, "%s, ignore vbus control\n", __func__);
208 return;
209 }
210
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
242 #ifdef CONFIG_PM_S2MU106
243 static 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
267 static 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
274 if (psy_pm)
275 ret = psy_pm->desc->get_property(psy_pm, POWER_SUPPLY_PROP_VCHGIN, &val);
276 else {
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
292 static 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
317 static int s2mu106_usbpd_check_vbus(struct s2mu106_usbpd_data *pdic_data,
318 int volt, CCIC_VBUS_SEL mode)
319 {
320 int ret = 0;
321
322 if (mode == VBUS_OFF) {
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;
336 }
337 } else if (mode == VBUS_ON) {
338 ret = s2mu106_usbpd_get_pmeter_volt(pdic_data);
339 if (ret < 0)
340 return ret;
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);
344 return true;
345 } else
346 return false;
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
356 static 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
373 #if defined(CONFIG_IFCONN_NOTIFIER)
374 static void process_dr_swap(struct s2mu106_usbpd_data *usbpd_data)
375 {
376 schedule_delayed_work(&usbpd_data->dr_work, msecs_to_jiffies(0));
377 }
378 #endif
379
380 static 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
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);
389 ifconn_event_work(pdic_data, IFCONN_NOTIFY_BATTERY,
390 IFCONN_NOTIFY_ID_DETACH, 0, 0);
391 } else if (val == USBPD_SOURCE_ON) {
392 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
393 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SRC;
394 #elif defined(CONFIG_TYPEC)
395 pdic_data->typec_power_role = TYPEC_SOURCE;
396 #endif
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;
402 #elif defined(CONFIG_TYPEC)
403 pdic_data->typec_power_role = TYPEC_SINK;
404 #endif
405 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
406 IFCONN_NOTIFY_ID_ROLE_SWAP,
407 IFCONN_NOTIFY_EVENT_PD_SINK, 0);
408 }
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
416 }
417
418 static 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
440 static 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
480 static 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
499 static 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
519 static 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
541 static 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
551 static 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
560 static 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 }
577 #endif
578 static 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
587 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_OP_MODE |
588 S2MU106_REG_MSG_SEND_CON_HARD_EN);
589
590 return ret;
591 }
592
593 static 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
602 static 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
622 static 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
645 static 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
653 static 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
669 static 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
685 static 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;
691 #if 0
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;
696 #endif
697
698 if (pdic_data->cc1_val == USBPD_Rd) {
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
713 if (pdic_data->cc2_val == USBPD_Rd) {
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
738 static 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
755 static 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
770 static bool s2mu106_poll_status(void *_data)
771 {
772 struct usbpd_data *data = (struct usbpd_data *) _data;
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;
779 msg_header_type header;
780 int data_obj_num = 0;
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
788 if ((intr[0] | intr[1] | intr[2] | intr[3] | intr[4] | intr[5]) == 0)
789 goto out;
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
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
820 if (intr[5] & S2MU106_REG_INT_STATUS5_HARD_RESET)
821 status_reg_val |= MSG_HARDRESET;
822
823 if (intr[0] & S2MU106_REG_INT_STATUS0_MSG_GOODCRC)
824 status_reg_val |= MSG_GOODCRC;
825
826 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PR_SWAP)
827 status_reg_val |= MSG_PR_SWAP;
828
829 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_SOFTRESET)
830 status_reg_val |= MSG_SOFTRESET;
831
832 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_DR_SWAP)
833 status_reg_val |= MSG_DR_SWAP;
834
835 if (intr[0] & S2MU106_REG_INT_STATUS0_MSG_ACCEPT)
836 status_reg_val |= MSG_ACCEPT;
837
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);
844 if (data->msg_received == 0)
845 goto out;
846
847 header = data->protocol_rx.msg_header;
848 data_obj_num = header.num_data_objs;
849
850 if (data_obj_num > 0)
851 s2mu106_usbpd_check_msg(data, &status_reg_val);
852
853 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PSRDY)
854 status_reg_val |= MSG_PSRDY;
855
856 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_REQUEST)
857 status_reg_val |= MSG_REQUEST;
858
859 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_REJECT)
860 status_reg_val |= MSG_REJECT;
861
862 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_WAIT)
863 status_reg_val |= MSG_WAIT;
864
865 if (intr[4] & S2MU106_REG_INT_STATUS4_MSG_ERROR)
866 status_reg_val |= MSG_ERROR;
867
868 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_PING)
869 status_reg_val |= MSG_PING;
870
871 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_GETSNKCAP)
872 status_reg_val |= MSG_GET_SNK_CAP;
873
874 if (intr[1] & S2MU106_REG_INT_STATUS1_MSG_GETSRCCAP)
875 status_reg_val |= MSG_GET_SRC_CAP;
876
877 if (intr[2] & S2MU106_REG_INT_STATUS2_MSG_VCONN_SWAP)
878 status_reg_val |= MSG_VCONN_SWAP;
879 }
880 }
881 out:
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
893 static 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
902 static 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;
909 u8 Read_Value = 0;
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;
920
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;
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);
934 udelay(1);
935 ret = s2mu106_usbpd_write_reg(i2c, reg, S2MU106_REG_MSG_SEND_CON_HARD_EN);
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
945 fail:
946 return -EIO;
947 }
948
949 static 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
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
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
980 static 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;
987 int i = 0;
988 int count = 0;
989 u8 send_msg[30];
990
991 pr_info("%s, \n", __func__);
992
993 /* if there is no attach, skip tx msg */
994 if (pdic_data->detach_valid)
995 goto done;
996
997 #if 0
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;
1002 #endif
1003 send_msg[0] = header->byte[0];
1004 send_msg[1] = header->byte[1];
1005
1006 count = header->num_data_objs;
1007
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];
1013 }
1014
1015 ret = s2mu106_write_msg_all(i2c, count, send_msg);
1016 if (ret < 0)
1017 goto done;
1018
1019 s2mu106_send_msg(i2c);
1020
1021 done:
1022 return ret;
1023 }
1024
1025 static 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
1047 static 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
1052 mutex_lock(&pdic_data->cc_mutex);
1053 if (val)
1054 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
1055 else
1056 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
1057 mutex_unlock(&pdic_data->cc_mutex);
1058
1059 return 0;
1060 }
1061
1062 static int s2mu106_set_cc_control(void *_data, int val)
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
1075 static int s2mu106_vbus_on_check(void *_data)
1076 {
1077 struct usbpd_data *data = (struct usbpd_data *) _data;
1078 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1079
1080 return s2mu106_usbpd_check_vbus(pdic_data, 3500, VBUS_ON);
1081 }
1082
1083 static void s2mu106_set_pwr_opmode(void *_data, int mode)
1084 {
1085 struct usbpd_data *data = (struct usbpd_data *) _data;
1086 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1087
1088 typec_set_pwr_opmode(pdic_data->port, mode);
1089 }
1090
1091 #if defined(CONFIG_CHECK_CTYPE_SIDE) || defined(CONFIG_CCIC_SYSFS)
1092 static int s2mu106_get_side_check(void *_data)
1093 {
1094 struct usbpd_data *data = (struct usbpd_data *) _data;
1095 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1096 struct i2c_client *i2c = pdic_data->i2c;
1097 u8 val, cc1_val, cc2_val;
1098
1099 s2mu106_usbpd_test_read(pdic_data);
1100
1101 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
1102
1103 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
1104 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1105
1106 if (cc1_val == USBPD_Rd)
1107 return USBPD_UP_SIDE;
1108 else if (cc2_val == USBPD_Rd)
1109 return USBPD_DOWN_SIDE;
1110 else
1111 return USBPD_UNDEFFINED_SIDE;
1112 }
1113 #endif
1114 static int s2mu106_set_vconn_source(void *_data, int val)
1115 {
1116 struct usbpd_data *data = (struct usbpd_data *) _data;
1117 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1118 struct i2c_client *i2c = pdic_data->i2c;
1119 u8 reg_data = 0, reg_val = 0, cc1_val = 0, cc2_val = 0;
1120
1121 if (!pdic_data->vconn_en) {
1122 pr_err("%s, not support vconn source\n", __func__);
1123 return -1;
1124 }
1125
1126 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &reg_val);
1127 cc1_val = (reg_val & S2MU106_REG_CTRL_MON_CC1_MASK) >> S2MU106_REG_CTRL_MON_CC1_SHIFT;
1128 cc2_val = (reg_val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1129
1130 if (val == USBPD_VCONN_ON) {
1131 if (cc1_val == USBPD_Rd) {
1132 if (cc2_val == USBPD_Ra) {
1133 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1134 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1135 reg_data |= (S2MU106_REG_PLUG_CTRL_RpRd_CC2_VCONN |
1136 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN);
1137 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1138 }
1139 }
1140 if (cc2_val == USBPD_Rd) {
1141 if (cc1_val == USBPD_Ra) {
1142 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1143 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1144 reg_data |= (S2MU106_REG_PLUG_CTRL_RpRd_CC1_VCONN |
1145 S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN);
1146 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1147 }
1148 }
1149 } else if (val == USBPD_VCONN_OFF) {
1150 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1151 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1152 reg_data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
1153 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1154 } else
1155 return(-1);
1156
1157 pdic_data->vconn_source = val;
1158 return 0;
1159 }
1160
1161 static void s2mu106_usbpd_set_vconn_manual(struct s2mu106_usbpd_data *pdic_data, bool enable)
1162 {
1163 u8 reg_data = 0;
1164
1165 s2mu106_usbpd_read_reg(pdic_data->i2c, S2MU106_REG_PLUG_CTRL_RpRd, &reg_data);
1166 reg_data &= ~S2MU106_REG_PLUG_CTRL_RpRd_VCONN_MASK;
1167
1168 if (enable)
1169 reg_data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
1170
1171 s2mu106_usbpd_write_reg(pdic_data->i2c, S2MU106_REG_PLUG_CTRL_RpRd, reg_data);
1172 }
1173
1174 static int s2mu106_get_vconn_source(void *_data, int *val)
1175 {
1176 struct usbpd_data *data = (struct usbpd_data *) _data;
1177 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1178
1179 /* TODO
1180 set s2mu106 pdic register control */
1181
1182 if (pdic_data->vconn_source != *val) {
1183 dev_info(pdic_data->dev, "%s, vconn_source(%d) != gpio val(%d)\n",
1184 __func__, pdic_data->vconn_source, *val);
1185 pdic_data->vconn_source = *val;
1186 }
1187
1188 return 0;
1189 }
1190
1191 /* val : sink(0) or source(1) */
1192 static int s2mu106_set_power_role(void *_data, int val)
1193 {
1194 struct usbpd_data *data = (struct usbpd_data *) _data;
1195 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1196
1197 pr_info("%s, power_role(%d)\n", __func__, val);
1198
1199 if (val == USBPD_SINK) {
1200 pdic_data->is_pr_swap = true;
1201 s2mu106_assert_rd(data);
1202 s2mu106_snk(pdic_data->i2c);
1203 } else if (val == USBPD_SOURCE) {
1204 pdic_data->is_pr_swap = true;
1205 s2mu106_assert_rp(data);
1206 s2mu106_src(pdic_data->i2c);
1207 } else if (val == USBPD_DRP) {
1208 pdic_data->is_pr_swap = false;
1209 s2mu106_assert_drp(data);
1210 return 0;
1211 } else
1212 return(-1);
1213
1214 pdic_data->power_role = val;
1215 return 0;
1216 }
1217
1218 static int s2mu106_get_power_role(void *_data, int *val)
1219 {
1220 struct usbpd_data *data = (struct usbpd_data *) _data;
1221 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1222
1223 *val = pdic_data->power_role;
1224
1225 return 0;
1226 }
1227
1228 static int s2mu106_set_data_role(void *_data, int val)
1229 {
1230 struct usbpd_data *data = (struct usbpd_data *) _data;
1231 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1232 struct i2c_client *i2c = pdic_data->i2c;
1233 u8 val_port, data_role;
1234
1235 /* DATA_ROLE (0x18[2])
1236 * 0 : UFP
1237 * 1 : DFP
1238 */
1239 if (val == USBPD_UFP) {
1240 data_role = S2MU106_REG_MSG_DATA_ROLE_UFP;
1241 s2mu106_ufp(i2c);
1242 } else {/* (val == USBPD_DFP) */
1243 data_role = S2MU106_REG_MSG_DATA_ROLE_DFP;
1244 s2mu106_dfp(i2c);
1245 }
1246
1247 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &val_port);
1248 val_port = (val_port & ~S2MU106_REG_MSG_DATA_ROLE_MASK) | data_role;
1249 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, val_port);
1250
1251 pdic_data->data_role = val;
1252
1253 #if defined(CONFIG_IFCONN_NOTIFIER)
1254 process_dr_swap(pdic_data);
1255 #endif
1256 return 0;
1257 }
1258
1259 static int s2mu106_get_data_role(void *_data, int *val)
1260 {
1261 struct usbpd_data *data = (struct usbpd_data *) _data;
1262 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1263 *val = pdic_data->data_role;
1264 return 0;
1265 }
1266
1267 static int s2mu106_set_check_msg_pass(void *_data, int val)
1268 {
1269 struct usbpd_data *data = (struct usbpd_data *) _data;
1270 struct s2mu106_usbpd_data *pdic_data = data->phy_driver_data;
1271
1272 dev_info(pdic_data->dev, "%s: check_msg_pass val(%d)\n", __func__, val);
1273
1274 pdic_data->check_msg_pass = val;
1275
1276 return 0;
1277 }
1278
1279 static void s2mu106_usbpd_set_threshold(struct s2mu106_usbpd_data *pdic_data,
1280 CCIC_RP_RD_SEL port_sel, CCIC_THRESHOLD_SEL threshold_sel)
1281 {
1282 struct i2c_client *i2c = pdic_data->i2c;
1283
1284 if (threshold_sel > S2MU106_THRESHOLD_MAX)
1285 dev_err(pdic_data->dev, "%s : threshold overflow!!\n", __func__);
1286 else {
1287 if (port_sel == PLUG_CTRL_RD)
1288 s2mu106_usbpd_write_reg(i2c,
1289 S2MU106_REG_PLUG_CTRL_SET_RD, threshold_sel);
1290 else if (port_sel == PLUG_CTRL_RP)
1291 s2mu106_usbpd_write_reg(i2c,
1292 S2MU106_REG_PLUG_CTRL_SET_RP, threshold_sel);
1293 }
1294 }
1295
1296 #ifndef CONFIG_SEC_FACTORY
1297 static void s2mu106_usbpd_set_rp_scr_sel(struct s2mu106_usbpd_data *pdic_data,
1298 CCIC_RP_SCR_SEL scr_sel)
1299 {
1300 struct i2c_client *i2c = pdic_data->i2c;
1301 u8 data = 0;
1302 pr_info("%s: scr_sel : (%d)\n", __func__, scr_sel);
1303 switch (scr_sel) {
1304 case PLUG_CTRL_RP0:
1305 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1306 data &= ~S2MU106_REG_PLUG_CTRL_RP_SEL_MASK;
1307 data |= S2MU106_REG_PLUG_CTRL_RP0;
1308 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1309 break;
1310 case PLUG_CTRL_RP80:
1311 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1312 data &= ~S2MU106_REG_PLUG_CTRL_RP_SEL_MASK;
1313 data |= S2MU106_REG_PLUG_CTRL_RP80;
1314 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1315 break;
1316 case PLUG_CTRL_RP180:
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_RP180;
1320 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1321 break;
1322 default:
1323 break;
1324 }
1325 return;
1326 }
1327 #endif
1328
1329 int s2mu106_usbpd_check_msg(void *_data, u64 *val)
1330 {
1331 struct usbpd_data *data = (struct usbpd_data *) _data;
1332 int data_type = 0;
1333 int msg_type = 0;
1334 int vdm_type = 0;
1335 int vdm_command = 0;
1336
1337 dev_info(data->dev, "%s\n", __func__);
1338
1339 if (data->protocol_rx.msg_header.num_data_objs == 0)
1340 data_type = USBPD_CTRL_MSG;
1341 else
1342 data_type = USBPD_DATA_MSG;
1343
1344 msg_type = data->protocol_rx.msg_header.msg_type;
1345
1346 if (data_type == USBPD_CTRL_MSG)
1347 return 0;
1348
1349 if (data_type == USBPD_DATA_MSG) {
1350 switch (msg_type) {
1351 case USBPD_Source_Capabilities:
1352 *val |= MSG_SRC_CAP;
1353 break;
1354 case USBPD_Request:
1355 *val |= MSG_REQUEST;
1356 break;
1357 case USBPD_Sink_Capabilities:
1358 *val |= MSG_SNK_CAP;
1359 break;
1360 case USBPD_BIST:
1361 *val |= MSG_BIST;
1362 break;
1363 case USBPD_Vendor_Defined:
1364 vdm_command = data->protocol_rx.data_obj[0].structured_vdm.command;
1365 vdm_type = data->protocol_rx.data_obj[0].structured_vdm.vdm_type;
1366
1367 if (vdm_type == Unstructured_VDM) {
1368 dev_info(data->dev, "%s : uvdm msg received!\n", __func__);
1369 *val |= UVDM_MSG;
1370 break;
1371 }
1372
1373 switch (vdm_command) {
1374 case DisplayPort_Status_Update:
1375 *val |= VDM_DP_STATUS_UPDATE;
1376 break;
1377 case DisplayPort_Configure:
1378 *val |= VDM_DP_CONFIGURE;
1379 break;
1380 case Attention:
1381 *val |= VDM_ATTENTION;
1382 break;
1383 case Exit_Mode:
1384 *val |= VDM_EXIT_MODE;
1385 break;
1386 case Enter_Mode:
1387 *val |= VDM_ENTER_MODE;
1388 break;
1389 case Discover_Modes:
1390 *val |= VDM_ENTER_MODE;
1391 break;
1392 case Discover_SVIDs:
1393 *val |= VDM_DISCOVER_SVID;
1394 break;
1395 case Discover_Identity:
1396 *val |= VDM_DISCOVER_IDENTITY;
1397 break;
1398 default:
1399 break;
1400 }
1401 break;
1402 default:
1403 break;
1404 }
1405 }
1406
1407 dev_info(data->dev, "%s: msg status(%lld)\n", __func__, *val);
1408
1409 return 0;
1410 }
1411
1412 static int s2mu106_usbpd_set_cc_control(struct s2mu106_usbpd_data *pdic_data, int val)
1413 {
1414 struct i2c_client *i2c = pdic_data->i2c;
1415 u8 data = 0;
1416
1417 dev_info(pdic_data->dev, "%s, (%d)\n", __func__, val);
1418
1419 if (pdic_data->detach_valid) {
1420 dev_info(pdic_data->dev, "%s, ignore cc control\n", __func__);
1421 return 0;
1422 }
1423
1424 if (val) {
1425 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &data);
1426 data &= ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK;
1427 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, data);
1428
1429 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL, &data);
1430 data |= S2MU106_REG_PLUG_CTRL_ECO_SRC_CAP_RDY;
1431 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
1432 } else {
1433 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, &data);
1434 data &= ~S2MU106_REG_PLUG_CTRL_CC_MANUAL_MASK;
1435 data |= S2MU106_REG_PLUG_CTRL_CC_MANUAL_EN;
1436 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC12, data);
1437
1438 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL, &data);
1439 data &= ~S2MU106_REG_PLUG_CTRL_ECO_SRC_CAP_RDY;
1440 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
1441 }
1442
1443 return 0;
1444 }
1445
1446 static void s2mu106_dfp(struct i2c_client *i2c)
1447 {
1448 u8 data;
1449
1450 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1451 data |= S2MU106_REG_MSG_DATA_ROLE_MASK;
1452 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1453 }
1454
1455 static void s2mu106_ufp(struct i2c_client *i2c)
1456 {
1457 u8 data;
1458 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1459 data &= ~S2MU106_REG_MSG_DATA_ROLE_MASK;
1460 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1461 }
1462
1463 static void s2mu106_src(struct i2c_client *i2c)
1464 {
1465 u8 data;
1466
1467 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1468 data = (data & ~S2MU106_REG_MSG_POWER_ROLE_MASK) | S2MU106_REG_MSG_POWER_ROLE_SOURCE;
1469 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1470 }
1471
1472 static void s2mu106_snk(struct i2c_client *i2c)
1473 {
1474 u8 data;
1475
1476 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, &data);
1477 data = (data & ~S2MU106_REG_MSG_POWER_ROLE_MASK) | S2MU106_REG_MSG_POWER_ROLE_SINK;
1478 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_MSG, data);
1479 }
1480
1481 #if defined(CONFIG_IFCONN_NOTIFIER)
1482 static void s2mu106_notify_pdic_rid(struct s2mu106_usbpd_data *pdic_data, int rid)
1483 {
1484 pdic_data->is_factory_mode = false;
1485 if (rid == RID_523K)
1486 pdic_data->is_factory_mode = true;
1487 /* rid */
1488 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
1489 IFCONN_NOTIFY_ID_RID, rid, NULL);
1490
1491 if (rid == REG_RID_523K || rid == REG_RID_619K || rid == REG_RID_OPEN) {
1492 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1493 IFCONN_NOTIFY_EVENT_ATTACH, NULL);
1494 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB,
1495 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
1496 pdic_data->is_host = HOST_OFF;
1497 pdic_data->is_client = CLIENT_OFF;
1498 } else if (rid == REG_RID_301K) {
1499 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1500 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
1501 pdic_data->is_host = HOST_OFF;
1502 pdic_data->is_client = CLIENT_ON;
1503 }
1504
1505 dev_info(pdic_data->dev, "%s : attached rid state(%d)", __func__, rid);
1506 }
1507 #endif
1508
1509 static void s2mu106_usbpd_check_rid(struct s2mu106_usbpd_data *pdic_data)
1510 {
1511 struct i2c_client *i2c = pdic_data->i2c;
1512 u8 rid;
1513 int prev_rid = pdic_data->rid;
1514
1515 msleep(200);
1516
1517 if (pdic_data->check_rid_wa)
1518 rid = REG_RID_619K;
1519 else {
1520 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_ADC_STATUS, &rid);
1521 rid = (rid & S2MU106_PDIC_RID_MASK) >> S2MU106_PDIC_RID_SHIFT;
1522 }
1523 dev_info(pdic_data->dev, "%s : attached rid state(%d)", __func__, rid);
1524
1525 if (rid) {
1526 if (pdic_data->rid != rid) {
1527 pdic_data->rid = rid;
1528 if (prev_rid >= REG_RID_OPEN && rid >= REG_RID_OPEN)
1529 dev_err(pdic_data->dev,
1530 "%s : rid is not changed, skip notify(%d)", __func__, rid);
1531 else
1532 s2mu106_notify_pdic_rid(pdic_data, rid);
1533 }
1534
1535 if (rid >= REG_RID_MAX) {
1536 dev_err(pdic_data->dev, "%s : overflow rid value", __func__);
1537 return;
1538 }
1539 }
1540 }
1541
1542 int s2mu106_set_normal_mode(struct s2mu106_usbpd_data *pdic_data)
1543 {
1544 u8 data;
1545 u8 data_lpm;
1546 int ret = 0;
1547 struct i2c_client *i2c = pdic_data->i2c;
1548 struct device *dev = &i2c->dev;
1549
1550 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1551 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1552 data |= S2MU106_REG_PLUG_CTRL_DRP | S2MU106_REG_PLUG_CTRL_RP80;
1553
1554 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1555 data_lpm &= ~S2MU106_REG_LPM_EN;
1556
1557 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1558 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1559
1560 pdic_data->lpm_mode = false;
1561
1562 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
1563 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
1564
1565 dev_info(dev, "%s s2mu106 exit lpm mode\n", __func__);
1566
1567 return ret;
1568 }
1569
1570 int s2mu106_usbpd_lpm_check(struct s2mu106_usbpd_data *pdic_data)
1571 {
1572 u8 data_lpm = 0;
1573 struct i2c_client *i2c = pdic_data->i2c;
1574
1575 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1576
1577 return (data_lpm & S2MU106_REG_LPM_EN);
1578 }
1579
1580 void s2mu106_usbpd_set_mode(struct s2mu106_usbpd_data *pdic_data,
1581 CCIC_LPM_MODE_SEL mode)
1582 {
1583 u8 data_lpm = 0;
1584 struct i2c_client *i2c = pdic_data->i2c;
1585
1586 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1587 if (mode == PD_LPM_MODE)
1588 data_lpm |= S2MU106_REG_LPM_EN;
1589 else if (mode == PD_NORMAL_MODE)
1590 data_lpm &= ~S2MU106_REG_LPM_EN;
1591 else {
1592 pr_info("%s mode val(%d) is invalid\n", __func__, mode);
1593 return;
1594 }
1595
1596 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1597 }
1598
1599 void s2mu106_usbpd_set_vbus_wakeup(struct s2mu106_usbpd_data *pdic_data,
1600 CCIC_VBUS_WAKEUP_SEL sel)
1601 {
1602 struct i2c_client *i2c = pdic_data->i2c;
1603 u8 data = 0;
1604
1605 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_TRIM, &data);
1606 if (sel == VBUS_WAKEUP_ENABLE)
1607 data &= ~S2MU106_REG_VBUS_WAKEUP_DIS;
1608 else if (sel == VBUS_WAKEUP_DISABLE)
1609 data |= S2MU106_REG_VBUS_WAKEUP_DIS;
1610 else {
1611 pr_info("%s sel val(%d) is invalid\n", __func__, sel);
1612 return;
1613 }
1614
1615 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_TRIM, data);
1616 }
1617
1618 int s2mu106_get_plug_monitor(struct s2mu106_usbpd_data *pdic_data, u8 *data)
1619 {
1620 u8 reg_val;
1621 int ret = 0;
1622 struct i2c_client *i2c = pdic_data->i2c;
1623
1624 if (&data[0] == NULL || &data[1] == NULL) {
1625 pr_err("%s NULL point data\n", __func__);
1626 return -1;
1627 }
1628
1629 ret = s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &reg_val);
1630 if (ret < 0) {
1631 pr_err("%s: S2MU106_REG_PLUG_MON1 Read err : %d\n", __func__, ret);
1632 return ret;
1633 }
1634
1635 data[0] = reg_val & S2MU106_REG_CTRL_MON_CC1_MASK;
1636 data[1] = (reg_val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
1637 pr_info("%s, water cc mon cc1 : 0x%X, cc2 : 0x%X\n", __func__, data[0], data[1]);
1638
1639 return ret;
1640 }
1641
1642 int s2mu106_set_lpm_mode(struct s2mu106_usbpd_data *pdic_data)
1643 {
1644 u8 data, data_lpm;
1645 int ret = 0;
1646 struct i2c_client *i2c = pdic_data->i2c;
1647 struct device *dev = &i2c->dev;
1648 u8 intr[S2MU106_MAX_NUM_INT_STATUS] = {0};
1649
1650 pdic_data->lpm_mode = true;
1651
1652 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1653 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1654 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP0;
1655 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1656 data_lpm |= S2MU106_REG_LPM_EN;
1657
1658 s2mu106_set_irq_enable(pdic_data, 0, 0, 0, 0, 0, 0);
1659
1660 ret = s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
1661 S2MU106_MAX_NUM_INT_STATUS, intr);
1662
1663 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1664 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1665
1666 if (pdic_data->detach_valid == false) {
1667 s2mu106_usbpd_detach_init(pdic_data);
1668 s2mu106_usbpd_notify_detach(pdic_data);
1669 }
1670
1671 dev_info(dev, "%s s2mu106 enter lpm mode\n", __func__);
1672
1673 return ret;
1674 }
1675
1676 void s2mu106_set_water_detect_pre_cond(struct s2mu106_usbpd_data *pdic_data)
1677 {
1678 int i;
1679 u8 cc_val[2] = {0,};
1680
1681 s2mu106_set_normal_mode(pdic_data);
1682 mdelay(10);
1683
1684 for (i = 0; i < 14; i++) {
1685 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1686 pr_info("%s abnormal", __func__);
1687 mdelay(10);
1688 } else {
1689 if (IS_CC_RP(cc_val[0], cc_val[1]))
1690 break;
1691 else {
1692 pr_info("%s Not Rp yet. ", __func__);
1693 mdelay(10);
1694 }
1695 }
1696 }
1697 }
1698
1699 void s2mu106_set_water_1st_detect(struct s2mu106_usbpd_data *pdic_data)
1700 {
1701 u8 data, data_lpm;
1702 struct i2c_client *i2c = pdic_data->i2c;
1703 struct device *dev = &i2c->dev;
1704
1705 pdic_data->lpm_mode = true;
1706 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP, S2MU106_THRESHOLD_MAX);
1707
1708 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
1709 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1710 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP80
1711 | S2MU106_REG_PLUG_CTRL_DETECT_BAT_DISABLE_MASK
1712 | S2MU106_REG_PLUG_CTRL_DETECT_OCP_DISABLE_MASK;
1713 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &data_lpm);
1714 data_lpm |= S2MU106_REG_LPM_EN;
1715
1716 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1717 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, data_lpm);
1718
1719 s2mu106_set_irq_enable(pdic_data, 0, 0, 0, 0, 0, 0);
1720
1721 usleep_range(500, 900);
1722
1723 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
1724 data |= S2MU106_REG_PLUG_CTRL_DFP | S2MU106_REG_PLUG_CTRL_RP0;
1725 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
1726
1727 dev_info(dev, "%s s2mu106 enter water chk lpm mode\n", __func__);
1728 }
1729
1730 static bool s2mu106_is_water_detected_2nd_seq(struct s2mu106_usbpd_data *pdic_data, u8 *cc_val)
1731 {
1732 struct i2c_client *i2c = pdic_data->i2c;
1733 u8 cc_chk[2] = {0,};
1734
1735 if (cc_val[0] == USBPD_Rp)
1736 cc_chk[0] = 1;
1737 if (cc_val[1] == USBPD_Rp)
1738 cc_chk[1] = 1;
1739
1740 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1741 S2MU106_THRESHOLD_214MV);
1742 s2mu106_set_lpm_mode(pdic_data);
1743 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1744 S2MU106_REG_LPM_EN, 0, 0);
1745 msleep(300);
1746
1747 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1748 pr_err("%s Failed to get the plug monitor.\n", __func__);
1749 return false;
1750 }
1751
1752 /* Rd is detected due to the water CAPACITOR. */
1753 if (((cc_chk[0] && !cc_chk[1]) && (cc_val[0] == USBPD_Rd)) ||
1754 ((cc_chk[1] && !cc_chk[0]) && (cc_val[1] == USBPD_Rd)) ||
1755 ((cc_chk[0] && cc_chk[1]) && ((cc_val[0] == USBPD_Rd) && (cc_val[1] == USBPD_Rd)))) {
1756 return true;
1757 }
1758
1759 return false;
1760 }
1761
1762 static void _S2MU106_PDIC_enter_to_water(struct s2mu106_usbpd_data *pdic_data)
1763 {
1764 struct i2c_client *i2c = pdic_data->i2c;
1765 #if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
1766 struct otg_notify *o_notify = get_otg_notify();
1767 #endif
1768
1769 #if defined(CONFIG_CCIC_NOTIFIER)
1770 ccic_event_work(pdic_data,
1771 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_ATTACH, 0);
1772 #endif
1773 pdic_data->is_water_detect = true;
1774 pdic_data->water_detect_cnt = 0;
1775 s2mu106_set_lpm_mode(pdic_data);
1776 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1777 S2MU106_REG_LPM_EN, 0, 0);
1778 #if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
1779 if (o_notify)
1780 inc_hw_param(o_notify, USB_CCIC_WATER_INT_COUNT);
1781 #endif
1782 }
1783
1784 static void S2MU106_PDIC_water_detect_handler(struct work_struct *work)
1785 {
1786 struct s2mu106_usbpd_data *pdic_data =
1787 container_of(work, struct s2mu106_usbpd_data, water_detect_handler.work);
1788 struct i2c_client *i2c = pdic_data->i2c;
1789
1790 u8 cc_val[2] = {0,};
1791
1792 pr_info("%s enter", __func__);
1793 mutex_lock(&pdic_data->_mutex);
1794
1795 /*
1796 * Cancel the detect handler,
1797 * in case the muic notifies cable attach or dry signal,
1798 * or the water chk cnt is over,
1799 * or ccic already detected the water.
1800 */
1801 if (!pdic_data->is_muic_water_detect
1802 || pdic_data->water_detect_cnt > WATER_CHK_RETRY_CNT
1803 || pdic_data->is_water_detect) {
1804 pr_info("%s: detect handler is canceled", __func__);
1805 goto WATER_OUT;
1806 }
1807
1808 s2mu106_set_water_detect_pre_cond(pdic_data);
1809 s2mu106_set_water_1st_detect(pdic_data);
1810 msleep(400);
1811
1812 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1813 pr_err("%s Failed to get the plug monitor.\n", __func__);
1814 goto WATER_MODE_OUT;
1815 }
1816
1817 if (IS_CC_WATER(cc_val[0], cc_val[1])) {
1818 pr_info("%s, water is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1819 __func__, cc_val[0], cc_val[1]);
1820 _S2MU106_PDIC_enter_to_water(pdic_data);
1821 goto WATER_MODE_OUT;
1822 } else {
1823 pr_info("%s, 1st chk is not water, cc1 : 0x%X, cc2 : 0x%X\n",
1824 __func__, cc_val[0], cc_val[1]);
1825 if (s2mu106_is_water_detected_2nd_seq(pdic_data, cc_val)) {
1826 pr_info("%s, 2nd seq, water is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1827 __func__, cc_val[0], cc_val[1]);
1828 _S2MU106_PDIC_enter_to_water(pdic_data);
1829 goto WATER_MODE_OUT;
1830 }
1831
1832 pr_info("%s, 2nd chk : not water, cc1 : 0x%X, cc2 : 0x%X\n",
1833 __func__, cc_val[0], cc_val[1]);
1834
1835 if (pdic_data->water_detect_cnt++ >= WATER_CHK_RETRY_CNT) {
1836 pdic_data->is_water_detect = false;
1837 pdic_data->water_detect_cnt = 0;
1838 #if defined(CONFIG_CCIC_NOTIFIER)
1839 ccic_event_work(pdic_data,
1840 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
1841 #endif
1842 } else {
1843 /*
1844 * Retry the cc check,
1845 * in case of invalid status.
1846 * (200ms interval + 175ms check duration) * 5 times
1847 */
1848 cancel_delayed_work(&pdic_data->water_detect_handler);
1849 schedule_delayed_work(&pdic_data->water_detect_handler,
1850 msecs_to_jiffies(S2MU106_WATER_CHK_INTERVAL_TIME));
1851 }
1852 }
1853 WATER_MODE_OUT:
1854 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1855 S2MU106_THRESHOLD_428MV);
1856 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP,
1857 S2MU106_THRESHOLD_2057MV);
1858 WATER_OUT:
1859 mutex_unlock(&pdic_data->_mutex);
1860 return;
1861 }
1862
1863 static void S2MU106_PDIC_water_dry_handler(struct work_struct *work)
1864 {
1865 struct s2mu106_usbpd_data *pdic_data =
1866 container_of(work, struct s2mu106_usbpd_data, water_dry_handler.work);
1867 struct i2c_client *i2c = pdic_data->i2c;
1868 u8 cc_val[2] = {0,};
1869
1870 pr_info("%s enter", __func__);
1871 mutex_lock(&pdic_data->_mutex);
1872
1873 s2mu106_set_water_detect_pre_cond(pdic_data);
1874 s2mu106_set_water_1st_detect(pdic_data);
1875 msleep(400);
1876
1877 if (s2mu106_get_plug_monitor(pdic_data, cc_val) < 0) {
1878 pr_err("%s Failed to get the plug monitor.\n", __func__);
1879 }
1880
1881 if (IS_CC_RP(cc_val[0], cc_val[1])) {
1882 pr_info("%s, 1st, water DRY is detected, cc1 : 0x%X, cc2 : 0x%X\n",
1883 __func__, cc_val[0], cc_val[1]);
1884
1885 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD,
1886 S2MU106_THRESHOLD_428MV);
1887 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP,
1888 S2MU106_THRESHOLD_2057MV);
1889 #if defined(CONFIG_CCIC_NOTIFIER)
1890 ccic_event_work(pdic_data,
1891 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
1892 #endif
1893 } else {
1894 pr_info("%s, It is not DRIED yet, cc1 : 0x%X, cc2 : 0x%X\n",
1895 __func__, cc_val[0], cc_val[1]);
1896
1897 #if defined(CONFIG_CCIC_NOTIFIER)
1898 ccic_event_work(pdic_data,
1899 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_ATTACH, 0);
1900 #endif
1901 s2mu106_set_lpm_mode(pdic_data);
1902 s2mu106_usbpd_update_bit(i2c, S2MU106_REG_PD_CTRL,
1903 S2MU106_REG_LPM_EN, 0, 0);
1904 }
1905
1906 mutex_unlock(&pdic_data->_mutex);
1907 return;
1908 }
1909
1910 static void s2mu106_usbpd_otg_attach(struct s2mu106_usbpd_data *pdic_data)
1911 {
1912 struct i2c_client *i2c = pdic_data->i2c;
1913 struct device *dev = &i2c->dev;
1914
1915 /* otg */
1916 pdic_data->is_host = HOST_ON;
1917 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
1918 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SRC;
1919 #elif defined(CONFIG_TYPEC)
1920 pdic_data->typec_power_role = TYPEC_SOURCE;
1921 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
1922 #endif
1923 #if defined(CONFIG_IFCONN_NOTIFIER)
1924 /* USB */
1925 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
1926 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP, NULL);
1927 #endif
1928 #ifdef CONFIG_PM_S2MU106
1929 s2mu106_usbpd_check_vbus(pdic_data, 80, VBUS_OFF);
1930 #endif
1931 /* add to turn on external 5V */
1932 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
1933
1934 usbpd_manager_acc_handler_cancel(dev);
1935 }
1936
1937 #if defined(CONFIG_MUIC_NOTIFIER)
1938 static int type3_handle_notification(struct notifier_block *nb,
1939 unsigned long action, void *data)
1940 {
1941 #if defined(CONFIG_CCIC_NOTIFIER)
1942 CC_NOTI_ATTACH_TYPEDEF *p_noti = (CC_NOTI_ATTACH_TYPEDEF *)data;
1943 muic_attached_dev_t attached_dev = p_noti->cable_type;
1944 #else
1945 muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data;
1946 #endif
1947 struct s2mu106_usbpd_data *pdic_data =
1948 container_of(nb, struct s2mu106_usbpd_data,
1949 type3_nb);
1950 struct i2c_client *i2c = pdic_data->i2c;
1951 u8 reg_data = 0;
1952
1953 #if (defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)) || \
1954 (!defined(CONFIG_SEC_FACTORY) && defined(CONFIG_USB_HOST_NOTIFY))
1955 struct otg_notify *o_notify = get_otg_notify();
1956 #endif
1957 mutex_lock(&pdic_data->lpm_mutex);
1958 pr_info("%s action:%d, attached_dev:%d, lpm:%d, pdic_data->is_otg_vboost:%d, pdic_data->is_otg_reboost:%d\n",
1959 __func__, (int)action, (int)attached_dev, pdic_data->lpm_mode,
1960 (int)pdic_data->is_otg_vboost, (int)pdic_data->is_otg_reboost);
1961
1962 if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1963 (attached_dev == ATTACHED_DEV_TYPE3_MUIC)) {
1964 pdic_data->is_muic_water_detect = false;
1965 pdic_data->water_detect_cnt = 0;
1966 if (pdic_data->lpm_mode) {
1967 pr_info("%s try to exit lpm mode-->\n", __func__);
1968 s2mu106_set_normal_mode(pdic_data);
1969 pr_info("%s after exit lpm mode<--\n", __func__);
1970 }
1971 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1972 attached_dev == ATTACHED_DEV_CHK_WATER_REQ) {
1973 pr_info("%s, ATTACH : MUIC REQUESTED WATER CHECK\n", __func__);
1974 s2mu106_usbpd_set_vconn_manual(pdic_data, true);
1975 pdic_data->is_muic_water_detect = true;
1976 pdic_data->water_detect_cnt = 0;
1977 pdic_data->is_water_detect = false;
1978 cancel_delayed_work(&pdic_data->water_detect_handler);
1979 schedule_delayed_work(&pdic_data->water_detect_handler, msecs_to_jiffies(100));
1980 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1981 attached_dev == ATTACHED_DEV_CHK_WATER_DRY_REQ) {
1982 pr_info("%s, ATTACH : MUIC REQUESTED WATER DRY CHECK\n", __func__);
1983 cancel_delayed_work(&pdic_data->water_dry_handler);
1984 schedule_delayed_work(&pdic_data->water_dry_handler, msecs_to_jiffies(100));
1985 } else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH) &&
1986 attached_dev == ATTACHED_DEV_OTG_MUIC) {
1987 s2mu106_usbpd_otg_attach(pdic_data);
1988 } else if ((action == MUIC_PDIC_NOTIFY_CMD_DETACH) &&
1989 attached_dev == ATTACHED_DEV_UNDEFINED_RANGE_MUIC) {
1990 pr_info("%s, DETACH : ATTACHED_DEV_UNDEFINED_RANGE_MUIC(Water DRY)\n", __func__);
1991 pdic_data->is_muic_water_detect = false;
1992 pdic_data->water_detect_cnt = 0;
1993 pdic_data->is_water_detect = false;
1994 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL, &reg_data);
1995 reg_data |= S2MU106_REG_LPM_EN;
1996 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL, reg_data);
1997 #if defined(CONFIG_USB_HW_PARAM) && !defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
1998 if (o_notify)
1999 inc_hw_param(o_notify, USB_CCIC_DRY_INT_COUNT);
2000 #endif
2001 #if defined(CONFIG_CCIC_NOTIFIER)
2002 ccic_event_work(pdic_data,
2003 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_WATER, CCIC_NOTIFY_DETACH, 0);
2004 #endif
2005 } else if (action == MUIC_PDIC_NOTIFY_CMD_DETACH) {
2006 if (!pdic_data->lpm_mode) {
2007 pr_info("%s try to enter lpm mode-->\n", __func__);
2008 s2mu106_set_lpm_mode(pdic_data);
2009 pr_info("%s after enter lpm mode<--\n", __func__);
2010 }
2011 }
2012 #if !defined(CONFIG_SEC_FACTORY) && defined(CONFIG_USB_HOST_NOTIFY)
2013 else if ((action == MUIC_PDIC_NOTIFY_CMD_ATTACH)
2014 && (attached_dev == ATTACHED_DEV_CHECK_OCP)
2015 && pdic_data->is_otg_vboost
2016 && pdic_data->data_role_dual ==
2017 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP) {
2018 if (o_notify) {
2019 if (is_blocked(o_notify, NOTIFY_BLOCK_TYPE_HOST)) {
2020 pr_info("%s, upsm mode, skip OCP handling\n", __func__);
2021 goto EOH;
2022 }
2023 }
2024 if (pdic_data->is_otg_reboost) {
2025 /* todo : over current event to platform */
2026 pr_info("%s, CHECK_OCP, Can't afford it(OVERCURRENT)\n", __func__);
2027 if (o_notify)
2028 send_otg_notify(o_notify, NOTIFY_EVENT_OVERCURRENT, 0);
2029 goto EOH;
2030 }
2031 ccic_event_work(pdic_data,
2032 CCIC_NOTIFY_DEV_MUIC, CCIC_NOTIFY_ID_ATTACH, 1/*attach*/, 1/*rprd*/);
2033
2034 pr_info("%s, CHECK_OCP, start OCP W/A\n", __func__);
2035 pdic_data->is_otg_reboost = true;
2036 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &reg_data);
2037 reg_data |= S2MU106_REG_PLUG_CTRL_CC_HOLD_BIT;
2038 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, reg_data);
2039
2040 s2mu106_usbpd_set_rp_scr_sel(pdic_data, PLUG_CTRL_RP80);
2041 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2042 vbus_turn_on_ctrl(pdic_data, VBUS_ON);
2043
2044 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &reg_data);
2045 reg_data &= ~S2MU106_REG_PLUG_CTRL_CC_HOLD_BIT;
2046 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, reg_data);
2047 }
2048 EOH:
2049 #endif
2050 mutex_unlock(&pdic_data->lpm_mutex);
2051
2052 return 0;
2053 }
2054 #endif
2055
2056 static void s2mu106_usbpd_prevent_watchdog_reset(
2057 struct s2mu106_usbpd_data *pdic_data)
2058 {
2059 struct i2c_client *i2c = pdic_data->i2c;
2060 u8 val = 0;
2061
2062 mutex_lock(&pdic_data->lpm_mutex);
2063 wake_lock(&pdic_data->wake_lock);
2064 if (!pdic_data->lpm_mode) {
2065 if (s2mu106_usbpd_lpm_check(pdic_data) == 0) {
2066 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2067 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2068 pr_info("%s force to lpm mode\n", __func__);
2069 s2mu106_usbpd_set_mode(pdic_data, PD_LPM_MODE);
2070 /* enable wakeup to check prevent function */
2071 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2072 ENABLED_INT_2_WAKEUP, ENABLED_INT_3, ENABLED_INT_4,
2073 ENABLED_INT_5);
2074 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
2075 usleep_range(1000, 1200);
2076 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2077 if (val & S2MU106_REG_INT_STATUS2_WAKEUP)
2078 pr_info("%s auto wakeup success\n", __func__);
2079 else {
2080 msleep(22);
2081 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2082 usleep_range(1000, 1200);
2083 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
2084 usleep_range(1000, 1200);
2085 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_INT_STATUS2, &val);
2086 if (val & S2MU106_REG_INT_STATUS2_WAKEUP)
2087 pr_info("%s auto wakeup success\n", __func__);
2088 else
2089 s2mu106_usbpd_set_mode(pdic_data, PD_NORMAL_MODE);
2090 }
2091
2092 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2093 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4,
2094 ENABLED_INT_5);
2095 }
2096 }
2097 wake_unlock(&pdic_data->wake_lock);
2098 mutex_unlock(&pdic_data->lpm_mutex);
2099 }
2100
2101 static int s2mu106_usbpd_check_abnormal_attach(struct s2mu106_usbpd_data *pdic_data)
2102 {
2103 struct i2c_client *i2c = pdic_data->i2c;
2104 u8 data = 0;
2105
2106 s2mu106_usbpd_set_threshold(pdic_data, PLUG_CTRL_RP,
2107 S2MU106_THRESHOLD_1285MV);
2108 msleep(20);
2109
2110 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2111 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE)
2112 return true;
2113 else
2114 return false;
2115 }
2116
2117 static void s2mu106_usbpd_rp_current_check(struct s2mu106_usbpd_data *pdic_data)
2118 {
2119 struct i2c_client *i2c = pdic_data->i2c;
2120 struct device *dev = pdic_data->dev;
2121 u8 val = 0;
2122 u8 cc1_val = 0, cc2_val = 0;
2123 u8 rp_currentlvl = 0;
2124
2125 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_FSM_MON, &val);
2126
2127 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
2128 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
2129
2130 dev_info(dev, "%s, rp check : cc1_val(%x), cc2_val(%x)\n",
2131 __func__, cc1_val, cc2_val);
2132
2133 if (cc1_val == USBPD_10k || cc2_val == USBPD_10k)
2134 rp_currentlvl = RP_CURRENT_LEVEL3;
2135 else if (cc1_val == USBPD_22k || cc2_val == USBPD_22k)
2136 rp_currentlvl = RP_CURRENT_LEVEL2;
2137 else if (cc1_val == USBPD_56k || cc2_val == USBPD_56k)
2138 rp_currentlvl = RP_CURRENT_LEVEL_DEFAULT;
2139
2140 pd_noti.sink_status.rp_currentlvl = rp_currentlvl;
2141 pd_noti.event = IFCONN_NOTIFY_EVENT_RP_ATTACH;
2142 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MANAGER,
2143 IFCONN_NOTIFY_ID_POWER_STATUS, IFCONN_NOTIFY_EVENT_ATTACH, &pd_noti);
2144 }
2145
2146 static void s2mu106_usbpd_detach_init(struct s2mu106_usbpd_data *pdic_data)
2147 {
2148 struct device *dev = pdic_data->dev;
2149 struct usbpd_data *pd_data = dev_get_drvdata(dev);
2150 int ret = 0;
2151
2152 dev_info(dev, "%s\n", __func__);
2153
2154 mutex_lock(&pdic_data->cc_mutex);
2155 s2mu106_usbpd_set_cc_control(pdic_data, USBPD_CC_OFF);
2156 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2157 if (pdic_data->power_role_dual == DUAL_ROLE_PROP_PR_SRC) {
2158 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2159 }
2160 #elif defined(CONFIG_TYPEC)
2161 if (pdic_data->typec_power_role == TYPEC_SOURCE) {
2162 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2163 }
2164 pd_data->pd_support = 0;
2165 #endif
2166 pdic_data->detach_valid = true;
2167 mutex_unlock(&pdic_data->cc_mutex);
2168 usbpd_manager_plug_detach(dev, 0);
2169
2170 /* wait flushing policy engine work */
2171 usbpd_cancel_policy_work(dev);
2172 s2mu106_self_soft_reset(pdic_data->i2c);
2173
2174 pdic_data->status_reg = 0;
2175 usbpd_reinit(dev);
2176 pdic_data->rid = REG_RID_MAX;
2177 pdic_data->check_rid_wa = false;
2178 pdic_data->is_factory_mode = false;
2179 pdic_data->is_pr_swap = false;
2180 if (pdic_data->regulator_en)
2181 ret = regulator_disable(pdic_data->regulator);
2182 #ifdef CONFIG_BATTERY_SAMSUNG
2183 #ifdef CONFIG_USB_TYPEC_MANAGER_NOTIFIER
2184 pd_noti.sink_status.current_pdo_num = 0;
2185 pd_noti.sink_status.selected_pdo_num = 0;
2186 pd_noti.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_NONE;
2187 #endif
2188 #endif
2189 s2mu106_usbpd_reg_init(pdic_data);
2190 s2mu106_set_vconn_source(pd_data, USBPD_VCONN_OFF);
2191 }
2192
2193 static void s2mu106_usbpd_notify_detach(struct s2mu106_usbpd_data *pdic_data)
2194 {
2195 struct device *dev = pdic_data->dev;
2196 #if defined(CONFIG_IFCONN_NOTIFIER)
2197 /* MUIC */
2198 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC, IFCONN_NOTIFY_ID_ATTACH,
2199 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2200
2201 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC, IFCONN_NOTIFY_ID_RID,
2202 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2203
2204 if (pdic_data->is_host > HOST_OFF || pdic_data->is_client > CLIENT_OFF) {
2205 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2206 if (pdic_data->is_host > HOST_OFF ||
2207 pdic_data->power_role_dual == DUAL_ROLE_PROP_PR_SRC) {
2208 #else
2209 if (pdic_data->is_host > HOST_OFF) {
2210 #endif
2211 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2212 }
2213 usbpd_manager_acc_detach(dev);
2214 /* usb or otg */
2215 dev_info(dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2216 __LINE__, pdic_data->is_host, pdic_data->is_client);
2217 pdic_data->is_host = HOST_OFF;
2218 pdic_data->is_client = CLIENT_OFF;
2219 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2220 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
2221 #elif defined(CONFIG_TYPEC)
2222 if (pdic_data->partner) {
2223 pr_info("%s, %d\n", __func__, __LINE__);
2224 if (!IS_ERR(pdic_data->partner)) {
2225 typec_unregister_partner(pdic_data->partner);
2226 pdic_data->partner = NULL;
2227 }
2228 }
2229 pdic_data->typec_power_role = TYPEC_SINK;
2230 pdic_data->typec_data_role = TYPEC_DEVICE;
2231 #endif
2232 /* USB */
2233 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2234 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2235 }
2236 #else
2237 usbpd_manager_plug_detach(dev, 1);
2238 #endif
2239 }
2240 #ifdef CONFIG_CCIC_TRY_SNK
2241 static void s2mu106_usbpd_try_snk(struct s2mu106_usbpd_data *pdic_data)
2242 {
2243 struct device *dev = pdic_data->dev;
2244 struct i2c_client *i2c = pdic_data->i2c;
2245 u8 data;
2246 u8 intr[S2MU106_MAX_NUM_INT_STATUS] = {0};
2247
2248 dev_info(dev, "%s\n", __func__);
2249
2250 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
2251 data &= ~S2MU106_REG_PLUG_CTRL_MODE_MASK;
2252 data |= S2MU106_REG_PLUG_CTRL_UFP;
2253 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2254
2255 msleep(250);
2256
2257 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2258 if ((data & S2MU106_PR_MASK) != S2MU106_PDIC_SINK) {
2259 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
2260 data &= ~S2MU106_REG_PLUG_CTRL_MODE_MASK;
2261 data |= S2MU106_REG_PLUG_CTRL_DFP;
2262 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2263
2264 msleep(200);
2265 }
2266
2267 s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
2268 S2MU106_MAX_NUM_INT_STATUS, intr);
2269 }
2270 #endif
2271 static void s2mu106_usbpd_check_host(struct s2mu106_usbpd_data *pdic_data,
2272 CCIC_HOST_REASON host)
2273 {
2274 if (host == HOST_ON && pdic_data->is_host == HOST_ON) {
2275 dev_info(pdic_data->dev, "%s %d: turn off host\n", __func__, __LINE__);
2276 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2277 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2278 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2279 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
2280 #elif defined(CONFIG_TYPEC)
2281 pdic_data->typec_power_role = TYPEC_SINK;
2282 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
2283 #endif
2284 /* add to turn off external 5V */
2285 vbus_turn_on_ctrl(pdic_data, VBUS_OFF);
2286 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2287 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2288 pdic_data->is_host = HOST_OFF;
2289 msleep(300);
2290 } else if (host == HOST_OFF && pdic_data->is_host == HOST_OFF) {
2291 /* muic */
2292 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2293 IFCONN_NOTIFY_ID_OTG, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
2294 s2mu106_usbpd_otg_attach(pdic_data);
2295 }
2296 }
2297
2298 static void s2mu106_usbpd_check_client(struct s2mu106_usbpd_data *pdic_data,
2299 CCIC_DEVICE_REASON client)
2300 {
2301 if (client == CLIENT_ON && pdic_data->is_client == CLIENT_ON) {
2302 dev_info(pdic_data->dev, "%s %d: turn off client\n", __func__, __LINE__);
2303 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2304 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2305 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2306 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_NONE;
2307 #elif defined(CONFIG_TYPEC)
2308 pdic_data->typec_power_role = TYPEC_SINK;
2309 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
2310 #endif
2311 ifconn_event_work(pdic_data, IFCONN_NOTIFY_USB,
2312 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2313 pdic_data->is_client = CLIENT_OFF;
2314 }
2315 }
2316
2317 static int s2mu106_check_port_detect(struct s2mu106_usbpd_data *pdic_data)
2318 {
2319 struct i2c_client *i2c = pdic_data->i2c;
2320 struct device *dev = &i2c->dev;
2321 struct usbpd_data *pd_data = dev_get_drvdata(dev);
2322 u8 data, val;
2323 u8 cc1_val = 0, cc2_val = 0;
2324 int ret = 0;
2325
2326 ret = s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2327 if (ret < 0)
2328 dev_err(dev, "%s, i2c read PLUG_MON2 error\n", __func__);
2329
2330 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON1, &val);
2331
2332 cc1_val = val & S2MU106_REG_CTRL_MON_CC1_MASK;
2333 cc2_val = (val & S2MU106_REG_CTRL_MON_CC2_MASK) >> S2MU106_REG_CTRL_MON_CC2_SHIFT;
2334
2335 pdic_data->cc1_val = cc1_val;
2336 pdic_data->cc2_val = cc2_val;
2337
2338 dev_info(dev, "%s, attach cc pin check cc1_val(%x), cc2_val(%x)\n",
2339 __func__, cc1_val, cc2_val);
2340
2341 #ifdef CONFIG_CCIC_DP
2342 if (cc1_val == USBPD_Rd)
2343 gpio_direction_output(pdic_data->usb_sw_sel, 1);
2344 else if (cc2_val == USBPD_Rd)
2345 gpio_direction_output(pdic_data->usb_sw_sel, 0);
2346 #endif
2347 #ifdef CONFIG_CCIC_TRY_SNK
2348 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE) {
2349 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2350 if (!pdic_data->try_state_change) {
2351 s2mu106_usbpd_try_snk(pdic_data);
2352 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2353 }
2354 #else
2355 s2mu106_usbpd_try_snk(pdic_data);
2356 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_MON2, &data);
2357 #endif
2358 }
2359 #endif
2360 if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SINK) {
2361 dev_info(dev, "SINK\n");
2362 pdic_data->detach_valid = false;
2363 pdic_data->power_role = PDIC_SINK;
2364 pdic_data->data_role = USBPD_UFP;
2365 s2mu106_snk(i2c);
2366 s2mu106_ufp(i2c);
2367 s2mu106_usbpd_prevent_watchdog_reset(pdic_data);
2368 usbpd_policy_reset(pd_data, PLUG_EVENT);
2369 #if defined(CONFIG_IFCONN_NOTIFIER)
2370 dev_info(&i2c->dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2371 __LINE__, pdic_data->is_host, pdic_data->is_client);
2372 if (pdic_data->regulator_en) {
2373 ret = regulator_enable(pdic_data->regulator);
2374 if (ret)
2375 dev_err(&i2c->dev, "Failed to enable vconn LDO: %d\n", ret);
2376 }
2377
2378 s2mu106_usbpd_check_host(pdic_data, HOST_ON);
2379 /* muic */
2380 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2381 IFCONN_NOTIFY_ID_ATTACH, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
2382 ifconn_event_work(pdic_data, IFCONN_NOTIFY_MUIC,
2383 IFCONN_NOTIFY_ID_TA, IFCONN_NOTIFY_EVENT_ATTACH, NULL);
2384 if (!(pdic_data->rid == REG_RID_523K || pdic_data->rid == REG_RID_619K)) {
2385 if (pdic_data->is_client == CLIENT_OFF && pdic_data->is_host == HOST_OFF) {
2386 /* usb */
2387 pdic_data->is_client = CLIENT_ON;
2388 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
2389 pdic_data->power_role_dual = DUAL_ROLE_PROP_PR_SNK;
2390 #elif defined(CONFIG_TYPEC)
2391 pdic_data->typec_power_role = TYPEC_SINK;
2392 typec_set_pwr_role(pdic_data->port, pdic_data->typec_power_role);
2393 #endif
2394 ifconn_event_work(pdic_data,
2395 IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2396 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
2397 }
2398 }
2399 #endif
2400 s2mu106_usbpd_rp_current_check(pdic_data);
2401 } else if ((data & S2MU106_PR_MASK) == S2MU106_PDIC_SOURCE) {
2402 dev_info(dev, "SOURCE\n");
2403 ret = s2mu106_usbpd_check_abnormal_attach(pdic_data);
2404 if (ret == false) {
2405 dev_err(&i2c->dev, "%s, abnormal attach\n", __func__);
2406 return -1;
2407 }
2408 s2mu106_usbpd_set_rp_scr_sel(pdic_data, PLUG_CTRL_RP180);
2409 ret = s2mu106_usbpd_check_accessory(pdic_data);
2410 if (ret < 0) {
2411 dev_info(&i2c->dev, "%s attach accessory\n", __func__);
2412 return -1;
2413 }
2414 pdic_data->detach_valid = false;
2415 pdic_data->power_role = PDIC_SOURCE;
2416 pdic_data->data_role = USBPD_DFP;
2417 s2mu106_dfp(i2c);
2418 s2mu106_src(i2c);
2419 usbpd_policy_reset(pd_data, PLUG_EVENT);
2420 #if defined(CONFIG_IFCONN_NOTIFIER)
2421 dev_info(&i2c->dev, "%s %d: is_host = %d, is_client = %d\n", __func__,
2422 __LINE__, pdic_data->is_host, pdic_data->is_client);
2423 s2mu106_usbpd_check_client(pdic_data, CLIENT_ON);
2424 s2mu106_usbpd_check_host(pdic_data, HOST_OFF);
2425 #endif
2426 if (pdic_data->regulator_en) {
2427 ret = regulator_enable(pdic_data->regulator);
2428 if (ret)
2429 dev_err(&i2c->dev, "Failed to enable vconn LDO: %d\n", ret);
2430 }
2431
2432 msleep(100);
2433 } else {
2434 dev_err(dev, "%s, PLUG Error\n", __func__);
2435 #ifdef CONFIG_CCIC_TRY_SNK
2436 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, &data);
2437 data &= ~(S2MU106_REG_PLUG_CTRL_MODE_MASK | S2MU106_REG_PLUG_CTRL_RP_SEL_MASK);
2438 data |= S2MU106_REG_PLUG_CTRL_DRP | S2MU106_REG_PLUG_CTRL_RP80;
2439 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_PORT, data);
2440 #endif
2441 return -1;
2442 }
2443
2444 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2445 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
2446
2447 return ret;
2448 }
2449
2450 #if defined(CONFIG_SEC_FACTORY)
2451 static int s2mu106_usbpd_check_619k(struct s2mu106_usbpd_data *pdic_data)
2452 {
2453 u8 rid = 0;
2454
2455 if (pdic_data->rid != REG_RID_619K)
2456 return false;
2457
2458 msleep(250);
2459 s2mu106_usbpd_read_reg(pdic_data->i2c, S2MU106_REG_ADC_STATUS, &rid);
2460 rid = (rid & S2MU106_PDIC_RID_MASK) >> S2MU106_PDIC_RID_SHIFT;
2461 dev_info(pdic_data->dev, "%s %d: Detached, check if still 619K? => 0x%X\n",
2462 __func__, __LINE__, rid);
2463
2464 if (rid == REG_RID_619K)
2465 return true;
2466 return false;
2467 }
2468 #endif
2469
2470 static irqreturn_t s2mu106_irq_thread(int irq, void *data)
2471 {
2472 struct s2mu106_usbpd_data *pdic_data = data;
2473 struct i2c_client *i2c = pdic_data->i2c;
2474 struct device *dev = &i2c->dev;
2475 struct usbpd_data *pd_data = dev_get_drvdata(dev);
2476 int ret = 0;
2477 unsigned attach_status = 0, rid_status = 0;
2478
2479 dev_info(dev, "%s\n", __func__);
2480
2481 mutex_lock(&pd_data->accept_mutex);
2482 mutex_unlock(&pd_data->accept_mutex);
2483
2484 mutex_lock(&pdic_data->_mutex);
2485
2486 s2mu106_poll_status(pd_data);
2487
2488 #ifndef CONFIG_SEC_FACTORY
2489 if (pdic_data->lpcharge_water)
2490 goto out;
2491 #endif
2492
2493 if (pdic_data->status_reg == 0)
2494 goto out;
2495
2496 if (s2mu106_get_status(pd_data, MSG_SOFTRESET))
2497 usbpd_rx_soft_reset(pd_data);
2498
2499 if (s2mu106_get_status(pd_data, PLUG_DETACH)) {
2500 #if defined(CONFIG_SEC_FACTORY)
2501 ret = s2mu106_usbpd_check_619k(pdic_data);
2502 if (ret)
2503 goto skip_detach;
2504 #endif /* CONFIG_SEC_FACTORY */
2505 s2mu106_usbpd_set_rp_scr_sel(pdic_data, PLUG_CTRL_RP80);
2506 attach_status = s2mu106_get_status(pd_data, PLUG_ATTACH);
2507 rid_status = s2mu106_get_status(pd_data, MSG_RID);
2508 s2mu106_usbpd_detach_init(pdic_data);
2509 s2mu106_usbpd_notify_detach(pdic_data);
2510 if (attach_status) {
2511 ret = s2mu106_check_port_detect(pdic_data);
2512 if (ret >= 0) {
2513 if (rid_status) {
2514 pdic_data->check_rid_wa = true;
2515 s2mu106_usbpd_check_rid(pdic_data);
2516 }
2517 goto hard_reset;
2518 }
2519 }
2520 #if 0
2521 mutex_lock(&pdic_data->lpm_mutex);
2522 if (!pdic_data->lpm_mode) {
2523 if (s2mu106_usbpd_lpm_check(pdic_data) > 0) {
2524 pr_info("%s force to normal mode\n", __func__);
2525 s2mu106_usbpd_set_mode(pdic_data, PD_NORMAL_MODE);
2526 }
2527 s2mu106_set_irq_enable(pdic_data, ENABLED_INT_0, ENABLED_INT_1,
2528 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
2529 }
2530 mutex_unlock(&pdic_data->lpm_mutex);
2531 #endif
2532 goto out;
2533 }
2534
2535 if (s2mu106_get_status(pd_data, MSG_HARDRESET)) {
2536 mutex_lock(&pdic_data->cc_mutex);
2537 s2mu106_usbpd_set_cc_control(pdic_data, USBPD_CC_OFF);
2538 mutex_unlock(&pdic_data->cc_mutex);
2539 s2mu106_self_soft_reset(i2c);
2540 pdic_data->status_reg = 0;
2541 if (pdic_data->power_role == PDIC_SOURCE)
2542 s2mu106_dfp(i2c);
2543 else
2544 s2mu106_ufp(i2c);
2545 usbpd_rx_hard_reset(dev);
2546 usbpd_kick_policy_work(dev);
2547 goto out;
2548 }
2549
2550 #if defined(CONFIG_SEC_FACTORY)
2551 skip_detach:
2552 #endif /* CONFIG_SEC_FACTORY */
2553 if (s2mu106_get_status(pd_data, PLUG_ATTACH) && !pdic_data->is_pr_swap) {
2554 if (s2mu106_check_port_detect(data) < 0)
2555 goto out;
2556 }
2557
2558 if (s2mu106_get_status(pd_data, MSG_RID)) {
2559 pdic_data->check_rid_wa = true;
2560 s2mu106_usbpd_check_rid(pdic_data);
2561 }
2562
2563 hard_reset:
2564 mutex_lock(&pdic_data->lpm_mutex);
2565 if (!pdic_data->lpm_mode)
2566 usbpd_kick_policy_work(dev);
2567 mutex_unlock(&pdic_data->lpm_mutex);
2568 out:
2569 mutex_unlock(&pdic_data->_mutex);
2570
2571 return IRQ_HANDLED;
2572 }
2573
2574 static void s2mu106_usbpd_plug_work(struct work_struct *work)
2575 {
2576 struct s2mu106_usbpd_data *pdic_data =
2577 container_of(work, struct s2mu106_usbpd_data, plug_work.work);
2578
2579 s2mu106_irq_thread(-1, pdic_data);
2580 }
2581
2582 static void s2mu106_usbpd_dr_work(struct work_struct *work)
2583 {
2584 struct s2mu106_usbpd_data *usbpd_data =
2585 container_of(work, struct s2mu106_usbpd_data, dr_work.work);
2586 struct i2c_client *i2c = usbpd_data->i2c;
2587
2588 dev_info(&i2c->dev, "%s : before - is_host : %d, is_client : %d\n",
2589 __func__, usbpd_data->is_host, usbpd_data->is_client);
2590 if (usbpd_data->is_host == HOST_ON) {
2591 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB,
2592 IFCONN_NOTIFY_ID_USB, IFCONN_NOTIFY_EVENT_DETACH, NULL);
2593
2594 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2595 IFCONN_NOTIFY_EVENT_USB_ATTACH_UFP, NULL);
2596 usbpd_data->is_host = HOST_OFF;
2597 usbpd_data->is_client = CLIENT_ON;
2598 } else if (usbpd_data->is_client == CLIENT_ON) {
2599 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2600 IFCONN_NOTIFY_EVENT_DETACH, NULL);
2601
2602 ifconn_event_work(usbpd_data, IFCONN_NOTIFY_USB, IFCONN_NOTIFY_ID_USB,
2603 IFCONN_NOTIFY_EVENT_USB_ATTACH_DFP, NULL);
2604 usbpd_data->is_host = HOST_ON;
2605 usbpd_data->is_client = CLIENT_OFF;
2606 }
2607 dev_info(&i2c->dev, "%s : after - is_host : %d, is_client : %d\n",
2608 __func__, usbpd_data->is_host, usbpd_data->is_client);
2609 }
2610
2611 static int s2mu106_usbpd_get_property(struct power_supply *psy,
2612 enum power_supply_property psp,
2613 union power_supply_propval *val)
2614 {
2615 switch (psp) {
2616 case POWER_SUPPLY_PROP_AUTHENTIC:
2617 break;
2618 default:
2619 return -EINVAL;
2620 }
2621
2622 return 0;
2623 }
2624
2625 static int s2mu106_usbpd_set_property(struct power_supply *psy,
2626 enum power_supply_property psp,
2627 const union power_supply_propval *val)
2628 {
2629 struct s2mu106_usbpd_data *pdic_data =
2630 power_supply_get_drvdata(psy);
2631 struct i2c_client *i2c = pdic_data->i2c;
2632 u8 data = 0;
2633
2634 switch (psp) {
2635 case POWER_SUPPLY_PROP_AUTHENTIC:
2636 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, &data);
2637 data &= ~(S2MU106_REG_RD_OR_VBUS_MUX_SEL);
2638 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, data);
2639 break;
2640 case POWER_SUPPLY_PROP_USBPD_RESET:
2641 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_DISABLE);
2642 s2mu106_usbpd_set_vbus_wakeup(pdic_data, VBUS_WAKEUP_ENABLE);
2643 break;
2644 default:
2645 return -EINVAL;
2646 }
2647 return 0;
2648 }
2649
2650 int s2mu106_usbpd_psy_init(struct s2mu106_usbpd_data *_data, struct device *parent)
2651 {
2652 struct power_supply_config psy_cfg = {};
2653 int ret = 0;
2654
2655 if (_data == NULL || parent == NULL) {
2656 pr_err("%s NULL data\n", __func__);
2657 return -1;
2658 }
2659
2660 _data->ccic_desc.name = "s2mu106-usbpd";
2661 _data->ccic_desc.type = POWER_SUPPLY_TYPE_UNKNOWN;
2662 _data->ccic_desc.get_property = s2mu106_usbpd_get_property;
2663 _data->ccic_desc.set_property = s2mu106_usbpd_set_property;
2664 _data->ccic_desc.properties = ccic_props;
2665 _data->ccic_desc.num_properties = ARRAY_SIZE(ccic_props);
2666
2667 psy_cfg.drv_data = _data;
2668 psy_cfg.supplied_to = ccic_supplied_to;
2669 psy_cfg.num_supplicants = ARRAY_SIZE(ccic_supplied_to);
2670
2671 _data->psy_ccic = power_supply_register(parent, &_data->ccic_desc, &psy_cfg);
2672 if (IS_ERR(_data->psy_ccic)) {
2673 ret = (int)PTR_ERR(_data->psy_ccic);
2674 pr_err("%s: Failed to Register psy_ccic, ret : %d\n", __func__, ret);
2675 }
2676 return ret;
2677 }
2678
2679 static int s2mu106_usbpd_reg_init(struct s2mu106_usbpd_data *_data)
2680 {
2681 struct i2c_client *i2c = _data->i2c;
2682 u8 data = 0;
2683
2684 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PHY_CTRL_IFG, &data);
2685 data |= S2MU106_PHY_IFG_35US << S2MU106_REG_IFG_SHIFT;
2686 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PHY_CTRL_IFG, data);
2687
2688 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_MSG_SEND_CON, &data);
2689 data |= S2MU106_REG_MSG_SEND_CON_HARD_EN;
2690 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_MSG_SEND_CON, data);
2691
2692 /* for SMPL issue */
2693 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_ANALOG_OTP_0A, &data);
2694 data |= S2MU106_REG_OVP_ON;
2695 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_ANALOG_OTP_0A, data);
2696
2697 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PD_CTRL_2, &data);
2698 data &= ~S2MU106_REG_CC_OCP_MASK;
2699 data |= S2MU106_CC_OCP_575MV << S2MU106_REG_CC_OCP_SHIFT;
2700 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PD_CTRL_2, data);
2701
2702 /* enable Rd monitor status when cc is attached at sink */
2703 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_MON, &data);
2704 data |= S2MU106_REG_PLUG_CTRL_SET_MON_RD;
2705 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_MON, data);
2706
2707 /* diable rd or vbus mux */
2708 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, &data);
2709 data &= ~S2MU106_REG_RD_OR_VBUS_MUX_SEL;
2710 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_VBUS_MUX, data);
2711
2712 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PHY_CTRL_00, 0x80);
2713 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_BMC_CTRL, &data);
2714 data |= 0x01 << 2;
2715 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_BMC_CTRL, data);
2716
2717 /* set debounce time
2718 devide by 300 and unit is ms */
2719 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_TIMER1, 0xe4);
2720 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_TIMER2, 0x0c);
2721
2722 /* enable support acc */
2723 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, &data);
2724 data |= S2MU106_REG_PLUG_CTRL_SUPPORT_ACC;
2725 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_CC_HOLD, data);
2726
2727 /* fix trim code */
2728 s2mu106_usbpd_read_reg(i2c, 0x00, &data);
2729 data |= 0x1 | 0x3 << 2;
2730 s2mu106_usbpd_write_reg(i2c, 0x00, data);
2731
2732 data = 0;
2733 data |= (S2MU106_REG_PLUG_CTRL_SSM_DISABLE |
2734 S2MU106_REG_PLUG_CTRL_VDM_DISABLE);
2735 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL, data);
2736
2737 /* set Rd threshold to 400mV */
2738 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD_2, S2MU106_THRESHOLD_600MV);
2739 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP_2, S2MU106_THRESHOLD_1200MV);
2740 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RD, S2MU106_THRESHOLD_300MV | 0x40);
2741 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_SET_RP, S2MU106_THRESHOLD_2057MV);
2742
2743 if (_data->vconn_en) {
2744 /* Off Manual Rd setup & On Manual Vconn setup */
2745 s2mu106_usbpd_read_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, &data);
2746 data &= ~(S2MU106_REG_PLUG_CTRL_RpRd_MANUAL_EN_MASK);
2747 data |= S2MU106_REG_PLUG_CTRL_VCONN_MANUAL_EN;
2748 s2mu106_usbpd_write_reg(i2c, S2MU106_REG_PLUG_CTRL_RpRd, data);
2749 }
2750 #ifdef CONFIG_PM_S2MU106
2751 s2mu106_usbpd_set_pmeter_mode(_data, PM_TYPE_VCHGIN);
2752 #endif
2753
2754 s2mu106_usbpd_set_vconn_manual(_data, true);
2755
2756 return 0;
2757 }
2758
2759 static irqreturn_t s2mu106_irq_isr(int irq, void *data)
2760 {
2761 return IRQ_WAKE_THREAD;
2762 }
2763
2764 static int s2mu106_usbpd_irq_init(struct s2mu106_usbpd_data *_data)
2765 {
2766 struct i2c_client *i2c = _data->i2c;
2767 struct device *dev = &i2c->dev;
2768 int ret = 0;
2769
2770 if (!_data->irq_gpio) {
2771 dev_err(dev, "%s No interrupt specified\n", __func__);
2772 return -ENXIO;
2773 }
2774
2775 /* s2mu106_usbpd_bulk_read(i2c, S2MU106_REG_INT_STATUS0,
2776 S2MU106_MAX_NUM_INT_STATUS, intr);
2777
2778 pr_info("%s status[0x%x 0x%x 0x%x 0x%x 0x%x]\n",
2779 __func__, intr[0], intr[1], intr[2], intr[3], intr[4]);
2780 */
2781 i2c->irq = gpio_to_irq(_data->irq_gpio);
2782
2783 if (i2c->irq) {
2784 ret = request_threaded_irq(i2c->irq, s2mu106_irq_isr,
2785 s2mu106_irq_thread,
2786 (IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_NO_SUSPEND),
2787 "s2mu106-usbpd", _data);
2788 if (ret < 0) {
2789 dev_err(dev, "%s failed to request irq(%d)\n",
2790 __func__, i2c->irq);
2791 return ret;
2792 }
2793
2794 ret = enable_irq_wake(i2c->irq);
2795 if (ret < 0)
2796 dev_err(dev, "%s failed to enable wakeup src\n",
2797 __func__);
2798 }
2799
2800 if (_data->lpm_mode)
2801 s2mu106_set_irq_enable(_data, 0, 0, 0, 0, 0, 0);
2802 else
2803 s2mu106_set_irq_enable(_data, ENABLED_INT_0, ENABLED_INT_1,
2804 ENABLED_INT_2, ENABLED_INT_3, ENABLED_INT_4, ENABLED_INT_5);
2805
2806 return ret;
2807 }
2808
2809 static void s2mu106_usbpd_init_configure(struct s2mu106_usbpd_data *_data)
2810 {
2811 s2mu106_usbpd_test_read(_data);
2812 s2mu106_usbpd_get_pmeter_volt(_data);
2813 s2mu106_usbpd_get_pmeter_current(_data);
2814 pr_info("%s, chgin(%d), chgin_i(%d)\n", __func__,
2815 _data->pm_chgin, _data->pm_chgin_i);
2816 usbpd_charger_test_read(_data);
2817 s2mu106_set_normal_mode(_data);
2818 pr_info("%s, usbpd irq gpio value(%d)\n", __func__,
2819 gpio_get_value(_data->irq_gpio));
2820 msleep(25);
2821 _data->detach_valid = true;
2822 s2mu106_self_soft_reset(_data->i2c);
2823 s2mu106_set_lpm_mode(_data);
2824 _data->detach_valid = false;
2825 s2mu106_usbpd_set_cc_control(_data, USBPD_CC_OFF);
2826 _data->lpm_mode = true;
2827 if (_data->pm_chgin > 4800 && _data->pm_chgin_i > 1000)
2828 msleep(500); /* for abnormal PD TA */
2829 else
2830 msleep(150);
2831 _data->is_factory_mode = false;
2832 s2mu106_set_normal_mode(_data);
2833 _data->lpm_mode = false;
2834 }
2835
2836 static void s2mu106_usbpd_pdic_data_init(struct s2mu106_usbpd_data *_data)
2837 {
2838 _data->check_msg_pass = false;
2839 _data->vconn_source = USBPD_VCONN_OFF;
2840 _data->rid = REG_RID_MAX;
2841 _data->is_host = 0;
2842 _data->is_client = 0;
2843 _data->data_role_dual = 0;
2844 _data->power_role_dual = 0;
2845 _data->is_water_detect = false;
2846 _data->is_muic_water_detect = false;
2847 _data->detach_valid = true;
2848 _data->is_otg_vboost = false;
2849 _data->is_otg_reboost = false;
2850 _data->is_pr_swap = false;
2851 _data->vbus_access = false;
2852 #ifndef CONFIG_SEC_FACTORY
2853 _data->lpcharge_water = false;
2854 #endif
2855 _data->check_rid_wa = false;
2856 #if defined(CONFIG_TYPEC)
2857 _data->typec_power_role = TYPEC_SINK;
2858 _data->typec_data_role = TYPEC_DEVICE;
2859 #endif
2860 }
2861
2862 static int of_s2mu106_dt(struct device *dev,
2863 struct s2mu106_usbpd_data *_data)
2864 {
2865 struct device_node *np_usbpd = dev->of_node;
2866 int ret = 0;
2867
2868 if (np_usbpd == NULL) {
2869 dev_err(dev, "%s np NULL\n", __func__);
2870 return -EINVAL;
2871 } else {
2872 _data->irq_gpio = of_get_named_gpio(np_usbpd,
2873 "usbpd,usbpd_int", 0);
2874 if (_data->irq_gpio < 0) {
2875 dev_err(dev, "error reading usbpd irq = %d\n",
2876 _data->irq_gpio);
2877 _data->irq_gpio = 0;
2878 }
2879 ret = gpio_get_value(_data->irq_gpio);
2880 pr_info("%s, usbpd irq gpio value(%d)\n", __func__, ret);
2881 if (of_find_property(np_usbpd, "vconn-en", NULL))
2882 _data->vconn_en = true;
2883 else
2884 _data->vconn_en = false;
2885
2886 if (of_find_property(np_usbpd, "regulator-en", NULL))
2887 _data->regulator_en = true;
2888 else
2889 _data->regulator_en = false;
2890 #ifdef CONFIG_CCIC_DP
2891 _data->usb_sw_sel = of_get_named_gpio(np_usbpd, "usb_sw_sel", 0);
2892
2893 if (!gpio_is_valid(_data->usb_sw_sel))
2894 dev_err(dev, "failed to get gpio usb_sw_sel\n");
2895 #endif
2896 }
2897 return ret;
2898 }
2899
2900 static int s2mu106_usbpd_probe(struct i2c_client *i2c,
2901 const struct i2c_device_id *id)
2902 {
2903 struct i2c_adapter *adapter = to_i2c_adapter(i2c->dev.parent);
2904 struct s2mu106_usbpd_data *pdic_data;
2905 struct device *dev = &i2c->dev;
2906 int ret = 0;
2907
2908 dev_info(dev, "%s\n", __func__);
2909 test_i2c = i2c;
2910
2911 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
2912 dev_err(dev, "%s: i2c functionality check error\n", __func__);
2913 ret = -EIO;
2914 goto err_return;
2915 }
2916
2917 pdic_data = kzalloc(sizeof(struct s2mu106_usbpd_data), GFP_KERNEL);
2918 if (!pdic_data) {
2919 dev_err(dev, "%s: failed to allocate driver data\n", __func__);
2920 ret = -ENOMEM;
2921 goto err_return;
2922 }
2923
2924 /* save platfom data for gpio control functions */
2925 pdic_data->dev = &i2c->dev;
2926 pdic_data->i2c = i2c;
2927 i2c_set_clientdata(i2c, pdic_data);
2928
2929 ret = of_s2mu106_dt(&i2c->dev, pdic_data);
2930 if (ret < 0)
2931 dev_err(dev, "%s: not found dt!\n", __func__);
2932
2933 mutex_init(&pdic_data->_mutex);
2934 mutex_init(&pdic_data->lpm_mutex);
2935 mutex_init(&pdic_data->cc_mutex);
2936 wake_lock_init(&pdic_data->wake_lock, WAKE_LOCK_SUSPEND, "pdic_wake");
2937
2938 #ifdef CONFIG_PM_S2MU106
2939 pdic_data->psy_pm = power_supply_get_by_name("s2mu106_pmeter");
2940 if (!pdic_data->psy_pm)
2941 pr_err("%s: Fail to get pmeter\n", __func__);
2942 s2mu106_usbpd_set_pmeter_mode(pdic_data, PM_TYPE_VCHGIN);
2943 s2mu106_usbpd_set_pmeter_mode(pdic_data, PM_TYPE_ICHGIN);
2944 #endif
2945
2946 s2mu106_usbpd_init_configure(pdic_data);
2947 s2mu106_usbpd_pdic_data_init(pdic_data);
2948
2949 if (pdic_data->regulator_en) {
2950 pdic_data->regulator = devm_regulator_get(dev, "vconn");
2951 if (IS_ERR(pdic_data->regulator)) {
2952 dev_err(dev, "%s: not found regulator vconn\n", __func__);
2953 pdic_data->regulator_en = false;
2954 } else
2955 ret = regulator_disable(pdic_data->regulator);
2956 }
2957
2958 ret = usbpd_init(dev, pdic_data);
2959 if (ret < 0) {
2960 dev_err(dev, "failed on usbpd_init\n");
2961 goto err_return;
2962 }
2963
2964 usbpd_set_ops(dev, &s2mu106_ops);
2965
2966 s2mu106_usbpd_reg_init(pdic_data);
2967
2968 pdic_data->pdic_queue =
2969 alloc_workqueue(dev_name(dev), WQ_MEM_RECLAIM, 1);
2970 if (!pdic_data->pdic_queue) {
2971 dev_err(dev,
2972 "%s: Fail to Create Workqueue\n", __func__);
2973 goto err_return;
2974 }
2975
2976 #if defined(CONFIG_IFCONN_NOTIFIER)
2977 /* Create a work queue for the ccic irq thread */
2978 pdic_data->ifconn_wq
2979 = create_singlethread_workqueue("ifconn_notify_event");
2980 if (!pdic_data->ifconn_wq) {
2981 pr_err("%s failed to create work queue for ccic notifier\n",
2982 __func__);
2983 goto err_return;
2984 }
2985 #endif
2986 if (pdic_data->rid == REG_RID_UNDF)
2987 pdic_data->rid = REG_RID_MAX;
2988 #if defined(CONFIG_TYPEC)
2989 ret = typec_init(pdic_data);
2990 if (ret < 0) {
2991 pr_err("failed to init typec\n");
2992 goto err_return;
2993 }
2994 #endif
2995
2996 ret = s2mu106_usbpd_irq_init(pdic_data);
2997 if (ret) {
2998 dev_err(dev, "%s: failed to init irq(%d)\n", __func__, ret);
2999 goto fail_init_irq;
3000 }
3001 INIT_DELAYED_WORK(&pdic_data->water_detect_handler, S2MU106_PDIC_water_detect_handler);
3002 INIT_DELAYED_WORK(&pdic_data->water_dry_handler, S2MU106_PDIC_water_dry_handler);
3003 INIT_DELAYED_WORK(&pdic_data->water_dry_handler, S2MU106_PDIC_water_dry_handler);
3004 INIT_DELAYED_WORK(&pdic_data->plug_work, s2mu106_usbpd_plug_work);
3005 INIT_DELAYED_WORK(&pdic_data->dr_work, s2mu106_usbpd_dr_work);
3006
3007 if (pdic_data->detach_valid) {
3008 mutex_lock(&pdic_data->_mutex);
3009 s2mu106_check_port_detect(pdic_data);
3010 s2mu106_usbpd_check_rid(pdic_data);
3011 mutex_unlock(&pdic_data->_mutex);
3012 }
3013
3014 s2mu106_irq_thread(-1, pdic_data);
3015
3016 #if defined(CONFIG_MUIC_NOTIFIER)
3017 muic_ccic_notifier_register(&pdic_data->type3_nb,
3018 type3_handle_notification,
3019 MUIC_NOTIFY_DEV_PDIC);
3020 #endif
3021 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
3022 ret = dual_role_init(pdic_data);
3023 if (ret < 0) {
3024 pr_err("unable to allocate dual role descriptor\n");
3025 goto fail_init_irq;
3026 }
3027
3028 #endif
3029 ret = s2mu106_usbpd_psy_init(pdic_data, &i2c->dev);
3030 if (ret < 0) {
3031 pr_err("faled to register the ccic psy.\n");
3032 }
3033
3034 dev_info(dev, "%s s2mu106 usbpd driver uploaded!\n", __func__);
3035
3036 return 0;
3037
3038 fail_init_irq:
3039 if (i2c->irq)
3040 free_irq(i2c->irq, pdic_data);
3041 err_return:
3042 return ret;
3043 }
3044
3045 #if defined CONFIG_PM
3046 static int s2mu106_usbpd_suspend(struct device *dev)
3047 {
3048 struct usbpd_data *_data = dev_get_drvdata(dev);
3049 struct s2mu106_usbpd_data *pdic_data = _data->phy_driver_data;
3050
3051 if (device_may_wakeup(dev))
3052 enable_irq_wake(pdic_data->i2c->irq);
3053
3054 #ifndef CONFIG_SEC_FACTORY
3055 disable_irq(pdic_data->i2c->irq);
3056 #endif
3057 return 0;
3058 }
3059
3060 static int s2mu106_usbpd_resume(struct device *dev)
3061 {
3062 struct usbpd_data *_data = dev_get_drvdata(dev);
3063 struct s2mu106_usbpd_data *pdic_data = _data->phy_driver_data;
3064
3065 if (device_may_wakeup(dev))
3066 disable_irq_wake(pdic_data->i2c->irq);
3067
3068 #ifndef CONFIG_SEC_FACTORY
3069 enable_irq(pdic_data->i2c->irq);
3070 #endif
3071 return 0;
3072 }
3073 #else
3074 #define s2mu106_muic_suspend NULL
3075 #define s2mu106_muic_resume NULL
3076 #endif
3077
3078 static int s2mu106_usbpd_remove(struct i2c_client *i2c)
3079 {
3080 struct s2mu106_usbpd_data *_data = i2c_get_clientdata(i2c);
3081
3082 if (_data) {
3083 #if defined(CONFIG_DUAL_ROLE_USB_INTF)
3084 devm_dual_role_instance_unregister(_data->dev,
3085 _data->dual_role);
3086 devm_kfree(_data->dev, _data->desc);
3087 #elif defined(CONFIG_TYPEC)
3088 typec_unregister_port(_data->port);
3089 #endif
3090 disable_irq_wake(_data->i2c->irq);
3091 free_irq(_data->i2c->irq, _data);
3092 mutex_destroy(&_data->_mutex);
3093 i2c_set_clientdata(_data->i2c, NULL);
3094 kfree(_data);
3095 }
3096 return 0;
3097 }
3098
3099 static const struct i2c_device_id s2mu106_usbpd_i2c_id[] = {
3100 { USBPD_DEV_NAME, 1 },
3101 {}
3102 };
3103 MODULE_DEVICE_TABLE(i2c, s2mu106_i2c_id);
3104
3105 static struct of_device_id sec_usbpd_i2c_dt_ids[] = {
3106 { .compatible = "sec-usbpd,i2c" },
3107 { }
3108 };
3109
3110 static void s2mu106_usbpd_shutdown(struct i2c_client *i2c)
3111 {
3112 struct s2mu106_usbpd_data *_data = i2c_get_clientdata(i2c);
3113
3114 if (!_data->i2c)
3115 return;
3116 }
3117
3118 static usbpd_phy_ops_type s2mu106_ops = {
3119 .tx_msg = s2mu106_tx_msg,
3120 .rx_msg = s2mu106_rx_msg,
3121 .hard_reset = s2mu106_hard_reset,
3122 .soft_reset = s2mu106_soft_reset,
3123 .set_power_role = s2mu106_set_power_role,
3124 .get_power_role = s2mu106_get_power_role,
3125 .set_data_role = s2mu106_set_data_role,
3126 .get_data_role = s2mu106_get_data_role,
3127 .set_vconn_source = s2mu106_set_vconn_source,
3128 .get_vconn_source = s2mu106_get_vconn_source,
3129 .set_check_msg_pass = s2mu106_set_check_msg_pass,
3130 .get_status = s2mu106_get_status,
3131 .poll_status = s2mu106_poll_status,
3132 .driver_reset = s2mu106_driver_reset,
3133 .set_otg_control = s2mu106_set_otg_control,
3134 .set_cc_control = s2mu106_set_cc_control,
3135 .get_side_check = s2mu106_get_side_check,
3136 .pr_swap = s2mu106_pr_swap,
3137 .vbus_on_check = s2mu106_vbus_on_check,
3138 .set_pwr_opmode = s2mu106_set_pwr_opmode,
3139 };
3140
3141 #if defined CONFIG_PM
3142 const struct dev_pm_ops s2mu106_usbpd_pm = {
3143 .suspend = s2mu106_usbpd_suspend,
3144 .resume = s2mu106_usbpd_resume,
3145 };
3146 #endif
3147
3148 static struct i2c_driver s2mu106_usbpd_driver = {
3149 .driver = {
3150 .name = USBPD_DEV_NAME,
3151 .of_match_table = sec_usbpd_i2c_dt_ids,
3152 #if defined CONFIG_PM
3153 .pm = &s2mu106_usbpd_pm,
3154 #endif /* CONFIG_PM */
3155 },
3156 .probe = s2mu106_usbpd_probe,
3157 .remove = s2mu106_usbpd_remove,
3158 .shutdown = s2mu106_usbpd_shutdown,
3159 .id_table = s2mu106_usbpd_i2c_id,
3160 };
3161
3162 static int __init s2mu106_usbpd_init(void)
3163 {
3164 return i2c_add_driver(&s2mu106_usbpd_driver);
3165 }
3166 late_initcall(s2mu106_usbpd_init);
3167
3168 static void __exit s2mu106_usbpd_exit(void)
3169 {
3170 i2c_del_driver(&s2mu106_usbpd_driver);
3171 }
3172 module_exit(s2mu106_usbpd_exit);
3173
3174 MODULE_DESCRIPTION("s2mu106 USB PD driver");
3175 MODULE_LICENSE("GPL");