Merge remote-tracking branch 'stable/linux-5.15.y' into rpi-5.15.y
[platform/kernel/linux-rpi.git] / drivers / extcon / extcon-usbc-tusb320.c
1 // SPDX-License-Identifier: GPL-2.0
2 /**
3  * drivers/extcon/extcon-tusb320.c - TUSB320 extcon driver
4  *
5  * Copyright (C) 2020 National Instruments Corporation
6  * Author: Michael Auchter <michael.auchter@ni.com>
7  */
8
9 #include <linux/extcon-provider.h>
10 #include <linux/i2c.h>
11 #include <linux/init.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16
17 #define TUSB320_REG9                            0x9
18 #define TUSB320_REG9_ATTACHED_STATE_SHIFT       6
19 #define TUSB320_REG9_ATTACHED_STATE_MASK        0x3
20 #define TUSB320_REG9_CABLE_DIRECTION            BIT(5)
21 #define TUSB320_REG9_INTERRUPT_STATUS           BIT(4)
22 #define TUSB320_ATTACHED_STATE_NONE             0x0
23 #define TUSB320_ATTACHED_STATE_DFP              0x1
24 #define TUSB320_ATTACHED_STATE_UFP              0x2
25 #define TUSB320_ATTACHED_STATE_ACC              0x3
26
27 struct tusb320_priv {
28         struct device *dev;
29         struct regmap *regmap;
30         struct extcon_dev *edev;
31 };
32
33 static const char * const tusb_attached_states[] = {
34         [TUSB320_ATTACHED_STATE_NONE] = "not attached",
35         [TUSB320_ATTACHED_STATE_DFP]  = "downstream facing port",
36         [TUSB320_ATTACHED_STATE_UFP]  = "upstream facing port",
37         [TUSB320_ATTACHED_STATE_ACC]  = "accessory",
38 };
39
40 static const unsigned int tusb320_extcon_cable[] = {
41         EXTCON_USB,
42         EXTCON_USB_HOST,
43         EXTCON_NONE,
44 };
45
46 static int tusb320_check_signature(struct tusb320_priv *priv)
47 {
48         static const char sig[] = { '\0', 'T', 'U', 'S', 'B', '3', '2', '0' };
49         unsigned val;
50         int i, ret;
51
52         for (i = 0; i < sizeof(sig); i++) {
53                 ret = regmap_read(priv->regmap, sizeof(sig) - 1 - i, &val);
54                 if (ret < 0)
55                         return ret;
56                 if (val != sig[i]) {
57                         dev_err(priv->dev, "signature mismatch!\n");
58                         return -ENODEV;
59                 }
60         }
61
62         return 0;
63 }
64
65 static irqreturn_t tusb320_irq_handler(int irq, void *dev_id)
66 {
67         struct tusb320_priv *priv = dev_id;
68         int state, polarity;
69         unsigned reg;
70
71         if (regmap_read(priv->regmap, TUSB320_REG9, &reg)) {
72                 dev_err(priv->dev, "error during i2c read!\n");
73                 return IRQ_NONE;
74         }
75
76         if (!(reg & TUSB320_REG9_INTERRUPT_STATUS))
77                 return IRQ_NONE;
78
79         state = (reg >> TUSB320_REG9_ATTACHED_STATE_SHIFT) &
80                 TUSB320_REG9_ATTACHED_STATE_MASK;
81         polarity = !!(reg & TUSB320_REG9_CABLE_DIRECTION);
82
83         dev_dbg(priv->dev, "attached state: %s, polarity: %d\n",
84                 tusb_attached_states[state], polarity);
85
86         extcon_set_state(priv->edev, EXTCON_USB,
87                          state == TUSB320_ATTACHED_STATE_UFP);
88         extcon_set_state(priv->edev, EXTCON_USB_HOST,
89                          state == TUSB320_ATTACHED_STATE_DFP);
90         extcon_set_property(priv->edev, EXTCON_USB,
91                             EXTCON_PROP_USB_TYPEC_POLARITY,
92                             (union extcon_property_value)polarity);
93         extcon_set_property(priv->edev, EXTCON_USB_HOST,
94                             EXTCON_PROP_USB_TYPEC_POLARITY,
95                             (union extcon_property_value)polarity);
96         extcon_sync(priv->edev, EXTCON_USB);
97         extcon_sync(priv->edev, EXTCON_USB_HOST);
98
99         regmap_write(priv->regmap, TUSB320_REG9, reg);
100
101         return IRQ_HANDLED;
102 }
103
104 static const struct regmap_config tusb320_regmap_config = {
105         .reg_bits = 8,
106         .val_bits = 8,
107 };
108
109 static int tusb320_extcon_probe(struct i2c_client *client,
110                                 const struct i2c_device_id *id)
111 {
112         struct tusb320_priv *priv;
113         int ret;
114
115         priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
116         if (!priv)
117                 return -ENOMEM;
118         priv->dev = &client->dev;
119
120         priv->regmap = devm_regmap_init_i2c(client, &tusb320_regmap_config);
121         if (IS_ERR(priv->regmap))
122                 return PTR_ERR(priv->regmap);
123
124         ret = tusb320_check_signature(priv);
125         if (ret)
126                 return ret;
127
128         priv->edev = devm_extcon_dev_allocate(priv->dev, tusb320_extcon_cable);
129         if (IS_ERR(priv->edev)) {
130                 dev_err(priv->dev, "failed to allocate extcon device\n");
131                 return PTR_ERR(priv->edev);
132         }
133
134         ret = devm_extcon_dev_register(priv->dev, priv->edev);
135         if (ret < 0) {
136                 dev_err(priv->dev, "failed to register extcon device\n");
137                 return ret;
138         }
139
140         extcon_set_property_capability(priv->edev, EXTCON_USB,
141                                        EXTCON_PROP_USB_TYPEC_POLARITY);
142         extcon_set_property_capability(priv->edev, EXTCON_USB_HOST,
143                                        EXTCON_PROP_USB_TYPEC_POLARITY);
144
145         /* update initial state */
146         tusb320_irq_handler(client->irq, priv);
147
148         ret = devm_request_threaded_irq(priv->dev, client->irq, NULL,
149                                         tusb320_irq_handler,
150                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
151                                         client->name, priv);
152
153         return ret;
154 }
155
156 static const struct of_device_id tusb320_extcon_dt_match[] = {
157         { .compatible = "ti,tusb320", },
158         { }
159 };
160 MODULE_DEVICE_TABLE(of, tusb320_extcon_dt_match);
161
162 static struct i2c_driver tusb320_extcon_driver = {
163         .probe          = tusb320_extcon_probe,
164         .driver         = {
165                 .name   = "extcon-tusb320",
166                 .of_match_table = tusb320_extcon_dt_match,
167         },
168 };
169
170 static int __init tusb320_init(void)
171 {
172         return i2c_add_driver(&tusb320_extcon_driver);
173 }
174 subsys_initcall(tusb320_init);
175
176 static void __exit tusb320_exit(void)
177 {
178         i2c_del_driver(&tusb320_extcon_driver);
179 }
180 module_exit(tusb320_exit);
181
182 MODULE_AUTHOR("Michael Auchter <michael.auchter@ni.com>");
183 MODULE_DESCRIPTION("TI TUSB320 extcon driver");
184 MODULE_LICENSE("GPL v2");