Merge branch 'for-linus' into for-next
[linux-2.6-microblaze.git] / drivers / usb / typec / tipd / core.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for TI TPS6598x USB Power Delivery controller family
4  *
5  * Copyright (C) 2017, Intel Corporation
6  * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
7  */
8
9 #include <linux/i2c.h>
10 #include <linux/acpi.h>
11 #include <linux/module.h>
12 #include <linux/power_supply.h>
13 #include <linux/regmap.h>
14 #include <linux/interrupt.h>
15 #include <linux/usb/typec.h>
16 #include <linux/usb/role.h>
17
18 #include "tps6598x.h"
19 #include "trace.h"
20
21 /* Register offsets */
22 #define TPS_REG_VID                     0x00
23 #define TPS_REG_MODE                    0x03
24 #define TPS_REG_CMD1                    0x08
25 #define TPS_REG_DATA1                   0x09
26 #define TPS_REG_INT_EVENT1              0x14
27 #define TPS_REG_INT_EVENT2              0x15
28 #define TPS_REG_INT_MASK1               0x16
29 #define TPS_REG_INT_MASK2               0x17
30 #define TPS_REG_INT_CLEAR1              0x18
31 #define TPS_REG_INT_CLEAR2              0x19
32 #define TPS_REG_STATUS                  0x1a
33 #define TPS_REG_SYSTEM_CONF             0x28
34 #define TPS_REG_CTRL_CONF               0x29
35 #define TPS_REG_POWER_STATUS            0x3f
36 #define TPS_REG_RX_IDENTITY_SOP         0x48
37 #define TPS_REG_DATA_STATUS             0x5f
38
39 /* TPS_REG_SYSTEM_CONF bits */
40 #define TPS_SYSCONF_PORTINFO(c)         ((c) & 7)
41
42 enum {
43         TPS_PORTINFO_SINK,
44         TPS_PORTINFO_SINK_ACCESSORY,
45         TPS_PORTINFO_DRP_UFP,
46         TPS_PORTINFO_DRP_UFP_DRD,
47         TPS_PORTINFO_DRP_DFP,
48         TPS_PORTINFO_DRP_DFP_DRD,
49         TPS_PORTINFO_SOURCE,
50 };
51
52 /* TPS_REG_RX_IDENTITY_SOP */
53 struct tps6598x_rx_identity_reg {
54         u8 status;
55         struct usb_pd_identity identity;
56 } __packed;
57
58 /* Standard Task return codes */
59 #define TPS_TASK_TIMEOUT                1
60 #define TPS_TASK_REJECTED               3
61
62 enum {
63         TPS_MODE_APP,
64         TPS_MODE_BOOT,
65         TPS_MODE_BIST,
66         TPS_MODE_DISC,
67 };
68
69 static const char *const modes[] = {
70         [TPS_MODE_APP]  = "APP ",
71         [TPS_MODE_BOOT] = "BOOT",
72         [TPS_MODE_BIST] = "BIST",
73         [TPS_MODE_DISC] = "DISC",
74 };
75
76 /* Unrecognized commands will be replaced with "!CMD" */
77 #define INVALID_CMD(_cmd_)              (_cmd_ == 0x444d4321)
78
79 struct tps6598x {
80         struct device *dev;
81         struct regmap *regmap;
82         struct mutex lock; /* device lock */
83         u8 i2c_protocol:1;
84
85         struct typec_port *port;
86         struct typec_partner *partner;
87         struct usb_pd_identity partner_identity;
88         struct usb_role_switch *role_sw;
89         struct typec_capability typec_cap;
90
91         struct power_supply *psy;
92         struct power_supply_desc psy_desc;
93         enum power_supply_usb_type usb_type;
94 };
95
96 static enum power_supply_property tps6598x_psy_props[] = {
97         POWER_SUPPLY_PROP_USB_TYPE,
98         POWER_SUPPLY_PROP_ONLINE,
99 };
100
101 static enum power_supply_usb_type tps6598x_psy_usb_types[] = {
102         POWER_SUPPLY_USB_TYPE_C,
103         POWER_SUPPLY_USB_TYPE_PD,
104 };
105
106 static const char *tps6598x_psy_name_prefix = "tps6598x-source-psy-";
107
108 /*
109  * Max data bytes for Data1, Data2, and other registers. See ch 1.3.2:
110  * https://www.ti.com/lit/ug/slvuan1a/slvuan1a.pdf
111  */
112 #define TPS_MAX_LEN     64
113
114 static int
115 tps6598x_block_read(struct tps6598x *tps, u8 reg, void *val, size_t len)
116 {
117         u8 data[TPS_MAX_LEN + 1];
118         int ret;
119
120         if (WARN_ON(len + 1 > sizeof(data)))
121                 return -EINVAL;
122
123         if (!tps->i2c_protocol)
124                 return regmap_raw_read(tps->regmap, reg, val, len);
125
126         ret = regmap_raw_read(tps->regmap, reg, data, sizeof(data));
127         if (ret)
128                 return ret;
129
130         if (data[0] < len)
131                 return -EIO;
132
133         memcpy(val, &data[1], len);
134         return 0;
135 }
136
137 static int tps6598x_block_write(struct tps6598x *tps, u8 reg,
138                                 const void *val, size_t len)
139 {
140         u8 data[TPS_MAX_LEN + 1];
141
142         if (!tps->i2c_protocol)
143                 return regmap_raw_write(tps->regmap, reg, val, len);
144
145         data[0] = len;
146         memcpy(&data[1], val, len);
147
148         return regmap_raw_write(tps->regmap, reg, data, sizeof(data));
149 }
150
151 static inline int tps6598x_read16(struct tps6598x *tps, u8 reg, u16 *val)
152 {
153         return tps6598x_block_read(tps, reg, val, sizeof(u16));
154 }
155
156 static inline int tps6598x_read32(struct tps6598x *tps, u8 reg, u32 *val)
157 {
158         return tps6598x_block_read(tps, reg, val, sizeof(u32));
159 }
160
161 static inline int tps6598x_read64(struct tps6598x *tps, u8 reg, u64 *val)
162 {
163         return tps6598x_block_read(tps, reg, val, sizeof(u64));
164 }
165
166 static inline int tps6598x_write16(struct tps6598x *tps, u8 reg, u16 val)
167 {
168         return tps6598x_block_write(tps, reg, &val, sizeof(u16));
169 }
170
171 static inline int tps6598x_write32(struct tps6598x *tps, u8 reg, u32 val)
172 {
173         return tps6598x_block_write(tps, reg, &val, sizeof(u32));
174 }
175
176 static inline int tps6598x_write64(struct tps6598x *tps, u8 reg, u64 val)
177 {
178         return tps6598x_block_write(tps, reg, &val, sizeof(u64));
179 }
180
181 static inline int
182 tps6598x_write_4cc(struct tps6598x *tps, u8 reg, const char *val)
183 {
184         return tps6598x_block_write(tps, reg, val, 4);
185 }
186
187 static int tps6598x_read_partner_identity(struct tps6598x *tps)
188 {
189         struct tps6598x_rx_identity_reg id;
190         int ret;
191
192         ret = tps6598x_block_read(tps, TPS_REG_RX_IDENTITY_SOP,
193                                   &id, sizeof(id));
194         if (ret)
195                 return ret;
196
197         tps->partner_identity = id.identity;
198
199         return 0;
200 }
201
202 static void tps6598x_set_data_role(struct tps6598x *tps,
203                                    enum typec_data_role role, bool connected)
204 {
205         enum usb_role role_val;
206
207         if (role == TYPEC_HOST)
208                 role_val = USB_ROLE_HOST;
209         else
210                 role_val = USB_ROLE_DEVICE;
211
212         if (!connected)
213                 role_val = USB_ROLE_NONE;
214
215         usb_role_switch_set_role(tps->role_sw, role_val);
216         typec_set_data_role(tps->port, role);
217 }
218
219 static int tps6598x_connect(struct tps6598x *tps, u32 status)
220 {
221         struct typec_partner_desc desc;
222         enum typec_pwr_opmode mode;
223         u16 pwr_status;
224         int ret;
225
226         if (tps->partner)
227                 return 0;
228
229         ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
230         if (ret < 0)
231                 return ret;
232
233         mode = TPS_POWER_STATUS_PWROPMODE(pwr_status);
234
235         desc.usb_pd = mode == TYPEC_PWR_MODE_PD;
236         desc.accessory = TYPEC_ACCESSORY_NONE; /* XXX: handle accessories */
237         desc.identity = NULL;
238
239         if (desc.usb_pd) {
240                 ret = tps6598x_read_partner_identity(tps);
241                 if (ret)
242                         return ret;
243                 desc.identity = &tps->partner_identity;
244         }
245
246         typec_set_pwr_opmode(tps->port, mode);
247         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
248         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
249         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), true);
250
251         tps->partner = typec_register_partner(tps->port, &desc);
252         if (IS_ERR(tps->partner))
253                 return PTR_ERR(tps->partner);
254
255         if (desc.identity)
256                 typec_partner_set_identity(tps->partner);
257
258         power_supply_changed(tps->psy);
259
260         return 0;
261 }
262
263 static void tps6598x_disconnect(struct tps6598x *tps, u32 status)
264 {
265         if (!IS_ERR(tps->partner))
266                 typec_unregister_partner(tps->partner);
267         tps->partner = NULL;
268         typec_set_pwr_opmode(tps->port, TYPEC_PWR_MODE_USB);
269         typec_set_pwr_role(tps->port, TPS_STATUS_TO_TYPEC_PORTROLE(status));
270         typec_set_vconn_role(tps->port, TPS_STATUS_TO_TYPEC_VCONN(status));
271         tps6598x_set_data_role(tps, TPS_STATUS_TO_TYPEC_DATAROLE(status), false);
272
273         power_supply_changed(tps->psy);
274 }
275
276 static int tps6598x_exec_cmd(struct tps6598x *tps, const char *cmd,
277                              size_t in_len, u8 *in_data,
278                              size_t out_len, u8 *out_data)
279 {
280         unsigned long timeout;
281         u32 val;
282         int ret;
283
284         ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
285         if (ret)
286                 return ret;
287         if (val && !INVALID_CMD(val))
288                 return -EBUSY;
289
290         if (in_len) {
291                 ret = tps6598x_block_write(tps, TPS_REG_DATA1,
292                                            in_data, in_len);
293                 if (ret)
294                         return ret;
295         }
296
297         ret = tps6598x_write_4cc(tps, TPS_REG_CMD1, cmd);
298         if (ret < 0)
299                 return ret;
300
301         /* XXX: Using 1s for now, but it may not be enough for every command. */
302         timeout = jiffies + msecs_to_jiffies(1000);
303
304         do {
305                 ret = tps6598x_read32(tps, TPS_REG_CMD1, &val);
306                 if (ret)
307                         return ret;
308                 if (INVALID_CMD(val))
309                         return -EINVAL;
310
311                 if (time_is_before_jiffies(timeout))
312                         return -ETIMEDOUT;
313         } while (val);
314
315         if (out_len) {
316                 ret = tps6598x_block_read(tps, TPS_REG_DATA1,
317                                           out_data, out_len);
318                 if (ret)
319                         return ret;
320                 val = out_data[0];
321         } else {
322                 ret = tps6598x_block_read(tps, TPS_REG_DATA1, &val, sizeof(u8));
323                 if (ret)
324                         return ret;
325         }
326
327         switch (val) {
328         case TPS_TASK_TIMEOUT:
329                 return -ETIMEDOUT;
330         case TPS_TASK_REJECTED:
331                 return -EPERM;
332         default:
333                 break;
334         }
335
336         return 0;
337 }
338
339 static int tps6598x_dr_set(struct typec_port *port, enum typec_data_role role)
340 {
341         const char *cmd = (role == TYPEC_DEVICE) ? "SWUF" : "SWDF";
342         struct tps6598x *tps = typec_get_drvdata(port);
343         u32 status;
344         int ret;
345
346         mutex_lock(&tps->lock);
347
348         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
349         if (ret)
350                 goto out_unlock;
351
352         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
353         if (ret)
354                 goto out_unlock;
355
356         if (role != TPS_STATUS_TO_TYPEC_DATAROLE(status)) {
357                 ret = -EPROTO;
358                 goto out_unlock;
359         }
360
361         tps6598x_set_data_role(tps, role, true);
362
363 out_unlock:
364         mutex_unlock(&tps->lock);
365
366         return ret;
367 }
368
369 static int tps6598x_pr_set(struct typec_port *port, enum typec_role role)
370 {
371         const char *cmd = (role == TYPEC_SINK) ? "SWSk" : "SWSr";
372         struct tps6598x *tps = typec_get_drvdata(port);
373         u32 status;
374         int ret;
375
376         mutex_lock(&tps->lock);
377
378         ret = tps6598x_exec_cmd(tps, cmd, 0, NULL, 0, NULL);
379         if (ret)
380                 goto out_unlock;
381
382         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
383         if (ret)
384                 goto out_unlock;
385
386         if (role != TPS_STATUS_TO_TYPEC_PORTROLE(status)) {
387                 ret = -EPROTO;
388                 goto out_unlock;
389         }
390
391         typec_set_pwr_role(tps->port, role);
392
393 out_unlock:
394         mutex_unlock(&tps->lock);
395
396         return ret;
397 }
398
399 static const struct typec_operations tps6598x_ops = {
400         .dr_set = tps6598x_dr_set,
401         .pr_set = tps6598x_pr_set,
402 };
403
404 static irqreturn_t tps6598x_interrupt(int irq, void *data)
405 {
406         struct tps6598x *tps = data;
407         u64 event1;
408         u64 event2;
409         u32 status, data_status;
410         u16 pwr_status;
411         int ret;
412
413         mutex_lock(&tps->lock);
414
415         ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
416         ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
417         if (ret) {
418                 dev_err(tps->dev, "%s: failed to read events\n", __func__);
419                 goto err_unlock;
420         }
421         trace_tps6598x_irq(event1, event2);
422
423         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
424         if (ret) {
425                 dev_err(tps->dev, "%s: failed to read status\n", __func__);
426                 goto err_clear_ints;
427         }
428         trace_tps6598x_status(status);
429
430         if ((event1 | event2) & TPS_REG_INT_POWER_STATUS_UPDATE) {
431                 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
432                 if (ret < 0) {
433                         dev_err(tps->dev, "failed to read power status: %d\n", ret);
434                         goto err_clear_ints;
435                 }
436                 trace_tps6598x_power_status(pwr_status);
437         }
438
439         if ((event1 | event2) & TPS_REG_INT_DATA_STATUS_UPDATE) {
440                 ret = tps6598x_read32(tps, TPS_REG_DATA_STATUS, &data_status);
441                 if (ret < 0) {
442                         dev_err(tps->dev, "failed to read data status: %d\n", ret);
443                         goto err_clear_ints;
444                 }
445                 trace_tps6598x_data_status(data_status);
446         }
447
448         /* Handle plug insert or removal */
449         if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT) {
450                 if (status & TPS_STATUS_PLUG_PRESENT) {
451                         ret = tps6598x_connect(tps, status);
452                         if (ret)
453                                 dev_err(tps->dev,
454                                         "failed to register partner\n");
455                 } else {
456                         tps6598x_disconnect(tps, status);
457                 }
458         }
459
460 err_clear_ints:
461         tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
462         tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
463
464 err_unlock:
465         mutex_unlock(&tps->lock);
466
467         return IRQ_HANDLED;
468 }
469
470 static int tps6598x_check_mode(struct tps6598x *tps)
471 {
472         char mode[5] = { };
473         int ret;
474
475         ret = tps6598x_read32(tps, TPS_REG_MODE, (void *)mode);
476         if (ret)
477                 return ret;
478
479         switch (match_string(modes, ARRAY_SIZE(modes), mode)) {
480         case TPS_MODE_APP:
481                 return 0;
482         case TPS_MODE_BOOT:
483                 dev_warn(tps->dev, "dead-battery condition\n");
484                 return 0;
485         case TPS_MODE_BIST:
486         case TPS_MODE_DISC:
487         default:
488                 dev_err(tps->dev, "controller in unsupported mode \"%s\"\n",
489                         mode);
490                 break;
491         }
492
493         return -ENODEV;
494 }
495
496 static const struct regmap_config tps6598x_regmap_config = {
497         .reg_bits = 8,
498         .val_bits = 8,
499         .max_register = 0x7F,
500 };
501
502 static int tps6598x_psy_get_online(struct tps6598x *tps,
503                                    union power_supply_propval *val)
504 {
505         int ret;
506         u16 pwr_status;
507
508         ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
509         if (ret < 0)
510                 return ret;
511
512         if (TPS_POWER_STATUS_CONNECTION(pwr_status) &&
513             TPS_POWER_STATUS_SOURCESINK(pwr_status)) {
514                 val->intval = 1;
515         } else {
516                 val->intval = 0;
517         }
518         return 0;
519 }
520
521 static int tps6598x_psy_get_prop(struct power_supply *psy,
522                                  enum power_supply_property psp,
523                                  union power_supply_propval *val)
524 {
525         struct tps6598x *tps = power_supply_get_drvdata(psy);
526         u16 pwr_status;
527         int ret = 0;
528
529         switch (psp) {
530         case POWER_SUPPLY_PROP_USB_TYPE:
531                 ret = tps6598x_read16(tps, TPS_REG_POWER_STATUS, &pwr_status);
532                 if (ret < 0)
533                         return ret;
534                 if (TPS_POWER_STATUS_PWROPMODE(pwr_status) == TYPEC_PWR_MODE_PD)
535                         val->intval = POWER_SUPPLY_USB_TYPE_PD;
536                 else
537                         val->intval = POWER_SUPPLY_USB_TYPE_C;
538                 break;
539         case POWER_SUPPLY_PROP_ONLINE:
540                 ret = tps6598x_psy_get_online(tps, val);
541                 break;
542         default:
543                 ret = -EINVAL;
544                 break;
545         }
546
547         return ret;
548 }
549
550 static int devm_tps6598_psy_register(struct tps6598x *tps)
551 {
552         struct power_supply_config psy_cfg = {};
553         const char *port_dev_name = dev_name(tps->dev);
554         char *psy_name;
555
556         psy_cfg.drv_data = tps;
557         psy_cfg.fwnode = dev_fwnode(tps->dev);
558
559         psy_name = devm_kasprintf(tps->dev, GFP_KERNEL, "%s%s", tps6598x_psy_name_prefix,
560                                   port_dev_name);
561         if (!psy_name)
562                 return -ENOMEM;
563
564         tps->psy_desc.name = psy_name;
565         tps->psy_desc.type = POWER_SUPPLY_TYPE_USB;
566         tps->psy_desc.usb_types = tps6598x_psy_usb_types;
567         tps->psy_desc.num_usb_types = ARRAY_SIZE(tps6598x_psy_usb_types);
568         tps->psy_desc.properties = tps6598x_psy_props;
569         tps->psy_desc.num_properties = ARRAY_SIZE(tps6598x_psy_props);
570         tps->psy_desc.get_property = tps6598x_psy_get_prop;
571
572         tps->usb_type = POWER_SUPPLY_USB_TYPE_C;
573
574         tps->psy = devm_power_supply_register(tps->dev, &tps->psy_desc,
575                                                &psy_cfg);
576         return PTR_ERR_OR_ZERO(tps->psy);
577 }
578
579 static int tps6598x_probe(struct i2c_client *client)
580 {
581         struct typec_capability typec_cap = { };
582         struct tps6598x *tps;
583         struct fwnode_handle *fwnode;
584         u32 status;
585         u32 conf;
586         u32 vid;
587         int ret;
588
589         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
590         if (!tps)
591                 return -ENOMEM;
592
593         mutex_init(&tps->lock);
594         tps->dev = &client->dev;
595
596         tps->regmap = devm_regmap_init_i2c(client, &tps6598x_regmap_config);
597         if (IS_ERR(tps->regmap))
598                 return PTR_ERR(tps->regmap);
599
600         ret = tps6598x_read32(tps, TPS_REG_VID, &vid);
601         if (ret < 0 || !vid)
602                 return -ENODEV;
603
604         /*
605          * Checking can the adapter handle SMBus protocol. If it can not, the
606          * driver needs to take care of block reads separately.
607          *
608          * FIXME: Testing with I2C_FUNC_I2C. regmap-i2c uses I2C protocol
609          * unconditionally if the adapter has I2C_FUNC_I2C set.
610          */
611         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
612                 tps->i2c_protocol = true;
613
614         /* Make sure the controller has application firmware running */
615         ret = tps6598x_check_mode(tps);
616         if (ret)
617                 return ret;
618
619         ret = tps6598x_read32(tps, TPS_REG_STATUS, &status);
620         if (ret < 0)
621                 return ret;
622         trace_tps6598x_status(status);
623
624         ret = tps6598x_read32(tps, TPS_REG_SYSTEM_CONF, &conf);
625         if (ret < 0)
626                 return ret;
627
628         fwnode = device_get_named_child_node(&client->dev, "connector");
629         if (!fwnode)
630                 return -ENODEV;
631
632         tps->role_sw = fwnode_usb_role_switch_get(fwnode);
633         if (IS_ERR(tps->role_sw)) {
634                 ret = PTR_ERR(tps->role_sw);
635                 goto err_fwnode_put;
636         }
637
638         typec_cap.revision = USB_TYPEC_REV_1_2;
639         typec_cap.pd_revision = 0x200;
640         typec_cap.prefer_role = TYPEC_NO_PREFERRED_ROLE;
641         typec_cap.driver_data = tps;
642         typec_cap.ops = &tps6598x_ops;
643         typec_cap.fwnode = fwnode;
644
645         switch (TPS_SYSCONF_PORTINFO(conf)) {
646         case TPS_PORTINFO_SINK_ACCESSORY:
647         case TPS_PORTINFO_SINK:
648                 typec_cap.type = TYPEC_PORT_SNK;
649                 typec_cap.data = TYPEC_PORT_UFP;
650                 break;
651         case TPS_PORTINFO_DRP_UFP_DRD:
652         case TPS_PORTINFO_DRP_DFP_DRD:
653                 typec_cap.type = TYPEC_PORT_DRP;
654                 typec_cap.data = TYPEC_PORT_DRD;
655                 break;
656         case TPS_PORTINFO_DRP_UFP:
657                 typec_cap.type = TYPEC_PORT_DRP;
658                 typec_cap.data = TYPEC_PORT_UFP;
659                 break;
660         case TPS_PORTINFO_DRP_DFP:
661                 typec_cap.type = TYPEC_PORT_DRP;
662                 typec_cap.data = TYPEC_PORT_DFP;
663                 break;
664         case TPS_PORTINFO_SOURCE:
665                 typec_cap.type = TYPEC_PORT_SRC;
666                 typec_cap.data = TYPEC_PORT_DFP;
667                 break;
668         default:
669                 ret = -ENODEV;
670                 goto err_role_put;
671         }
672
673         ret = devm_tps6598_psy_register(tps);
674         if (ret)
675                 return ret;
676
677         tps->port = typec_register_port(&client->dev, &typec_cap);
678         if (IS_ERR(tps->port)) {
679                 ret = PTR_ERR(tps->port);
680                 goto err_role_put;
681         }
682         fwnode_handle_put(fwnode);
683
684         if (status & TPS_STATUS_PLUG_PRESENT) {
685                 ret = tps6598x_connect(tps, status);
686                 if (ret)
687                         dev_err(&client->dev, "failed to register partner\n");
688         }
689
690         ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
691                                         tps6598x_interrupt,
692                                         IRQF_SHARED | IRQF_ONESHOT,
693                                         dev_name(&client->dev), tps);
694         if (ret) {
695                 tps6598x_disconnect(tps, 0);
696                 typec_unregister_port(tps->port);
697                 goto err_role_put;
698         }
699
700         i2c_set_clientdata(client, tps);
701
702         return 0;
703
704 err_role_put:
705         usb_role_switch_put(tps->role_sw);
706 err_fwnode_put:
707         fwnode_handle_put(fwnode);
708
709         return ret;
710 }
711
712 static int tps6598x_remove(struct i2c_client *client)
713 {
714         struct tps6598x *tps = i2c_get_clientdata(client);
715
716         tps6598x_disconnect(tps, 0);
717         typec_unregister_port(tps->port);
718         usb_role_switch_put(tps->role_sw);
719
720         return 0;
721 }
722
723 static const struct of_device_id tps6598x_of_match[] = {
724         { .compatible = "ti,tps6598x", },
725         {}
726 };
727 MODULE_DEVICE_TABLE(of, tps6598x_of_match);
728
729 static const struct i2c_device_id tps6598x_id[] = {
730         { "tps6598x" },
731         { }
732 };
733 MODULE_DEVICE_TABLE(i2c, tps6598x_id);
734
735 static struct i2c_driver tps6598x_i2c_driver = {
736         .driver = {
737                 .name = "tps6598x",
738                 .of_match_table = tps6598x_of_match,
739         },
740         .probe_new = tps6598x_probe,
741         .remove = tps6598x_remove,
742         .id_table = tps6598x_id,
743 };
744 module_i2c_driver(tps6598x_i2c_driver);
745
746 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
747 MODULE_LICENSE("GPL v2");
748 MODULE_DESCRIPTION("TI TPS6598x USB Power Delivery Controller Driver");