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