projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blob
? search:


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