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