1// SPDX-License-Identifier: GPL-2.0
2/*
3 * STMicroelectronics STUSB160x Type-C controller family driver
4 *
5 * Copyright (C) 2020, STMicroelectronics
6 * Author(s): Amelie Delaunay <amelie.delaunay@st.com>
7 */
8
9#include <linux/bitfield.h>
10#include <linux/i2c.h>
11#include <linux/interrupt.h>
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/regmap.h>
15#include <linux/regulator/consumer.h>
16#include <linux/usb/role.h>
17#include <linux/usb/typec.h>
18
19#define STUSB160X_ALERT_STATUS 0x0B /* RC */
20#define STUSB160X_ALERT_STATUS_MASK_CTRL 0x0C /* RW */
21#define STUSB160X_CC_CONNECTION_STATUS_TRANS 0x0D /* RC */
22#define STUSB160X_CC_CONNECTION_STATUS 0x0E /* RO */
23#define STUSB160X_MONITORING_STATUS_TRANS 0x0F /* RC */
24#define STUSB160X_MONITORING_STATUS 0x10 /* RO */
25#define STUSB160X_CC_OPERATION_STATUS 0x11 /* RO */
26#define STUSB160X_HW_FAULT_STATUS_TRANS 0x12 /* RC */
27#define STUSB160X_HW_FAULT_STATUS 0x13 /* RO */
28#define STUSB160X_CC_CAPABILITY_CTRL 0x18 /* RW */
29#define STUSB160X_CC_VCONN_SWITCH_CTRL 0x1E /* RW */
30#define STUSB160X_VCONN_MONITORING_CTRL 0x20 /* RW */
31#define STUSB160X_VBUS_MONITORING_RANGE_CTRL 0x22 /* RW */
32#define STUSB160X_RESET_CTRL 0x23 /* RW */
33#define STUSB160X_VBUS_DISCHARGE_TIME_CTRL 0x25 /* RW */
34#define STUSB160X_VBUS_DISCHARGE_STATUS 0x26 /* RO */
35#define STUSB160X_VBUS_ENABLE_STATUS 0x27 /* RO */
36#define STUSB160X_CC_POWER_MODE_CTRL 0x28 /* RW */
37#define STUSB160X_VBUS_MONITORING_CTRL 0x2E /* RW */
38#define STUSB1600_REG_MAX 0x2F /* RO - Reserved */
39
40/* STUSB160X_ALERT_STATUS/STUSB160X_ALERT_STATUS_MASK_CTRL bitfields */
41#define STUSB160X_HW_FAULT BIT(4)
42#define STUSB160X_MONITORING BIT(5)
43#define STUSB160X_CC_CONNECTION BIT(6)
44#define STUSB160X_ALL_ALERTS GENMASK(6, 4)
45
46/* STUSB160X_CC_CONNECTION_STATUS_TRANS bitfields */
47#define STUSB160X_CC_ATTACH_TRANS BIT(0)
48
49/* STUSB160X_CC_CONNECTION_STATUS bitfields */
50#define STUSB160X_CC_ATTACH BIT(0)
51#define STUSB160X_CC_VCONN_SUPPLY BIT(1)
52#define STUSB160X_CC_DATA_ROLE(s) (!!((s) & BIT(2)))
53#define STUSB160X_CC_POWER_ROLE(s) (!!((s) & BIT(3)))
54#define STUSB160X_CC_ATTACHED_MODE GENMASK(7, 5)
55
56/* STUSB160X_MONITORING_STATUS_TRANS bitfields */
57#define STUSB160X_VCONN_PRESENCE_TRANS BIT(0)
58#define STUSB160X_VBUS_PRESENCE_TRANS BIT(1)
59#define STUSB160X_VBUS_VSAFE0V_TRANS BIT(2)
60#define STUSB160X_VBUS_VALID_TRANS BIT(3)
61
62/* STUSB160X_MONITORING_STATUS bitfields */
63#define STUSB160X_VCONN_PRESENCE BIT(0)
64#define STUSB160X_VBUS_PRESENCE BIT(1)
65#define STUSB160X_VBUS_VSAFE0V BIT(2)
66#define STUSB160X_VBUS_VALID BIT(3)
67
68/* STUSB160X_CC_OPERATION_STATUS bitfields */
69#define STUSB160X_TYPEC_FSM_STATE GENMASK(4, 0)
70#define STUSB160X_SINK_POWER_STATE GENMASK(6, 5)
71#define STUSB160X_CC_ATTACHED BIT(7)
72
73/* STUSB160X_HW_FAULT_STATUS_TRANS bitfields */
74#define STUSB160X_VCONN_SW_OVP_FAULT_TRANS BIT(0)
75#define STUSB160X_VCONN_SW_OCP_FAULT_TRANS BIT(1)
76#define STUSB160X_VCONN_SW_RVP_FAULT_TRANS BIT(2)
77#define STUSB160X_VPU_VALID_TRANS BIT(4)
78#define STUSB160X_VPU_OVP_FAULT_TRANS BIT(5)
79#define STUSB160X_THERMAL_FAULT BIT(7)
80
81/* STUSB160X_HW_FAULT_STATUS bitfields */
82#define STUSB160X_VCONN_SW_OVP_FAULT_CC2 BIT(0)
83#define STUSB160X_VCONN_SW_OVP_FAULT_CC1 BIT(1)
84#define STUSB160X_VCONN_SW_OCP_FAULT_CC2 BIT(2)
85#define STUSB160X_VCONN_SW_OCP_FAULT_CC1 BIT(3)
86#define STUSB160X_VCONN_SW_RVP_FAULT_CC2 BIT(4)
87#define STUSB160X_VCONN_SW_RVP_FAULT_CC1 BIT(5)
88#define STUSB160X_VPU_VALID BIT(6)
89#define STUSB160X_VPU_OVP_FAULT BIT(7)
90
91/* STUSB160X_CC_CAPABILITY_CTRL bitfields */
92#define STUSB160X_CC_VCONN_SUPPLY_EN BIT(0)
93#define STUSB160X_CC_VCONN_DISCHARGE_EN BIT(4)
94#define STUSB160X_CC_CURRENT_ADVERTISED GENMASK(7, 6)
95
96/* STUSB160X_VCONN_SWITCH_CTRL bitfields */
97#define STUSB160X_CC_VCONN_SWITCH_ILIM GENMASK(3, 0)
98
99/* STUSB160X_VCONN_MONITORING_CTRL bitfields */
100#define STUSB160X_VCONN_UVLO_THRESHOLD BIT(6)
101#define STUSB160X_VCONN_MONITORING_EN BIT(7)
102
103/* STUSB160X_VBUS_MONITORING_RANGE_CTRL bitfields */
104#define STUSB160X_SHIFT_LOW_VBUS_LIMIT GENMASK(3, 0)
105#define STUSB160X_SHIFT_HIGH_VBUS_LIMIT GENMASK(7, 4)
106
107/* STUSB160X_RESET_CTRL bitfields */
108#define STUSB160X_SW_RESET_EN BIT(0)
109
110/* STUSB160X_VBUS_DISCHARGE_TIME_CTRL bitfields */
111#define STUSBXX02_VBUS_DISCHARGE_TIME_TO_PDO GENMASK(3, 0)
112#define STUSB160X_VBUS_DISCHARGE_TIME_TO_0V GENMASK(7, 4)
113
114/* STUSB160X_VBUS_DISCHARGE_STATUS bitfields */
115#define STUSB160X_VBUS_DISCHARGE_EN BIT(7)
116
117/* STUSB160X_VBUS_ENABLE_STATUS bitfields */
118#define STUSB160X_VBUS_SOURCE_EN BIT(0)
119#define STUSB160X_VBUS_SINK_EN BIT(1)
120
121/* STUSB160X_CC_POWER_MODE_CTRL bitfields */
122#define STUSB160X_CC_POWER_MODE GENMASK(2, 0)
123
124/* STUSB160X_VBUS_MONITORING_CTRL bitfields */
125#define STUSB160X_VDD_UVLO_DISABLE BIT(0)
126#define STUSB160X_VBUS_VSAFE0V_THRESHOLD GENMASK(2, 1)
127#define STUSB160X_VBUS_RANGE_DISABLE BIT(4)
128#define STUSB160X_VDD_OVLO_DISABLE BIT(6)
129
130enum stusb160x_pwr_mode {
131 SOURCE_WITH_ACCESSORY,
132 SINK_WITH_ACCESSORY,
133 SINK_WITHOUT_ACCESSORY,
134 DUAL_WITH_ACCESSORY,
135 DUAL_WITH_ACCESSORY_AND_TRY_SRC,
136 DUAL_WITH_ACCESSORY_AND_TRY_SNK,
137};
138
139enum stusb160x_attached_mode {
140 NO_DEVICE_ATTACHED,
141 SINK_ATTACHED,
142 SOURCE_ATTACHED,
143 DEBUG_ACCESSORY_ATTACHED,
144 AUDIO_ACCESSORY_ATTACHED,
145};
146
147struct stusb160x {
148 struct device *dev;
149 struct regmap *regmap;
150 struct regulator *vdd_supply;
151 struct regulator *vsys_supply;
152 struct regulator *vconn_supply;
153 struct regulator *main_supply;
154
155 struct typec_port *port;
156 struct typec_capability capability;
157 struct typec_partner *partner;
158
159 enum typec_port_type port_type;
160 enum typec_pwr_opmode pwr_opmode;
161 bool vbus_on;
162
163 struct usb_role_switch *role_sw;
164};
165
166static bool stusb160x_reg_writeable(struct device *dev, unsigned int reg)
167{
168 switch (reg) {
169 case STUSB160X_ALERT_STATUS_MASK_CTRL:
170 case STUSB160X_CC_CAPABILITY_CTRL:
171 case STUSB160X_CC_VCONN_SWITCH_CTRL:
172 case STUSB160X_VCONN_MONITORING_CTRL:
173 case STUSB160X_VBUS_MONITORING_RANGE_CTRL:
174 case STUSB160X_RESET_CTRL:
175 case STUSB160X_VBUS_DISCHARGE_TIME_CTRL:
176 case STUSB160X_CC_POWER_MODE_CTRL:
177 case STUSB160X_VBUS_MONITORING_CTRL:
178 return true;
179 default:
180 return false;
181 }
182}
183
184static bool stusb160x_reg_readable(struct device *dev, unsigned int reg)
185{
186 if (reg <= 0x0A ||
187 (reg >= 0x14 && reg <= 0x17) ||
188 (reg >= 0x19 && reg <= 0x1D) ||
189 (reg >= 0x29 && reg <= 0x2D) ||
190 (reg == 0x1F || reg == 0x21 || reg == 0x24 || reg == 0x2F))
191 return false;
192 else
193 return true;
194}
195
196static bool stusb160x_reg_volatile(struct device *dev, unsigned int reg)
197{
198 switch (reg) {
199 case STUSB160X_ALERT_STATUS:
200 case STUSB160X_CC_CONNECTION_STATUS_TRANS:
201 case STUSB160X_CC_CONNECTION_STATUS:
202 case STUSB160X_MONITORING_STATUS_TRANS:
203 case STUSB160X_MONITORING_STATUS:
204 case STUSB160X_CC_OPERATION_STATUS:
205 case STUSB160X_HW_FAULT_STATUS_TRANS:
206 case STUSB160X_HW_FAULT_STATUS:
207 case STUSB160X_VBUS_DISCHARGE_STATUS:
208 case STUSB160X_VBUS_ENABLE_STATUS:
209 return true;
210 default:
211 return false;
212 }
213}
214
215static bool stusb160x_reg_precious(struct device *dev, unsigned int reg)
216{
217 switch (reg) {
218 case STUSB160X_ALERT_STATUS:
219 case STUSB160X_CC_CONNECTION_STATUS_TRANS:
220 case STUSB160X_MONITORING_STATUS_TRANS:
221 case STUSB160X_HW_FAULT_STATUS_TRANS:
222 return true;
223 default:
224 return false;
225 }
226}
227
228static const struct regmap_config stusb1600_regmap_config = {
229 .reg_bits = 8,
230 .reg_stride = 1,
231 .val_bits = 8,
232 .max_register = STUSB1600_REG_MAX,
233 .writeable_reg = stusb160x_reg_writeable,
234 .readable_reg = stusb160x_reg_readable,
235 .volatile_reg = stusb160x_reg_volatile,
236 .precious_reg = stusb160x_reg_precious,
237 .cache_type = REGCACHE_MAPLE,
238};
239
240static bool stusb160x_get_vconn(struct stusb160x *chip)
241{
242 u32 val;
243 int ret;
244
245 ret = regmap_read(map: chip->regmap, STUSB160X_CC_CAPABILITY_CTRL, val: &val);
246 if (ret) {
247 dev_err(chip->dev, "Unable to get Vconn status: %d\n", ret);
248 return false;
249 }
250
251 return !!FIELD_GET(STUSB160X_CC_VCONN_SUPPLY_EN, val);
252}
253
254static int stusb160x_set_vconn(struct stusb160x *chip, bool on)
255{
256 int ret;
257
258 /* Manage VCONN input supply */
259 if (chip->vconn_supply) {
260 if (on) {
261 ret = regulator_enable(regulator: chip->vconn_supply);
262 if (ret) {
263 dev_err(chip->dev,
264 "failed to enable vconn supply: %d\n",
265 ret);
266 return ret;
267 }
268 } else {
269 regulator_disable(regulator: chip->vconn_supply);
270 }
271 }
272
273 /* Manage VCONN monitoring and power path */
274 ret = regmap_update_bits(map: chip->regmap, STUSB160X_VCONN_MONITORING_CTRL,
275 STUSB160X_VCONN_MONITORING_EN,
276 val: on ? STUSB160X_VCONN_MONITORING_EN : 0);
277 if (ret)
278 goto vconn_reg_disable;
279
280 return 0;
281
282vconn_reg_disable:
283 if (chip->vconn_supply && on)
284 regulator_disable(regulator: chip->vconn_supply);
285
286 return ret;
287}
288
289static enum typec_pwr_opmode stusb160x_get_pwr_opmode(struct stusb160x *chip)
290{
291 u32 val;
292 int ret;
293
294 ret = regmap_read(map: chip->regmap, STUSB160X_CC_CAPABILITY_CTRL, val: &val);
295 if (ret) {
296 dev_err(chip->dev, "Unable to get pwr opmode: %d\n", ret);
297 return TYPEC_PWR_MODE_USB;
298 }
299
300 return FIELD_GET(STUSB160X_CC_CURRENT_ADVERTISED, val);
301}
302
303static enum typec_accessory stusb160x_get_accessory(u32 status)
304{
305 enum stusb160x_attached_mode mode;
306
307 mode = FIELD_GET(STUSB160X_CC_ATTACHED_MODE, status);
308
309 switch (mode) {
310 case DEBUG_ACCESSORY_ATTACHED:
311 return TYPEC_ACCESSORY_DEBUG;
312 case AUDIO_ACCESSORY_ATTACHED:
313 return TYPEC_ACCESSORY_AUDIO;
314 default:
315 return TYPEC_ACCESSORY_NONE;
316 }
317}
318
319static enum typec_role stusb160x_get_vconn_role(u32 status)
320{
321 if (FIELD_GET(STUSB160X_CC_VCONN_SUPPLY, status))
322 return TYPEC_SOURCE;
323
324 return TYPEC_SINK;
325}
326
327static void stusb160x_set_data_role(struct stusb160x *chip,
328 enum typec_data_role data_role,
329 bool attached)
330{
331 enum usb_role usb_role = USB_ROLE_NONE;
332
333 if (attached) {
334 if (data_role == TYPEC_HOST)
335 usb_role = USB_ROLE_HOST;
336 else
337 usb_role = USB_ROLE_DEVICE;
338 }
339
340 usb_role_switch_set_role(sw: chip->role_sw, role: usb_role);
341 typec_set_data_role(port: chip->port, role: data_role);
342}
343
344static int stusb160x_attach(struct stusb160x *chip, u32 status)
345{
346 struct typec_partner_desc desc;
347 int ret;
348
349 if ((STUSB160X_CC_POWER_ROLE(status) == TYPEC_SOURCE) &&
350 chip->vdd_supply) {
351 ret = regulator_enable(regulator: chip->vdd_supply);
352 if (ret) {
353 dev_err(chip->dev,
354 "Failed to enable Vbus supply: %d\n", ret);
355 return ret;
356 }
357 chip->vbus_on = true;
358 }
359
360 desc.usb_pd = false;
361 desc.accessory = stusb160x_get_accessory(status);
362 desc.identity = NULL;
363
364 chip->partner = typec_register_partner(port: chip->port, desc: &desc);
365 if (IS_ERR(ptr: chip->partner)) {
366 ret = PTR_ERR(ptr: chip->partner);
367 goto vbus_disable;
368 }
369
370 typec_set_pwr_role(port: chip->port, STUSB160X_CC_POWER_ROLE(status));
371 typec_set_pwr_opmode(port: chip->port, mode: stusb160x_get_pwr_opmode(chip));
372 typec_set_vconn_role(port: chip->port, role: stusb160x_get_vconn_role(status));
373 stusb160x_set_data_role(chip, STUSB160X_CC_DATA_ROLE(status), attached: true);
374
375 return 0;
376
377vbus_disable:
378 if (chip->vbus_on) {
379 regulator_disable(regulator: chip->vdd_supply);
380 chip->vbus_on = false;
381 }
382
383 return ret;
384}
385
386static void stusb160x_detach(struct stusb160x *chip, u32 status)
387{
388 typec_unregister_partner(partner: chip->partner);
389 chip->partner = NULL;
390
391 typec_set_pwr_role(port: chip->port, STUSB160X_CC_POWER_ROLE(status));
392 typec_set_pwr_opmode(port: chip->port, mode: TYPEC_PWR_MODE_USB);
393 typec_set_vconn_role(port: chip->port, role: stusb160x_get_vconn_role(status));
394 stusb160x_set_data_role(chip, STUSB160X_CC_DATA_ROLE(status), attached: false);
395
396 if (chip->vbus_on) {
397 regulator_disable(regulator: chip->vdd_supply);
398 chip->vbus_on = false;
399 }
400}
401
402static irqreturn_t stusb160x_irq_handler(int irq, void *data)
403{
404 struct stusb160x *chip = data;
405 u32 pending, trans, status;
406 int ret;
407
408 ret = regmap_read(map: chip->regmap, STUSB160X_ALERT_STATUS, val: &pending);
409 if (ret)
410 goto err;
411
412 if (pending & STUSB160X_CC_CONNECTION) {
413 ret = regmap_read(map: chip->regmap,
414 STUSB160X_CC_CONNECTION_STATUS_TRANS, val: &trans);
415 if (ret)
416 goto err;
417 ret = regmap_read(map: chip->regmap,
418 STUSB160X_CC_CONNECTION_STATUS, val: &status);
419 if (ret)
420 goto err;
421
422 if (trans & STUSB160X_CC_ATTACH_TRANS) {
423 if (status & STUSB160X_CC_ATTACH) {
424 ret = stusb160x_attach(chip, status);
425 if (ret)
426 goto err;
427 } else {
428 stusb160x_detach(chip, status);
429 }
430 }
431 }
432err:
433 return IRQ_HANDLED;
434}
435
436static int stusb160x_irq_init(struct stusb160x *chip, int irq)
437{
438 u32 status;
439 int ret;
440
441 ret = regmap_read(map: chip->regmap,
442 STUSB160X_CC_CONNECTION_STATUS, val: &status);
443 if (ret)
444 return ret;
445
446 if (status & STUSB160X_CC_ATTACH) {
447 ret = stusb160x_attach(chip, status);
448 if (ret)
449 dev_err(chip->dev, "attach failed: %d\n", ret);
450 }
451
452 ret = devm_request_threaded_irq(dev: chip->dev, irq, NULL,
453 thread_fn: stusb160x_irq_handler, IRQF_ONESHOT,
454 devname: dev_name(dev: chip->dev), dev_id: chip);
455 if (ret)
456 goto partner_unregister;
457
458 /* Unmask CC_CONNECTION events */
459 ret = regmap_write_bits(map: chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
460 STUSB160X_CC_CONNECTION, val: 0);
461 if (ret)
462 goto partner_unregister;
463
464 return 0;
465
466partner_unregister:
467 if (chip->partner) {
468 typec_unregister_partner(partner: chip->partner);
469 chip->partner = NULL;
470 }
471
472 return ret;
473}
474
475static int stusb160x_chip_init(struct stusb160x *chip)
476{
477 u32 val;
478 int ret;
479
480 /* Change the default Type-C power mode */
481 if (chip->port_type == TYPEC_PORT_SRC)
482 ret = regmap_update_bits(map: chip->regmap,
483 STUSB160X_CC_POWER_MODE_CTRL,
484 STUSB160X_CC_POWER_MODE,
485 val: SOURCE_WITH_ACCESSORY);
486 else if (chip->port_type == TYPEC_PORT_SNK)
487 ret = regmap_update_bits(map: chip->regmap,
488 STUSB160X_CC_POWER_MODE_CTRL,
489 STUSB160X_CC_POWER_MODE,
490 val: SINK_WITH_ACCESSORY);
491 else /* (chip->port_type == TYPEC_PORT_DRP) */
492 ret = regmap_update_bits(map: chip->regmap,
493 STUSB160X_CC_POWER_MODE_CTRL,
494 STUSB160X_CC_POWER_MODE,
495 val: DUAL_WITH_ACCESSORY);
496 if (ret)
497 return ret;
498
499 if (chip->port_type == TYPEC_PORT_SNK)
500 goto skip_src;
501
502 /* Change the default Type-C Source power operation mode capability */
503 ret = regmap_update_bits(map: chip->regmap, STUSB160X_CC_CAPABILITY_CTRL,
504 STUSB160X_CC_CURRENT_ADVERTISED,
505 FIELD_PREP(STUSB160X_CC_CURRENT_ADVERTISED,
506 chip->pwr_opmode));
507 if (ret)
508 return ret;
509
510 /* Manage Type-C Source Vconn supply */
511 if (stusb160x_get_vconn(chip)) {
512 ret = stusb160x_set_vconn(chip, on: true);
513 if (ret)
514 return ret;
515 }
516
517skip_src:
518 /* Mask all events interrupts - to be unmasked with interrupt support */
519 ret = regmap_update_bits(map: chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
520 STUSB160X_ALL_ALERTS, STUSB160X_ALL_ALERTS);
521 if (ret)
522 return ret;
523
524 /* Read status at least once to clear any stale interrupts */
525 regmap_read(map: chip->regmap, STUSB160X_ALERT_STATUS, val: &val);
526 regmap_read(map: chip->regmap, STUSB160X_CC_CONNECTION_STATUS_TRANS, val: &val);
527 regmap_read(map: chip->regmap, STUSB160X_MONITORING_STATUS_TRANS, val: &val);
528 regmap_read(map: chip->regmap, STUSB160X_HW_FAULT_STATUS_TRANS, val: &val);
529
530 return 0;
531}
532
533static int stusb160x_get_fw_caps(struct stusb160x *chip,
534 struct fwnode_handle *fwnode)
535{
536 const char *cap_str;
537 int ret;
538
539 chip->capability.fwnode = fwnode;
540
541 /*
542 * Supported port type can be configured through device tree
543 * else it is read from chip registers in stusb160x_get_caps.
544 */
545 ret = fwnode_property_read_string(fwnode, propname: "power-role", val: &cap_str);
546 if (!ret) {
547 ret = typec_find_port_power_role(name: cap_str);
548 if (ret < 0)
549 return ret;
550 chip->port_type = ret;
551 }
552 chip->capability.type = chip->port_type;
553
554 /* Skip DRP/Source capabilities in case of Sink only */
555 if (chip->port_type == TYPEC_PORT_SNK)
556 return 0;
557
558 if (chip->port_type == TYPEC_PORT_DRP)
559 chip->capability.prefer_role = TYPEC_SINK;
560
561 /*
562 * Supported power operation mode can be configured through device tree
563 * else it is read from chip registers in stusb160x_get_caps.
564 */
565 ret = fwnode_property_read_string(fwnode, propname: "typec-power-opmode", val: &cap_str);
566 if (!ret) {
567 ret = typec_find_pwr_opmode(name: cap_str);
568 /* Power delivery not yet supported */
569 if (ret < 0 || ret == TYPEC_PWR_MODE_PD) {
570 dev_err(chip->dev, "bad power operation mode: %d\n", ret);
571 return -EINVAL;
572 }
573 chip->pwr_opmode = ret;
574 }
575
576 return 0;
577}
578
579static int stusb160x_get_caps(struct stusb160x *chip)
580{
581 enum typec_port_type *type = &chip->capability.type;
582 enum typec_port_data *data = &chip->capability.data;
583 enum typec_accessory *accessory = chip->capability.accessory;
584 u32 val;
585 int ret;
586
587 chip->capability.revision = USB_TYPEC_REV_1_2;
588
589 ret = regmap_read(map: chip->regmap, STUSB160X_CC_POWER_MODE_CTRL, val: &val);
590 if (ret)
591 return ret;
592
593 switch (FIELD_GET(STUSB160X_CC_POWER_MODE, val)) {
594 case SOURCE_WITH_ACCESSORY:
595 *type = TYPEC_PORT_SRC;
596 *data = TYPEC_PORT_DFP;
597 *accessory++ = TYPEC_ACCESSORY_AUDIO;
598 *accessory++ = TYPEC_ACCESSORY_DEBUG;
599 break;
600 case SINK_WITH_ACCESSORY:
601 *type = TYPEC_PORT_SNK;
602 *data = TYPEC_PORT_UFP;
603 *accessory++ = TYPEC_ACCESSORY_AUDIO;
604 *accessory++ = TYPEC_ACCESSORY_DEBUG;
605 break;
606 case SINK_WITHOUT_ACCESSORY:
607 *type = TYPEC_PORT_SNK;
608 *data = TYPEC_PORT_UFP;
609 break;
610 case DUAL_WITH_ACCESSORY:
611 case DUAL_WITH_ACCESSORY_AND_TRY_SRC:
612 case DUAL_WITH_ACCESSORY_AND_TRY_SNK:
613 *type = TYPEC_PORT_DRP;
614 *data = TYPEC_PORT_DRD;
615 *accessory++ = TYPEC_ACCESSORY_AUDIO;
616 *accessory++ = TYPEC_ACCESSORY_DEBUG;
617 break;
618 default:
619 return -EINVAL;
620 }
621
622 chip->port_type = *type;
623 chip->pwr_opmode = stusb160x_get_pwr_opmode(chip);
624
625 return 0;
626}
627
628static const struct of_device_id stusb160x_of_match[] = {
629 { .compatible = "st,stusb1600", .data = &stusb1600_regmap_config},
630 {},
631};
632MODULE_DEVICE_TABLE(of, stusb160x_of_match);
633
634static int stusb160x_probe(struct i2c_client *client)
635{
636 const struct regmap_config *regmap_config;
637 struct stusb160x *chip;
638 struct fwnode_handle *fwnode;
639 int ret;
640
641 chip = devm_kzalloc(dev: &client->dev, size: sizeof(struct stusb160x), GFP_KERNEL);
642 if (!chip)
643 return -ENOMEM;
644
645 i2c_set_clientdata(client, data: chip);
646
647 regmap_config = i2c_get_match_data(client);
648
649 chip->regmap = devm_regmap_init_i2c(client, regmap_config);
650 if (IS_ERR(ptr: chip->regmap)) {
651 ret = PTR_ERR(ptr: chip->regmap);
652 dev_err(&client->dev,
653 "Failed to allocate register map:%d\n", ret);
654 return ret;
655 }
656
657 chip->dev = &client->dev;
658
659 chip->vsys_supply = devm_regulator_get_optional(dev: chip->dev, id: "vsys");
660 if (IS_ERR(ptr: chip->vsys_supply)) {
661 ret = PTR_ERR(ptr: chip->vsys_supply);
662 if (ret != -ENODEV)
663 return ret;
664 chip->vsys_supply = NULL;
665 }
666
667 chip->vdd_supply = devm_regulator_get_optional(dev: chip->dev, id: "vdd");
668 if (IS_ERR(ptr: chip->vdd_supply)) {
669 ret = PTR_ERR(ptr: chip->vdd_supply);
670 if (ret != -ENODEV)
671 return ret;
672 chip->vdd_supply = NULL;
673 }
674
675 chip->vconn_supply = devm_regulator_get_optional(dev: chip->dev, id: "vconn");
676 if (IS_ERR(ptr: chip->vconn_supply)) {
677 ret = PTR_ERR(ptr: chip->vconn_supply);
678 if (ret != -ENODEV)
679 return ret;
680 chip->vconn_supply = NULL;
681 }
682
683 fwnode = device_get_named_child_node(dev: chip->dev, childname: "connector");
684 if (!fwnode)
685 return -ENODEV;
686
687 /*
688 * This fwnode has a "compatible" property, but is never populated as a
689 * struct device. Instead we simply parse it to read the properties.
690 * This it breaks fw_devlink=on. To maintain backward compatibility
691 * with existing DT files, we work around this by deleting any
692 * fwnode_links to/from this fwnode.
693 */
694 fw_devlink_purge_absent_suppliers(fwnode);
695
696 /*
697 * When both VDD and VSYS power supplies are present, the low power
698 * supply VSYS is selected when VSYS voltage is above 3.1 V.
699 * Otherwise VDD is selected.
700 */
701 if (chip->vdd_supply &&
702 (!chip->vsys_supply ||
703 (regulator_get_voltage(regulator: chip->vsys_supply) <= 3100000)))
704 chip->main_supply = chip->vdd_supply;
705 else
706 chip->main_supply = chip->vsys_supply;
707
708 if (chip->main_supply) {
709 ret = regulator_enable(regulator: chip->main_supply);
710 if (ret) {
711 dev_err(chip->dev,
712 "Failed to enable main supply: %d\n", ret);
713 goto fwnode_put;
714 }
715 }
716
717 /* Get configuration from chip */
718 ret = stusb160x_get_caps(chip);
719 if (ret) {
720 dev_err(chip->dev, "Failed to get port caps: %d\n", ret);
721 goto main_reg_disable;
722 }
723
724 /* Get optional re-configuration from device tree */
725 ret = stusb160x_get_fw_caps(chip, fwnode);
726 if (ret) {
727 dev_err(chip->dev, "Failed to get connector caps: %d\n", ret);
728 goto main_reg_disable;
729 }
730
731 ret = stusb160x_chip_init(chip);
732 if (ret) {
733 dev_err(chip->dev, "Failed to init port: %d\n", ret);
734 goto main_reg_disable;
735 }
736
737 chip->port = typec_register_port(parent: chip->dev, cap: &chip->capability);
738 if (IS_ERR(ptr: chip->port)) {
739 ret = PTR_ERR(ptr: chip->port);
740 goto all_reg_disable;
741 }
742
743 /*
744 * Default power operation mode initialization: will be updated upon
745 * attach/detach interrupt
746 */
747 typec_set_pwr_opmode(port: chip->port, mode: chip->pwr_opmode);
748
749 if (client->irq) {
750 chip->role_sw = fwnode_usb_role_switch_get(node: fwnode);
751 if (IS_ERR(ptr: chip->role_sw)) {
752 ret = dev_err_probe(dev: chip->dev, err: PTR_ERR(ptr: chip->role_sw),
753 fmt: "Failed to get usb role switch\n");
754 goto port_unregister;
755 }
756
757 ret = stusb160x_irq_init(chip, irq: client->irq);
758 if (ret)
759 goto role_sw_put;
760 } else {
761 /*
762 * If Source or Dual power role, need to enable VDD supply
763 * providing Vbus if present. In case of interrupt support,
764 * VDD supply will be dynamically managed upon attach/detach
765 * interrupt.
766 */
767 if (chip->port_type != TYPEC_PORT_SNK && chip->vdd_supply) {
768 ret = regulator_enable(regulator: chip->vdd_supply);
769 if (ret) {
770 dev_err(chip->dev,
771 "Failed to enable VDD supply: %d\n",
772 ret);
773 goto port_unregister;
774 }
775 chip->vbus_on = true;
776 }
777 }
778
779 fwnode_handle_put(fwnode);
780
781 return 0;
782
783role_sw_put:
784 if (chip->role_sw)
785 usb_role_switch_put(sw: chip->role_sw);
786port_unregister:
787 typec_unregister_port(port: chip->port);
788all_reg_disable:
789 if (stusb160x_get_vconn(chip))
790 stusb160x_set_vconn(chip, on: false);
791main_reg_disable:
792 if (chip->main_supply)
793 regulator_disable(regulator: chip->main_supply);
794fwnode_put:
795 fwnode_handle_put(fwnode);
796
797 return ret;
798}
799
800static void stusb160x_remove(struct i2c_client *client)
801{
802 struct stusb160x *chip = i2c_get_clientdata(client);
803
804 if (chip->partner) {
805 typec_unregister_partner(partner: chip->partner);
806 chip->partner = NULL;
807 }
808
809 if (chip->vbus_on)
810 regulator_disable(regulator: chip->vdd_supply);
811
812 if (chip->role_sw)
813 usb_role_switch_put(sw: chip->role_sw);
814
815 typec_unregister_port(port: chip->port);
816
817 if (stusb160x_get_vconn(chip))
818 stusb160x_set_vconn(chip, on: false);
819
820 if (chip->main_supply)
821 regulator_disable(regulator: chip->main_supply);
822}
823
824static int __maybe_unused stusb160x_suspend(struct device *dev)
825{
826 struct stusb160x *chip = dev_get_drvdata(dev);
827
828 /* Mask interrupts */
829 return regmap_update_bits(map: chip->regmap,
830 STUSB160X_ALERT_STATUS_MASK_CTRL,
831 STUSB160X_ALL_ALERTS, STUSB160X_ALL_ALERTS);
832}
833
834static int __maybe_unused stusb160x_resume(struct device *dev)
835{
836 struct stusb160x *chip = dev_get_drvdata(dev);
837 u32 status;
838 int ret;
839
840 ret = regcache_sync(map: chip->regmap);
841 if (ret)
842 return ret;
843
844 /* Check if attach/detach occurred during low power */
845 ret = regmap_read(map: chip->regmap,
846 STUSB160X_CC_CONNECTION_STATUS, val: &status);
847 if (ret)
848 return ret;
849
850 if (chip->partner && !(status & STUSB160X_CC_ATTACH))
851 stusb160x_detach(chip, status);
852
853 if (!chip->partner && (status & STUSB160X_CC_ATTACH)) {
854 ret = stusb160x_attach(chip, status);
855 if (ret)
856 dev_err(chip->dev, "attach failed: %d\n", ret);
857 }
858
859 /* Unmask interrupts */
860 return regmap_write_bits(map: chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
861 STUSB160X_CC_CONNECTION, val: 0);
862}
863
864static SIMPLE_DEV_PM_OPS(stusb160x_pm_ops, stusb160x_suspend, stusb160x_resume);
865
866static struct i2c_driver stusb160x_driver = {
867 .driver = {
868 .name = "stusb160x",
869 .pm = &stusb160x_pm_ops,
870 .of_match_table = stusb160x_of_match,
871 },
872 .probe = stusb160x_probe,
873 .remove = stusb160x_remove,
874};
875module_i2c_driver(stusb160x_driver);
876
877MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
878MODULE_DESCRIPTION("STMicroelectronics STUSB160x Type-C controller driver");
879MODULE_LICENSE("GPL v2");
880

source code of linux/drivers/usb/typec/stusb160x.c