158ef4eceSBjorn Andersson // SPDX-License-Identifier: GPL-2.0-only
258ef4eceSBjorn Andersson /*
358ef4eceSBjorn Andersson * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
458ef4eceSBjorn Andersson * Copyright (c) 2022, Linaro Ltd
558ef4eceSBjorn Andersson */
658ef4eceSBjorn Andersson #include <linux/auxiliary_bus.h>
758ef4eceSBjorn Andersson #include <linux/module.h>
86484be9dSRob Herring #include <linux/of.h>
958ef4eceSBjorn Andersson #include <linux/platform_device.h>
1058ef4eceSBjorn Andersson #include <linux/rpmsg.h>
1158ef4eceSBjorn Andersson #include <linux/slab.h>
1258ef4eceSBjorn Andersson #include <linux/soc/qcom/pdr.h>
1358ef4eceSBjorn Andersson #include <linux/soc/qcom/pmic_glink.h>
1493299336SBjorn Andersson #include <linux/spinlock.h>
1558ef4eceSBjorn Andersson
16ff642773SNeil Armstrong enum {
17ff642773SNeil Armstrong PMIC_GLINK_CLIENT_BATT = 0,
18ff642773SNeil Armstrong PMIC_GLINK_CLIENT_ALTMODE,
19ff642773SNeil Armstrong PMIC_GLINK_CLIENT_UCSI,
20ff642773SNeil Armstrong };
21ff642773SNeil Armstrong
2258ef4eceSBjorn Andersson struct pmic_glink {
2358ef4eceSBjorn Andersson struct device *dev;
2458ef4eceSBjorn Andersson struct pdr_handle *pdr;
2558ef4eceSBjorn Andersson
2658ef4eceSBjorn Andersson struct rpmsg_endpoint *ept;
2758ef4eceSBjorn Andersson
28ff642773SNeil Armstrong unsigned long client_mask;
29ff642773SNeil Armstrong
3058ef4eceSBjorn Andersson struct auxiliary_device altmode_aux;
3158ef4eceSBjorn Andersson struct auxiliary_device ps_aux;
3258ef4eceSBjorn Andersson struct auxiliary_device ucsi_aux;
3358ef4eceSBjorn Andersson
3458ef4eceSBjorn Andersson /* serializing client_state and pdr_state updates */
3558ef4eceSBjorn Andersson struct mutex state_lock;
3658ef4eceSBjorn Andersson unsigned int client_state;
3758ef4eceSBjorn Andersson unsigned int pdr_state;
3858ef4eceSBjorn Andersson
3958ef4eceSBjorn Andersson /* serializing clients list updates */
4093299336SBjorn Andersson spinlock_t client_lock;
4158ef4eceSBjorn Andersson struct list_head clients;
4258ef4eceSBjorn Andersson };
4358ef4eceSBjorn Andersson
4458ef4eceSBjorn Andersson static struct pmic_glink *__pmic_glink;
4558ef4eceSBjorn Andersson static DEFINE_MUTEX(__pmic_glink_lock);
4658ef4eceSBjorn Andersson
4758ef4eceSBjorn Andersson struct pmic_glink_client {
4858ef4eceSBjorn Andersson struct list_head node;
4958ef4eceSBjorn Andersson
5058ef4eceSBjorn Andersson struct pmic_glink *pg;
5158ef4eceSBjorn Andersson unsigned int id;
5258ef4eceSBjorn Andersson
5358ef4eceSBjorn Andersson void (*cb)(const void *data, size_t len, void *priv);
5458ef4eceSBjorn Andersson void (*pdr_notify)(void *priv, int state);
5558ef4eceSBjorn Andersson void *priv;
5658ef4eceSBjorn Andersson };
5758ef4eceSBjorn Andersson
_devm_pmic_glink_release_client(struct device * dev,void * res)5858ef4eceSBjorn Andersson static void _devm_pmic_glink_release_client(struct device *dev, void *res)
5958ef4eceSBjorn Andersson {
6058ef4eceSBjorn Andersson struct pmic_glink_client *client = (struct pmic_glink_client *)res;
6158ef4eceSBjorn Andersson struct pmic_glink *pg = client->pg;
6293299336SBjorn Andersson unsigned long flags;
6358ef4eceSBjorn Andersson
6493299336SBjorn Andersson spin_lock_irqsave(&pg->client_lock, flags);
6558ef4eceSBjorn Andersson list_del(&client->node);
6693299336SBjorn Andersson spin_unlock_irqrestore(&pg->client_lock, flags);
6758ef4eceSBjorn Andersson }
6858ef4eceSBjorn Andersson
devm_pmic_glink_client_alloc(struct device * dev,unsigned int id,void (* cb)(const void *,size_t,void *),void (* pdr)(void *,int),void * priv)693568affcSBjorn Andersson struct pmic_glink_client *devm_pmic_glink_client_alloc(struct device *dev,
7058ef4eceSBjorn Andersson unsigned int id,
7158ef4eceSBjorn Andersson void (*cb)(const void *, size_t, void *),
7258ef4eceSBjorn Andersson void (*pdr)(void *, int),
7358ef4eceSBjorn Andersson void *priv)
7458ef4eceSBjorn Andersson {
7558ef4eceSBjorn Andersson struct pmic_glink_client *client;
7658ef4eceSBjorn Andersson struct pmic_glink *pg = dev_get_drvdata(dev->parent);
7758ef4eceSBjorn Andersson
7858ef4eceSBjorn Andersson client = devres_alloc(_devm_pmic_glink_release_client, sizeof(*client), GFP_KERNEL);
7958ef4eceSBjorn Andersson if (!client)
8058ef4eceSBjorn Andersson return ERR_PTR(-ENOMEM);
8158ef4eceSBjorn Andersson
8258ef4eceSBjorn Andersson client->pg = pg;
8358ef4eceSBjorn Andersson client->id = id;
8458ef4eceSBjorn Andersson client->cb = cb;
8558ef4eceSBjorn Andersson client->pdr_notify = pdr;
8658ef4eceSBjorn Andersson client->priv = priv;
873568affcSBjorn Andersson INIT_LIST_HEAD(&client->node);
883568affcSBjorn Andersson
893568affcSBjorn Andersson devres_add(dev, client);
903568affcSBjorn Andersson
913568affcSBjorn Andersson return client;
923568affcSBjorn Andersson }
933568affcSBjorn Andersson EXPORT_SYMBOL_GPL(devm_pmic_glink_client_alloc);
943568affcSBjorn Andersson
pmic_glink_client_register(struct pmic_glink_client * client)953568affcSBjorn Andersson void pmic_glink_client_register(struct pmic_glink_client *client)
963568affcSBjorn Andersson {
973568affcSBjorn Andersson struct pmic_glink *pg = client->pg;
983568affcSBjorn Andersson unsigned long flags;
9958ef4eceSBjorn Andersson
100d6cbce2cSDmitry Baryshkov mutex_lock(&pg->state_lock);
10193299336SBjorn Andersson spin_lock_irqsave(&pg->client_lock, flags);
102d6cbce2cSDmitry Baryshkov
10358ef4eceSBjorn Andersson list_add(&client->node, &pg->clients);
104d6cbce2cSDmitry Baryshkov client->pdr_notify(client->priv, pg->client_state);
105d6cbce2cSDmitry Baryshkov
10693299336SBjorn Andersson spin_unlock_irqrestore(&pg->client_lock, flags);
107d6cbce2cSDmitry Baryshkov mutex_unlock(&pg->state_lock);
10858ef4eceSBjorn Andersson
10958ef4eceSBjorn Andersson }
1103568affcSBjorn Andersson EXPORT_SYMBOL_GPL(pmic_glink_client_register);
11158ef4eceSBjorn Andersson
pmic_glink_send(struct pmic_glink_client * client,void * data,size_t len)11258ef4eceSBjorn Andersson int pmic_glink_send(struct pmic_glink_client *client, void *data, size_t len)
11358ef4eceSBjorn Andersson {
11458ef4eceSBjorn Andersson struct pmic_glink *pg = client->pg;
11511bb2ffbSBjorn Andersson int ret;
11658ef4eceSBjorn Andersson
11711bb2ffbSBjorn Andersson mutex_lock(&pg->state_lock);
11811bb2ffbSBjorn Andersson if (!pg->ept)
11911bb2ffbSBjorn Andersson ret = -ECONNRESET;
12011bb2ffbSBjorn Andersson else
12111bb2ffbSBjorn Andersson ret = rpmsg_send(pg->ept, data, len);
12211bb2ffbSBjorn Andersson mutex_unlock(&pg->state_lock);
12311bb2ffbSBjorn Andersson
12411bb2ffbSBjorn Andersson return ret;
12558ef4eceSBjorn Andersson }
12658ef4eceSBjorn Andersson EXPORT_SYMBOL_GPL(pmic_glink_send);
12758ef4eceSBjorn Andersson
pmic_glink_rpmsg_callback(struct rpmsg_device * rpdev,void * data,int len,void * priv,u32 addr)12858ef4eceSBjorn Andersson static int pmic_glink_rpmsg_callback(struct rpmsg_device *rpdev, void *data,
12958ef4eceSBjorn Andersson int len, void *priv, u32 addr)
13058ef4eceSBjorn Andersson {
13158ef4eceSBjorn Andersson struct pmic_glink_client *client;
13258ef4eceSBjorn Andersson struct pmic_glink_hdr *hdr;
13358ef4eceSBjorn Andersson struct pmic_glink *pg = dev_get_drvdata(&rpdev->dev);
13493299336SBjorn Andersson unsigned long flags;
13558ef4eceSBjorn Andersson
13658ef4eceSBjorn Andersson if (len < sizeof(*hdr)) {
13758ef4eceSBjorn Andersson dev_warn(pg->dev, "ignoring truncated message\n");
13858ef4eceSBjorn Andersson return 0;
13958ef4eceSBjorn Andersson }
14058ef4eceSBjorn Andersson
14158ef4eceSBjorn Andersson hdr = data;
14258ef4eceSBjorn Andersson
14393299336SBjorn Andersson spin_lock_irqsave(&pg->client_lock, flags);
14458ef4eceSBjorn Andersson list_for_each_entry(client, &pg->clients, node) {
14558ef4eceSBjorn Andersson if (client->id == le32_to_cpu(hdr->owner))
14658ef4eceSBjorn Andersson client->cb(data, len, client->priv);
14758ef4eceSBjorn Andersson }
14893299336SBjorn Andersson spin_unlock_irqrestore(&pg->client_lock, flags);
14958ef4eceSBjorn Andersson
15058ef4eceSBjorn Andersson return 0;
15158ef4eceSBjorn Andersson }
15258ef4eceSBjorn Andersson
pmic_glink_aux_release(struct device * dev)15358ef4eceSBjorn Andersson static void pmic_glink_aux_release(struct device *dev) {}
15458ef4eceSBjorn Andersson
pmic_glink_add_aux_device(struct pmic_glink * pg,struct auxiliary_device * aux,const char * name)15558ef4eceSBjorn Andersson static int pmic_glink_add_aux_device(struct pmic_glink *pg,
15658ef4eceSBjorn Andersson struct auxiliary_device *aux,
15758ef4eceSBjorn Andersson const char *name)
15858ef4eceSBjorn Andersson {
15958ef4eceSBjorn Andersson struct device *parent = pg->dev;
16058ef4eceSBjorn Andersson int ret;
16158ef4eceSBjorn Andersson
16258ef4eceSBjorn Andersson aux->name = name;
16358ef4eceSBjorn Andersson aux->dev.parent = parent;
16458ef4eceSBjorn Andersson aux->dev.release = pmic_glink_aux_release;
16558ef4eceSBjorn Andersson device_set_of_node_from_dev(&aux->dev, parent);
16658ef4eceSBjorn Andersson ret = auxiliary_device_init(aux);
16758ef4eceSBjorn Andersson if (ret)
16858ef4eceSBjorn Andersson return ret;
16958ef4eceSBjorn Andersson
17058ef4eceSBjorn Andersson ret = auxiliary_device_add(aux);
17158ef4eceSBjorn Andersson if (ret)
17258ef4eceSBjorn Andersson auxiliary_device_uninit(aux);
17358ef4eceSBjorn Andersson
17458ef4eceSBjorn Andersson return ret;
17558ef4eceSBjorn Andersson }
17658ef4eceSBjorn Andersson
pmic_glink_del_aux_device(struct pmic_glink * pg,struct auxiliary_device * aux)17758ef4eceSBjorn Andersson static void pmic_glink_del_aux_device(struct pmic_glink *pg,
17858ef4eceSBjorn Andersson struct auxiliary_device *aux)
17958ef4eceSBjorn Andersson {
18058ef4eceSBjorn Andersson auxiliary_device_delete(aux);
18158ef4eceSBjorn Andersson auxiliary_device_uninit(aux);
18258ef4eceSBjorn Andersson }
18358ef4eceSBjorn Andersson
pmic_glink_state_notify_clients(struct pmic_glink * pg)18458ef4eceSBjorn Andersson static void pmic_glink_state_notify_clients(struct pmic_glink *pg)
18558ef4eceSBjorn Andersson {
18658ef4eceSBjorn Andersson struct pmic_glink_client *client;
18758ef4eceSBjorn Andersson unsigned int new_state = pg->client_state;
18893299336SBjorn Andersson unsigned long flags;
18958ef4eceSBjorn Andersson
19058ef4eceSBjorn Andersson if (pg->client_state != SERVREG_SERVICE_STATE_UP) {
19158ef4eceSBjorn Andersson if (pg->pdr_state == SERVREG_SERVICE_STATE_UP && pg->ept)
19258ef4eceSBjorn Andersson new_state = SERVREG_SERVICE_STATE_UP;
19358ef4eceSBjorn Andersson } else {
194*ad511260SBjorn Andersson if (pg->pdr_state == SERVREG_SERVICE_STATE_DOWN || !pg->ept)
19558ef4eceSBjorn Andersson new_state = SERVREG_SERVICE_STATE_DOWN;
19658ef4eceSBjorn Andersson }
19758ef4eceSBjorn Andersson
19858ef4eceSBjorn Andersson if (new_state != pg->client_state) {
19993299336SBjorn Andersson spin_lock_irqsave(&pg->client_lock, flags);
20058ef4eceSBjorn Andersson list_for_each_entry(client, &pg->clients, node)
20158ef4eceSBjorn Andersson client->pdr_notify(client->priv, new_state);
20293299336SBjorn Andersson spin_unlock_irqrestore(&pg->client_lock, flags);
20358ef4eceSBjorn Andersson pg->client_state = new_state;
20458ef4eceSBjorn Andersson }
20558ef4eceSBjorn Andersson }
20658ef4eceSBjorn Andersson
pmic_glink_pdr_callback(int state,char * svc_path,void * priv)20758ef4eceSBjorn Andersson static void pmic_glink_pdr_callback(int state, char *svc_path, void *priv)
20858ef4eceSBjorn Andersson {
20958ef4eceSBjorn Andersson struct pmic_glink *pg = priv;
21058ef4eceSBjorn Andersson
21158ef4eceSBjorn Andersson mutex_lock(&pg->state_lock);
21258ef4eceSBjorn Andersson pg->pdr_state = state;
21358ef4eceSBjorn Andersson
21458ef4eceSBjorn Andersson pmic_glink_state_notify_clients(pg);
21558ef4eceSBjorn Andersson mutex_unlock(&pg->state_lock);
21658ef4eceSBjorn Andersson }
21758ef4eceSBjorn Andersson
pmic_glink_rpmsg_probe(struct rpmsg_device * rpdev)21858ef4eceSBjorn Andersson static int pmic_glink_rpmsg_probe(struct rpmsg_device *rpdev)
21958ef4eceSBjorn Andersson {
22058ef4eceSBjorn Andersson struct pmic_glink *pg = __pmic_glink;
22158ef4eceSBjorn Andersson int ret = 0;
22258ef4eceSBjorn Andersson
22358ef4eceSBjorn Andersson mutex_lock(&__pmic_glink_lock);
22458ef4eceSBjorn Andersson if (!pg) {
22558ef4eceSBjorn Andersson ret = dev_err_probe(&rpdev->dev, -ENODEV, "no pmic_glink device to attach to\n");
22658ef4eceSBjorn Andersson goto out_unlock;
22758ef4eceSBjorn Andersson }
22858ef4eceSBjorn Andersson
22958ef4eceSBjorn Andersson dev_set_drvdata(&rpdev->dev, pg);
23058ef4eceSBjorn Andersson
23158ef4eceSBjorn Andersson mutex_lock(&pg->state_lock);
23258ef4eceSBjorn Andersson pg->ept = rpdev->ept;
23358ef4eceSBjorn Andersson pmic_glink_state_notify_clients(pg);
23458ef4eceSBjorn Andersson mutex_unlock(&pg->state_lock);
23558ef4eceSBjorn Andersson
23658ef4eceSBjorn Andersson out_unlock:
23758ef4eceSBjorn Andersson mutex_unlock(&__pmic_glink_lock);
23858ef4eceSBjorn Andersson return ret;
23958ef4eceSBjorn Andersson }
24058ef4eceSBjorn Andersson
pmic_glink_rpmsg_remove(struct rpmsg_device * rpdev)24158ef4eceSBjorn Andersson static void pmic_glink_rpmsg_remove(struct rpmsg_device *rpdev)
24258ef4eceSBjorn Andersson {
24358ef4eceSBjorn Andersson struct pmic_glink *pg;
24458ef4eceSBjorn Andersson
24558ef4eceSBjorn Andersson mutex_lock(&__pmic_glink_lock);
24658ef4eceSBjorn Andersson pg = __pmic_glink;
24758ef4eceSBjorn Andersson if (!pg)
24858ef4eceSBjorn Andersson goto out_unlock;
24958ef4eceSBjorn Andersson
25058ef4eceSBjorn Andersson mutex_lock(&pg->state_lock);
25158ef4eceSBjorn Andersson pg->ept = NULL;
25258ef4eceSBjorn Andersson pmic_glink_state_notify_clients(pg);
25358ef4eceSBjorn Andersson mutex_unlock(&pg->state_lock);
25458ef4eceSBjorn Andersson out_unlock:
25558ef4eceSBjorn Andersson mutex_unlock(&__pmic_glink_lock);
25658ef4eceSBjorn Andersson }
25758ef4eceSBjorn Andersson
25858ef4eceSBjorn Andersson static const struct rpmsg_device_id pmic_glink_rpmsg_id_match[] = {
25958ef4eceSBjorn Andersson { "PMIC_RTR_ADSP_APPS" },
26058ef4eceSBjorn Andersson {}
26158ef4eceSBjorn Andersson };
26258ef4eceSBjorn Andersson
26358ef4eceSBjorn Andersson static struct rpmsg_driver pmic_glink_rpmsg_driver = {
26458ef4eceSBjorn Andersson .probe = pmic_glink_rpmsg_probe,
26558ef4eceSBjorn Andersson .remove = pmic_glink_rpmsg_remove,
26658ef4eceSBjorn Andersson .callback = pmic_glink_rpmsg_callback,
26758ef4eceSBjorn Andersson .id_table = pmic_glink_rpmsg_id_match,
26858ef4eceSBjorn Andersson .drv = {
26958ef4eceSBjorn Andersson .name = "qcom_pmic_glink_rpmsg",
27058ef4eceSBjorn Andersson },
27158ef4eceSBjorn Andersson };
27258ef4eceSBjorn Andersson
pmic_glink_probe(struct platform_device * pdev)27358ef4eceSBjorn Andersson static int pmic_glink_probe(struct platform_device *pdev)
27458ef4eceSBjorn Andersson {
275ff642773SNeil Armstrong const unsigned long *match_data;
27658ef4eceSBjorn Andersson struct pdr_service *service;
27758ef4eceSBjorn Andersson struct pmic_glink *pg;
27858ef4eceSBjorn Andersson int ret;
27958ef4eceSBjorn Andersson
28058ef4eceSBjorn Andersson pg = devm_kzalloc(&pdev->dev, sizeof(*pg), GFP_KERNEL);
28158ef4eceSBjorn Andersson if (!pg)
28258ef4eceSBjorn Andersson return -ENOMEM;
28358ef4eceSBjorn Andersson
28458ef4eceSBjorn Andersson dev_set_drvdata(&pdev->dev, pg);
28558ef4eceSBjorn Andersson
28658ef4eceSBjorn Andersson pg->dev = &pdev->dev;
28758ef4eceSBjorn Andersson
28858ef4eceSBjorn Andersson INIT_LIST_HEAD(&pg->clients);
28993299336SBjorn Andersson spin_lock_init(&pg->client_lock);
29058ef4eceSBjorn Andersson mutex_init(&pg->state_lock);
29158ef4eceSBjorn Andersson
292ff642773SNeil Armstrong match_data = (unsigned long *)of_device_get_match_data(&pdev->dev);
2934db09e7bSDmitry Baryshkov if (!match_data)
2944db09e7bSDmitry Baryshkov return -EINVAL;
2954db09e7bSDmitry Baryshkov
296ff642773SNeil Armstrong pg->client_mask = *match_data;
297ff642773SNeil Armstrong
298f79ee787SRob Clark pg->pdr = pdr_handle_alloc(pmic_glink_pdr_callback, pg);
299f79ee787SRob Clark if (IS_ERR(pg->pdr)) {
300f79ee787SRob Clark ret = dev_err_probe(&pdev->dev, PTR_ERR(pg->pdr),
301f79ee787SRob Clark "failed to initialize pdr\n");
302f79ee787SRob Clark return ret;
303f79ee787SRob Clark }
304f79ee787SRob Clark
305ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI)) {
306ff642773SNeil Armstrong ret = pmic_glink_add_aux_device(pg, &pg->ucsi_aux, "ucsi");
30758ef4eceSBjorn Andersson if (ret)
308f79ee787SRob Clark goto out_release_pdr_handle;
309ff642773SNeil Armstrong }
310ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE)) {
311ff642773SNeil Armstrong ret = pmic_glink_add_aux_device(pg, &pg->altmode_aux, "altmode");
312ff642773SNeil Armstrong if (ret)
313ff642773SNeil Armstrong goto out_release_ucsi_aux;
314ff642773SNeil Armstrong }
315ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT)) {
31658ef4eceSBjorn Andersson ret = pmic_glink_add_aux_device(pg, &pg->ps_aux, "power-supply");
31758ef4eceSBjorn Andersson if (ret)
31858ef4eceSBjorn Andersson goto out_release_altmode_aux;
319ff642773SNeil Armstrong }
32058ef4eceSBjorn Andersson
32158ef4eceSBjorn Andersson service = pdr_add_lookup(pg->pdr, "tms/servreg", "msm/adsp/charger_pd");
32258ef4eceSBjorn Andersson if (IS_ERR(service)) {
32358ef4eceSBjorn Andersson ret = dev_err_probe(&pdev->dev, PTR_ERR(service),
32458ef4eceSBjorn Andersson "failed adding pdr lookup for charger_pd\n");
325f79ee787SRob Clark goto out_release_aux_devices;
32658ef4eceSBjorn Andersson }
32758ef4eceSBjorn Andersson
32858ef4eceSBjorn Andersson mutex_lock(&__pmic_glink_lock);
32958ef4eceSBjorn Andersson __pmic_glink = pg;
33058ef4eceSBjorn Andersson mutex_unlock(&__pmic_glink_lock);
33158ef4eceSBjorn Andersson
33258ef4eceSBjorn Andersson return 0;
33358ef4eceSBjorn Andersson
33458ef4eceSBjorn Andersson out_release_aux_devices:
335ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT))
33658ef4eceSBjorn Andersson pmic_glink_del_aux_device(pg, &pg->ps_aux);
33758ef4eceSBjorn Andersson out_release_altmode_aux:
338ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE))
33958ef4eceSBjorn Andersson pmic_glink_del_aux_device(pg, &pg->altmode_aux);
340ff642773SNeil Armstrong out_release_ucsi_aux:
341ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI))
342ff642773SNeil Armstrong pmic_glink_del_aux_device(pg, &pg->ucsi_aux);
343f79ee787SRob Clark out_release_pdr_handle:
344f79ee787SRob Clark pdr_handle_release(pg->pdr);
34558ef4eceSBjorn Andersson
34658ef4eceSBjorn Andersson return ret;
34758ef4eceSBjorn Andersson }
34858ef4eceSBjorn Andersson
pmic_glink_remove(struct platform_device * pdev)3494b3373e4SUwe Kleine-König static void pmic_glink_remove(struct platform_device *pdev)
35058ef4eceSBjorn Andersson {
35158ef4eceSBjorn Andersson struct pmic_glink *pg = dev_get_drvdata(&pdev->dev);
35258ef4eceSBjorn Andersson
35358ef4eceSBjorn Andersson pdr_handle_release(pg->pdr);
35458ef4eceSBjorn Andersson
355ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_BATT))
35658ef4eceSBjorn Andersson pmic_glink_del_aux_device(pg, &pg->ps_aux);
357ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_ALTMODE))
35858ef4eceSBjorn Andersson pmic_glink_del_aux_device(pg, &pg->altmode_aux);
359ff642773SNeil Armstrong if (pg->client_mask & BIT(PMIC_GLINK_CLIENT_UCSI))
360ff642773SNeil Armstrong pmic_glink_del_aux_device(pg, &pg->ucsi_aux);
36158ef4eceSBjorn Andersson
36258ef4eceSBjorn Andersson mutex_lock(&__pmic_glink_lock);
36358ef4eceSBjorn Andersson __pmic_glink = NULL;
36458ef4eceSBjorn Andersson mutex_unlock(&__pmic_glink_lock);
36558ef4eceSBjorn Andersson }
36658ef4eceSBjorn Andersson
367ad3dd959SJohan Hovold static const unsigned long pmic_glink_sc8280xp_client_mask = BIT(PMIC_GLINK_CLIENT_BATT) |
368ad3dd959SJohan Hovold BIT(PMIC_GLINK_CLIENT_ALTMODE);
369ad3dd959SJohan Hovold
370ff642773SNeil Armstrong static const unsigned long pmic_glink_sm8450_client_mask = BIT(PMIC_GLINK_CLIENT_BATT) |
3714b11fa4fSNeil Armstrong BIT(PMIC_GLINK_CLIENT_ALTMODE) |
3724b11fa4fSNeil Armstrong BIT(PMIC_GLINK_CLIENT_UCSI);
3734b11fa4fSNeil Armstrong
37458ef4eceSBjorn Andersson static const struct of_device_id pmic_glink_of_match[] = {
375ad3dd959SJohan Hovold { .compatible = "qcom,sc8280xp-pmic-glink", .data = &pmic_glink_sc8280xp_client_mask },
3764db09e7bSDmitry Baryshkov { .compatible = "qcom,pmic-glink", .data = &pmic_glink_sm8450_client_mask },
37758ef4eceSBjorn Andersson {}
37858ef4eceSBjorn Andersson };
37958ef4eceSBjorn Andersson MODULE_DEVICE_TABLE(of, pmic_glink_of_match);
38058ef4eceSBjorn Andersson
38158ef4eceSBjorn Andersson static struct platform_driver pmic_glink_driver = {
38258ef4eceSBjorn Andersson .probe = pmic_glink_probe,
3834b3373e4SUwe Kleine-König .remove_new = pmic_glink_remove,
38458ef4eceSBjorn Andersson .driver = {
38558ef4eceSBjorn Andersson .name = "qcom_pmic_glink",
38658ef4eceSBjorn Andersson .of_match_table = pmic_glink_of_match,
38758ef4eceSBjorn Andersson },
38858ef4eceSBjorn Andersson };
38958ef4eceSBjorn Andersson
pmic_glink_init(void)39058ef4eceSBjorn Andersson static int pmic_glink_init(void)
39158ef4eceSBjorn Andersson {
3920780c836SChen Ni int ret;
3930780c836SChen Ni
3940780c836SChen Ni ret = platform_driver_register(&pmic_glink_driver);
3950780c836SChen Ni if (ret < 0)
3960780c836SChen Ni return ret;
3970780c836SChen Ni
3980780c836SChen Ni ret = register_rpmsg_driver(&pmic_glink_rpmsg_driver);
3990780c836SChen Ni if (ret < 0) {
4000780c836SChen Ni platform_driver_unregister(&pmic_glink_driver);
4010780c836SChen Ni return ret;
4020780c836SChen Ni }
40358ef4eceSBjorn Andersson
40458ef4eceSBjorn Andersson return 0;
40527117558SJohan Hovold }
40658ef4eceSBjorn Andersson module_init(pmic_glink_init);
40758ef4eceSBjorn Andersson
pmic_glink_exit(void)40858ef4eceSBjorn Andersson static void pmic_glink_exit(void)
40958ef4eceSBjorn Andersson {
41058ef4eceSBjorn Andersson unregister_rpmsg_driver(&pmic_glink_rpmsg_driver);
41158ef4eceSBjorn Andersson platform_driver_unregister(&pmic_glink_driver);
41227117558SJohan Hovold }
41358ef4eceSBjorn Andersson module_exit(pmic_glink_exit);
41458ef4eceSBjorn Andersson
41558ef4eceSBjorn Andersson MODULE_DESCRIPTION("Qualcomm PMIC GLINK driver");
41658ef4eceSBjorn Andersson MODULE_LICENSE("GPL");
417