Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2
3#include <linux/device.h>
4#include <linux/devm-helpers.h>
5#include <linux/delay.h>
6#include <linux/err.h>
7#include <linux/extcon-provider.h>
8#include <linux/i2c.h>
9#include <linux/mod_devicetable.h>
10#include <linux/interrupt.h>
11#include <linux/module.h>
12#include <linux/pm.h>
13#include <linux/regmap.h>
14
15/* I2C addresses of MUIC internal registers */
16#define MAX14526_DEVICE_ID 0x00
17#define MAX14526_ID 0x02
18
19/* CONTROL_1 register masks */
20#define MAX14526_CONTROL_1 0x01
21#define ID_2P2 BIT(6)
22#define ID_620 BIT(5)
23#define ID_200 BIT(4)
24#define VLDO BIT(3)
25#define SEMREN BIT(2)
26#define ADC_EN BIT(1)
27#define CP_EN BIT(0)
28
29/* CONTROL_2 register masks */
30#define MAX14526_CONTROL_2 0x02
31#define INTPOL BIT(7)
32#define INT_EN BIT(6)
33#define MIC_LP BIT(5)
34#define CP_AUD BIT(4)
35#define CHG_TYPE BIT(1)
36#define USB_DET_DIS BIT(0)
37
38/* SW_CONTROL register masks */
39#define MAX14526_SW_CONTROL 0x03
40#define SW_DATA 0x00
41#define SW_UART 0x01
42#define SW_AUDIO 0x02
43#define SW_OPEN 0x07
44
45/* INT_STATUS register masks */
46#define MAX14526_INT_STAT 0x04
47#define CHGDET BIT(7)
48#define MR_COMP BIT(6)
49#define SENDEND BIT(5)
50#define V_VBUS BIT(4)
51
52/* STATUS register masks */
53#define MAX14526_STATUS 0x05
54#define CPORT BIT(7)
55#define CHPORT BIT(6)
56#define C1COMP BIT(0)
57
58enum max14526_idno_resistance {
59 MAX14526_GND,
60 MAX14526_24KOHM,
61 MAX14526_56KOHM,
62 MAX14526_100KOHM,
63 MAX14526_130KOHM,
64 MAX14526_180KOHM,
65 MAX14526_240KOHM,
66 MAX14526_330KOHM,
67 MAX14526_430KOHM,
68 MAX14526_620KOHM,
69 MAX14526_910KOHM,
70 MAX14526_OPEN
71};
72
73enum max14526_field_idx {
74 VENDOR_ID, CHIP_REV, /* DEVID */
75 DM, DP, /* SW_CONTROL */
76 MAX14526_N_REGMAP_FIELDS
77};
78
79static const struct reg_field max14526_reg_field[MAX14526_N_REGMAP_FIELDS] = {
80 [VENDOR_ID] = REG_FIELD(MAX14526_DEVICE_ID, 4, 7),
81 [CHIP_REV] = REG_FIELD(MAX14526_DEVICE_ID, 0, 3),
82 [DM] = REG_FIELD(MAX14526_SW_CONTROL, 0, 2),
83 [DP] = REG_FIELD(MAX14526_SW_CONTROL, 3, 5),
84};
85
86struct max14526_data {
87 struct i2c_client *client;
88 struct extcon_dev *edev;
89
90 struct regmap *regmap;
91 struct regmap_field *rfield[MAX14526_N_REGMAP_FIELDS];
92
93 int last_state;
94 int cable;
95};
96
97enum max14526_muic_modes {
98 MAX14526_OTG = MAX14526_GND, /* no power */
99 MAX14526_MHL = MAX14526_56KOHM, /* no power */
100 MAX14526_OTG_Y = MAX14526_GND | V_VBUS,
101 MAX14526_MHL_CHG = MAX14526_GND | V_VBUS | CHGDET,
102 MAX14526_NONE = MAX14526_OPEN,
103 MAX14526_USB = MAX14526_OPEN | V_VBUS,
104 MAX14526_CHG = MAX14526_OPEN | V_VBUS | CHGDET,
105};
106
107static const unsigned int max14526_extcon_cable[] = {
108 EXTCON_USB,
109 EXTCON_USB_HOST,
110 EXTCON_CHG_USB_FAST,
111 EXTCON_DISP_MHL,
112 EXTCON_NONE,
113};
114
115static int max14526_ap_usb_mode(struct max14526_data *priv)
116{
117 struct device *dev = &priv->client->dev;
118 int ret;
119
120 /* Enable USB Path */
121 ret = regmap_field_write(priv->rfield[DM], SW_DATA);
122 if (ret)
123 return ret;
124
125 ret = regmap_field_write(priv->rfield[DP], SW_DATA);
126 if (ret)
127 return ret;
128
129 /* Enable 200K, Charger Pump and ADC */
130 ret = regmap_write(priv->regmap, MAX14526_CONTROL_1,
131 ID_200 | ADC_EN | CP_EN);
132 if (ret)
133 return ret;
134
135 dev_dbg(dev, "AP USB mode set\n");
136
137 return 0;
138}
139
140static irqreturn_t max14526_interrupt(int irq, void *dev_id)
141{
142 struct max14526_data *priv = dev_id;
143 struct device *dev = &priv->client->dev;
144 int state, ret;
145
146 /*
147 * Upon an MUIC IRQ (MUIC_INT_N falls), wait at least 70ms
148 * before reading INT_STAT and STATUS. After the reads,
149 * MUIC_INT_N returns to high (but the INT_STAT and STATUS
150 * contents will be held).
151 */
152 msleep(100);
153
154 ret = regmap_read(priv->regmap, MAX14526_INT_STAT, &state);
155 if (ret)
156 dev_err(dev, "failed to read MUIC state %d\n", ret);
157
158 if (state == priv->last_state)
159 return IRQ_HANDLED;
160
161 /* Detach previous device */
162 extcon_set_state_sync(priv->edev, priv->cable, false);
163
164 switch (state) {
165 case MAX14526_USB:
166 priv->cable = EXTCON_USB;
167 break;
168
169 case MAX14526_CHG:
170 priv->cable = EXTCON_CHG_USB_FAST;
171 break;
172
173 case MAX14526_OTG:
174 case MAX14526_OTG_Y:
175 priv->cable = EXTCON_USB_HOST;
176 break;
177
178 case MAX14526_MHL:
179 case MAX14526_MHL_CHG:
180 priv->cable = EXTCON_DISP_MHL;
181 break;
182
183 case MAX14526_NONE:
184 default:
185 priv->cable = EXTCON_NONE;
186 break;
187 }
188
189 extcon_set_state_sync(priv->edev, priv->cable, true);
190
191 priv->last_state = state;
192
193 return IRQ_HANDLED;
194}
195
196static const struct regmap_config max14526_regmap_config = {
197 .reg_bits = 8,
198 .val_bits = 8,
199 .max_register = MAX14526_STATUS,
200};
201
202static int max14526_probe(struct i2c_client *client)
203{
204 struct device *dev = &client->dev;
205 struct max14526_data *priv;
206 int ret, dev_id, rev, i;
207
208 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
209 if (!priv)
210 return -ENOMEM;
211
212 priv->client = client;
213 i2c_set_clientdata(client, priv);
214
215 priv->regmap = devm_regmap_init_i2c(client, &max14526_regmap_config);
216 if (IS_ERR(priv->regmap))
217 return dev_err_probe(dev, PTR_ERR(priv->regmap), "cannot allocate regmap\n");
218
219 for (i = 0; i < MAX14526_N_REGMAP_FIELDS; i++) {
220 priv->rfield[i] = devm_regmap_field_alloc(dev, priv->regmap,
221 max14526_reg_field[i]);
222 if (IS_ERR(priv->rfield[i]))
223 return dev_err_probe(dev, PTR_ERR(priv->rfield[i]),
224 "cannot allocate regmap field\n");
225 }
226
227 /* Detect if MUIC version is supported */
228 ret = regmap_field_read(priv->rfield[VENDOR_ID], &dev_id);
229 if (ret)
230 return dev_err_probe(dev, ret, "failed to read MUIC ID\n");
231
232 regmap_field_read(priv->rfield[CHIP_REV], &rev);
233
234 if (dev_id == MAX14526_ID)
235 dev_info(dev, "detected MAX14526 MUIC with id 0x%x, rev 0x%x\n", dev_id, rev);
236 else
237 dev_err_probe(dev, -EINVAL, "MUIC vendor id 0x%X is not recognized\n", dev_id);
238
239 priv->edev = devm_extcon_dev_allocate(dev, max14526_extcon_cable);
240 if (IS_ERR(priv->edev))
241 return dev_err_probe(dev, (IS_ERR(priv->edev)),
242 "failed to allocate extcon device\n");
243
244 ret = devm_extcon_dev_register(dev, priv->edev);
245 if (ret < 0)
246 return dev_err_probe(dev, ret, "failed to register extcon device\n");
247
248 ret = max14526_ap_usb_mode(priv);
249 if (ret < 0)
250 return dev_err_probe(dev, ret, "failed to set AP USB mode\n");
251
252 regmap_write_bits(priv->regmap, MAX14526_CONTROL_2, INT_EN, INT_EN);
253 regmap_write_bits(priv->regmap, MAX14526_CONTROL_2, USB_DET_DIS, (u32)~USB_DET_DIS);
254
255 ret = devm_request_threaded_irq(dev, client->irq, NULL, &max14526_interrupt,
256 IRQF_ONESHOT | IRQF_SHARED, client->name, priv);
257 if (ret)
258 return dev_err_probe(dev, ret, "failed to register IRQ\n");
259
260 irq_wake_thread(client->irq, priv);
261
262 return 0;
263}
264
265static int max14526_resume(struct device *dev)
266{
267 struct i2c_client *client = to_i2c_client(dev);
268 struct max14526_data *priv = i2c_get_clientdata(client);
269
270 irq_wake_thread(client->irq, priv);
271
272 return 0;
273}
274
275static DEFINE_SIMPLE_DEV_PM_OPS(max14526_pm_ops, NULL, max14526_resume);
276
277static const struct of_device_id max14526_match[] = {
278 { .compatible = "maxim,max14526" },
279 { /* sentinel */ }
280};
281MODULE_DEVICE_TABLE(of, max14526_match);
282
283static const struct i2c_device_id max14526_id[] = {
284 { "max14526" },
285 { }
286};
287MODULE_DEVICE_TABLE(i2c, max14526_id);
288
289static struct i2c_driver max14526_driver = {
290 .driver = {
291 .name = "max14526",
292 .of_match_table = max14526_match,
293 .pm = &max14526_pm_ops,
294 },
295 .probe = max14526_probe,
296 .id_table = max14526_id,
297};
298module_i2c_driver(max14526_driver);
299
300MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>");
301MODULE_DESCRIPTION("MAX14526 extcon driver to support MUIC");
302MODULE_LICENSE("GPL");