1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2022, Linaro Ltd
5 */
6 #include <linux/auxiliary_bus.h>
7 #include <linux/cleanup.h>
8 #include <linux/delay.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/platform_device.h>
12 #include <linux/rpmsg.h>
13 #include <linux/slab.h>
14 #include <linux/soc/qcom/pdr.h>
15 #include <linux/soc/qcom/pmic_glink.h>
16 #include <linux/spinlock.h>
17
18 #define PMIC_GLINK_SEND_TIMEOUT (5 * HZ)
19
20 enum {
21 PMIC_GLINK_CLIENT_BATT = 0,
22 PMIC_GLINK_CLIENT_ALTMODE,
23 PMIC_GLINK_CLIENT_UCSI,
24 };
25
26 struct pmic_glink {
27 struct device *dev;
28 struct pdr_handle *pdr;
29
30 struct rpmsg_endpoint *ept;
31
32 unsigned long client_mask;
33
34 struct auxiliary_device altmode_aux;
35 struct auxiliary_device ps_aux;
36 struct auxiliary_device ucsi_aux;
37
38 /* serializing client_state and pdr_state updates */
39 struct mutex state_lock;
40 unsigned int client_state;
41 unsigned int pdr_state;
42
43 /* serializing clients list updates */
44 spinlock_t client_lock;
45 struct list_head clients;
46 };
47
48 static struct pmic_glink *__pmic_glink;
49 static DEFINE_MUTEX(__pmic_glink_lock);
50
51 struct pmic_glink_client {
52 struct list_head node;
53
54 struct pmic_glink *pg;
55 unsigned int id;
56
57 void (*cb)(const void *data, size_t len, void *priv);
58 void (*pdr_notify)(void *priv, int state);
59 void *priv;
60 };
61
_devm_pmic_glink_release_client(struct device * dev,void * res)62 static void _devm_pmic_glink_release_client(struct device *dev, void *res)
63 {
64 struct pmic_glink_client *client = (struct pmic_glink_client *)res;
65 struct pmic_glink *pg = client->pg;
66 unsigned long flags;
67
68 spin_lock_irqsave(&pg->client_lock, flags);
69 list_del(&client->node);
70 spin_unlock_irqrestore(&pg->client_lock, flags);
71 }
72
devm_pmic_glink_client_alloc(struct device * dev,unsigned int id,void (* cb)(const void *,size_t,void *),void (* pdr)(void *,int),void * priv)73 struct pmic_glink_client *devm_pmic_glink_client_alloc(struct device *dev,
74 unsigned int id,
75 void (*cb)(const void *, size_t, void *),
76 void (*pdr)(void *, int),
77 void *priv)
78 {
79 struct pmic_glink_client *client;
80 struct pmic_glink *pg = dev_get_drvdata(dev->parent);
81
82 client = devres_alloc(_devm_pmic_glink_release_client, sizeof(*client), GFP_KERNEL);
83 if (!client)
84 return ERR_PTR(-ENOMEM);
85
86 client->pg = pg;
87 client->id = id;
88 client->cb = cb;
89 client->pdr_notify = pdr;
90 client->priv = priv;
91 INIT_LIST_HEAD(&client->node);
92
93 devres_add(dev, client);
94
95 return client;
96 }
97 EXPORT_SYMBOL_GPL(devm_pmic_glink_client_alloc);
98
pmic_glink_client_register(struct pmic_glink_client * client)99 void pmic_glink_client_register(struct pmic_glink_client *client)
100 {
101 struct pmic_glink *pg = client->pg;
102 unsigned long flags;
103
104 guard(mutex)(&pg->state_lock);
105 spin_lock_irqsave(&pg->client_lock, flags);
106
107 list_add(&client->node, &pg->clients);
108 client->pdr_notify(client->priv, pg->client_state);
109
110 spin_unlock_irqrestore(&pg->client_lock, flags);
111 }
112 EXPORT_SYMBOL_GPL(pmic_glink_client_register);
113
pmic_glink_send(struct pmic_glink_client * client,void * data,size_t len)114 int pmic_glink_send(struct pmic_glink_client *client, void *data, size_t len)
115 {
116 struct pmic_glink *pg = client->pg;
117 bool timeout_reached = false;
118 unsigned long start;
119 int ret;
120
121 guard(mutex)(&pg->state_lock);
122 if (!pg->ept) {
123 return -ECONNRESET;
124 }
125
126 start = jiffies;
127 for (;;) {
128 ret = rpmsg_send(pg->ept, data, len);
129 if (ret != -EAGAIN)
130 break;
131
132 if (timeout_reached) {
133 ret = -ETIMEDOUT;
134 break;
135 }
136
137 usleep_range(1000, 5000);
138 timeout_reached = time_after(jiffies, start + PMIC_GLINK_SEND_TIMEOUT);
139 }
140
141 return ret;
142 }
143 EXPORT_SYMBOL_GPL(pmic_glink_send);
144
pmic_glink_rpmsg_callback(struct rpmsg_device * rpdev,void * data,int len,void * priv,u32 addr)145 static int pmic_glink_rpmsg_callback(struct rpmsg_device *rpdev, void *data,
146 int len, void *priv, u32 addr)
147 {
148 struct pmic_glink_client *client;
149 struct pmic_glink_hdr *hdr;
150 struct pmic_glink *pg = dev_get_drvdata(&rpdev->dev);
151 unsigned long flags;
152
153 if (len < sizeof(*hdr)) {
154 dev_warn(pg->dev, "ignoring truncated message\n");
155 return 0;
156 }
157
158 hdr = data;
159
160 spin_lock_irqsave(&pg->client_lock, flags);
161 list_for_each_entry(client, &pg->clients, node) {
162 if (client->id == le32_to_cpu(hdr->owner))
163 client->cb(data, len, client->priv);
164 }
165 spin_unlock_irqrestore(&pg->client_lock, flags);
166
167 return 0;
168 }
169
pmic_glink_aux_release(struct device * dev)170 static void pmic_glink_aux_release(struct device *dev) {}
171
pmic_glink_add_aux_device(struct pmic_glink * pg,struct auxiliary_device * aux,const char * name)172 static int pmic_glink_add_aux_device(struct pmic_glink *pg,
173 struct auxiliary_device *aux,
174 const char *name)
175 {
176 struct device *parent = pg->dev;
177 int ret;
178
179 aux->name = name;
180 aux->dev.parent = parent;
181 aux->dev.release = pmic_glink_aux_release;
182 device_set_of_node_from_dev(&aux->dev, parent);
183 ret = auxiliary_device_init(aux);
184 if (ret)
185 return ret;
186
187 ret = auxiliary_device_add(aux);
188 if (ret)
189 auxiliary_device_uninit(aux);
190
191 return ret;
192 }
193
pmic_glink_del_aux_device(struct pmic_glink * pg,struct auxiliary_device * aux)194 static void pmic_glink_del_aux_device(struct pmic_glink *pg,
195 struct auxiliary_device *aux)
196 {
197 auxiliary_device_delete(aux);
198 auxiliary_device_uninit(aux);
199 }
200
pmic_glink_state_notify_clients(struct pmic_glink * pg)201 static void pmic_glink_state_notify_clients(struct pmic_glink *pg)
202 {
203 struct pmic_glink_client *client;
204 unsigned int new_state = pg->client_state;
205 unsigned long flags;
206
207 if (pg->client_state != SERVREG_SERVICE_STATE_UP) {
208 if (pg->pdr_state == SERVREG_SERVICE_STATE_UP && pg->ept)
209 new_state = SERVREG_SERVICE_STATE_UP;
210 } else {
211 if (pg->pdr_state == SERVREG_SERVICE_STATE_DOWN || !pg->ept)
212 new_state = SERVREG_SERVICE_STATE_DOWN;
213 }
214
215 if (new_state != pg->client_state) {
216 spin_lock_irqsave(&pg->client_lock, flags);
217 list_for_each_entry(client, &pg->clients, node)
218 client->pdr_notify(client->priv, new_state);
219 spin_unlock_irqrestore(&pg->client_lock, flags);
220 pg->client_state = new_state;
221 }
222 }
223
pmic_glink_pdr_callback(int state,char * svc_path,void * priv)224 static void pmic_glink_pdr_callback(int state, char *svc_path, void *priv)
225 {
226 struct pmic_glink *pg = priv;
227
228 guard(mutex)(&pg->state_lock);
229 pg->pdr_state = state;
230
231 pmic_glink_state_notify_clients(pg);
232 }
233
pmic_glink_rpmsg_probe(struct rpmsg_device * rpdev)234 static int pmic_glink_rpmsg_probe(struct rpmsg_device *rpdev)
235 {
236 struct pmic_glink *pg;
237
238 guard(mutex)(&__pmic_glink_lock);
239 pg = __pmic_glink;
240 if (!pg)
241 return dev_err_probe(&rpdev->dev, -ENODEV, "no pmic_glink device to attach to\n");
242
243 dev_set_drvdata(&rpdev->dev, pg);
244
245 guard(mutex)(&pg->state_lock);
246 pg->ept = rpdev->ept;
247 pmic_glink_state_notify_clients(pg);
248
249 return 0;
250 }
251
pmic_glink_rpmsg_remove(struct rpmsg_device * rpdev)252 static void pmic_glink_rpmsg_remove(struct rpmsg_device *rpdev)
253 {
254 struct pmic_glink *pg;
255
256 guard(mutex)(&__pmic_glink_lock);
257 pg = __pmic_glink;
258 if (!pg)
259 return;
260
261 guard(mutex)(&pg->state_lock);
262 pg->ept = NULL;
263 pmic_glink_state_notify_clients(pg);
264 }
265
266 static const struct rpmsg_device_id pmic_glink_rpmsg_id_match[] = {
267 { "PMIC_RTR_ADSP_APPS" },
268 {}
269 };
270
271 static struct rpmsg_driver pmic_glink_rpmsg_driver = {
272 .probe = pmic_glink_rpmsg_probe,
273 .remove = pmic_glink_rpmsg_remove,
274 .callback = pmic_glink_rpmsg_callback,
275 .id_table = pmic_glink_rpmsg_id_match,
276 .drv = {
277 .name = "qcom_pmic_glink_rpmsg",
278 },
279 };
280
pmic_glink_probe(struct platform_device * pdev)281 static int pmic_glink_probe(struct platform_device *pdev)
282 {
283 const unsigned long *match_data;
284 struct pdr_service *service;
285 struct pmic_glink *pg;
286 int ret;
287
288 pg = devm_kzalloc(&pdev->dev, sizeof(*pg), GFP_KERNEL);
289 if (!pg)
290 return -ENOMEM;
291
292 dev_set_drvdata(&pdev->dev, pg);
293
294 pg->dev = &pdev->dev;
295
296 INIT_LIST_HEAD(&pg->clients);
297 spin_lock_init(&pg->client_lock);
298 mutex_init(&pg->state_lock);
299
300 match_data = (unsigned long *)of_device_get_match_data(&pdev->dev);
301 if (!match_data)
302 return -EINVAL;
303
304 pg->client_mask = *match_data;
305
306 pg->pdr = pdr_handle_alloc(pmic_glink_pdr_callback, pg);
307 if (IS_ERR(pg->pdr)) {
308 ret = dev_err_probe(&pdev->dev, PTR_ERR(pg->pdr),
309 "failed to initialize pdr\n");
310 return ret;
311 }
312
313 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI)) {
314 ret = pmic_glink_add_aux_device(pg, &pg->ucsi_aux, "ucsi");
315 if (ret)
316 goto out_release_pdr_handle;
317 }
318 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE)) {
319 ret = pmic_glink_add_aux_device(pg, &pg->altmode_aux, "altmode");
320 if (ret)
321 goto out_release_ucsi_aux;
322 }
323 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT)) {
324 ret = pmic_glink_add_aux_device(pg, &pg->ps_aux, "power-supply");
325 if (ret)
326 goto out_release_altmode_aux;
327 }
328
329 service = pdr_add_lookup(pg->pdr, "tms/servreg", "msm/adsp/charger_pd");
330 if (IS_ERR(service)) {
331 ret = dev_err_probe(&pdev->dev, PTR_ERR(service),
332 "failed adding pdr lookup for charger_pd\n");
333 goto out_release_aux_devices;
334 }
335
336 mutex_lock(&__pmic_glink_lock);
337 __pmic_glink = pg;
338 mutex_unlock(&__pmic_glink_lock);
339
340 return 0;
341
342 out_release_aux_devices:
343 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT))
344 pmic_glink_del_aux_device(pg, &pg->ps_aux);
345 out_release_altmode_aux:
346 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE))
347 pmic_glink_del_aux_device(pg, &pg->altmode_aux);
348 out_release_ucsi_aux:
349 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI))
350 pmic_glink_del_aux_device(pg, &pg->ucsi_aux);
351 out_release_pdr_handle:
352 pdr_handle_release(pg->pdr);
353
354 return ret;
355 }
356
pmic_glink_remove(struct platform_device * pdev)357 static void pmic_glink_remove(struct platform_device *pdev)
358 {
359 struct pmic_glink *pg = dev_get_drvdata(&pdev->dev);
360
361 pdr_handle_release(pg->pdr);
362
363 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT))
364 pmic_glink_del_aux_device(pg, &pg->ps_aux);
365 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE))
366 pmic_glink_del_aux_device(pg, &pg->altmode_aux);
367 if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI))
368 pmic_glink_del_aux_device(pg, &pg->ucsi_aux);
369
370 guard(mutex)(&__pmic_glink_lock);
371 __pmic_glink = NULL;
372 }
373
374 static const unsigned long pmic_glink_sc8280xp_client_mask = BIT(PMIC_GLINK_CLIENT_BATT) |
375 BIT(PMIC_GLINK_CLIENT_ALTMODE);
376
377 static const unsigned long pmic_glink_sm8450_client_mask = BIT(PMIC_GLINK_CLIENT_BATT) |
378 BIT(PMIC_GLINK_CLIENT_ALTMODE) |
379 BIT(PMIC_GLINK_CLIENT_UCSI);
380
381 static const struct of_device_id pmic_glink_of_match[] = {
382 { .compatible = "qcom,sc8280xp-pmic-glink", .data = &pmic_glink_sc8280xp_client_mask },
383 { .compatible = "qcom,pmic-glink", .data = &pmic_glink_sm8450_client_mask },
384 {}
385 };
386 MODULE_DEVICE_TABLE(of, pmic_glink_of_match);
387
388 static struct platform_driver pmic_glink_driver = {
389 .probe = pmic_glink_probe,
390 .remove = pmic_glink_remove,
391 .driver = {
392 .name = "qcom_pmic_glink",
393 .of_match_table = pmic_glink_of_match,
394 },
395 };
396
pmic_glink_init(void)397 static int pmic_glink_init(void)
398 {
399 int ret;
400
401 ret = platform_driver_register(&pmic_glink_driver);
402 if (ret < 0)
403 return ret;
404
405 ret = register_rpmsg_driver(&pmic_glink_rpmsg_driver);
406 if (ret < 0) {
407 platform_driver_unregister(&pmic_glink_driver);
408 return ret;
409 }
410
411 return 0;
412 }
413 module_init(pmic_glink_init);
414
pmic_glink_exit(void)415 static void pmic_glink_exit(void)
416 {
417 unregister_rpmsg_driver(&pmic_glink_rpmsg_driver);
418 platform_driver_unregister(&pmic_glink_driver);
419 }
420 module_exit(pmic_glink_exit);
421
422 MODULE_DESCRIPTION("Qualcomm PMIC GLINK driver");
423 MODULE_LICENSE("GPL");
424