drivers/rpmsg/mtk_rpmsg.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // Copyright 2019 Google LLC.
0004
0005 #include <linux/kernel.h>
0006 #include <linux/module.h>
0007 #include <linux/of.h>
0008 #include <linux/platform_device.h>
0009 #include <linux/remoteproc.h>
0010 #include <linux/rpmsg/mtk_rpmsg.h>
0011 #include <linux/slab.h>
0012 #include <linux/workqueue.h>
0013
0014 #include "rpmsg_internal.h"
0015
0016 struct mtk_rpmsg_rproc_subdev {
0017     struct platform_device *pdev;
0018     struct mtk_rpmsg_info *info;
0019     struct rpmsg_endpoint *ns_ept;
0020     struct rproc_subdev subdev;
0021
0022     struct work_struct register_work;
0023     struct list_head channels;
0024     struct mutex channels_lock;
0025 };
0026
0027 #define to_mtk_subdev(d) container_of(d, struct mtk_rpmsg_rproc_subdev, subdev)
0028
0029 struct mtk_rpmsg_channel_info {
0030     struct rpmsg_channel_info info;
0031     bool registered;
0032     struct list_head list;
0033 };
0034
0035 /**
0036  * struct rpmsg_ns_msg - dynamic name service announcement message
0037  * @name: name of remote service that is published
0038  * @addr: address of remote service that is published
0039  *
0040  * This message is sent across to publish a new service. When we receive these
0041  * messages, an appropriate rpmsg channel (i.e device) is created. In turn, the
0042  * ->probe() handler of the appropriate rpmsg driver will be invoked
0043  *  (if/as-soon-as one is registered).
0044  */
0045 struct rpmsg_ns_msg {
0046     char name[RPMSG_NAME_SIZE];
0047     u32 addr;
0048 } __packed;
0049
0050 struct mtk_rpmsg_device {
0051     struct rpmsg_device rpdev;
0052     struct mtk_rpmsg_rproc_subdev *mtk_subdev;
0053 };
0054
0055 struct mtk_rpmsg_endpoint {
0056     struct rpmsg_endpoint ept;
0057     struct mtk_rpmsg_rproc_subdev *mtk_subdev;
0058 };
0059
0060 #define to_mtk_rpmsg_device(r) container_of(r, struct mtk_rpmsg_device, rpdev)
0061 #define to_mtk_rpmsg_endpoint(r) container_of(r, struct mtk_rpmsg_endpoint, ept)
0062
0063 static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops;
0064
0065 static void __mtk_ept_release(struct kref *kref)
0066 {
0067     struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint,
0068                           refcount);
0069     kfree(to_mtk_rpmsg_endpoint(ept));
0070 }
0071
0072 static void mtk_rpmsg_ipi_handler(void *data, unsigned int len, void *priv)
0073 {
0074     struct mtk_rpmsg_endpoint *mept = priv;
0075     struct rpmsg_endpoint *ept = &mept->ept;
0076     int ret;
0077
0078     ret = (*ept->cb)(ept->rpdev, data, len, ept->priv, ept->addr);
0079     if (ret)
0080         dev_warn(&ept->rpdev->dev, "rpmsg handler return error = %d",
0081              ret);
0082 }
0083
0084 static struct rpmsg_endpoint *
0085 __mtk_create_ept(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
0086          struct rpmsg_device *rpdev, rpmsg_rx_cb_t cb, void *priv,
0087          u32 id)
0088 {
0089     struct mtk_rpmsg_endpoint *mept;
0090     struct rpmsg_endpoint *ept;
0091     struct platform_device *pdev = mtk_subdev->pdev;
0092     int ret;
0093
0094     mept = kzalloc(sizeof(*mept), GFP_KERNEL);
0095     if (!mept)
0096         return NULL;
0097     mept->mtk_subdev = mtk_subdev;
0098
0099     ept = &mept->ept;
0100     kref_init(&ept->refcount);
0101
0102     ept->rpdev = rpdev;
0103     ept->cb = cb;
0104     ept->priv = priv;
0105     ept->ops = &mtk_rpmsg_endpoint_ops;
0106     ept->addr = id;
0107
0108     ret = mtk_subdev->info->register_ipi(pdev, id, mtk_rpmsg_ipi_handler,
0109                          mept);
0110     if (ret) {
0111         dev_err(&pdev->dev, "IPI register failed, id = %d", id);
0112         kref_put(&ept->refcount, __mtk_ept_release);
0113         return NULL;
0114     }
0115
0116     return ept;
0117 }
0118
0119 static struct rpmsg_endpoint *
0120 mtk_rpmsg_create_ept(struct rpmsg_device *rpdev, rpmsg_rx_cb_t cb, void *priv,
0121              struct rpmsg_channel_info chinfo)
0122 {
0123     struct mtk_rpmsg_rproc_subdev *mtk_subdev =
0124         to_mtk_rpmsg_device(rpdev)->mtk_subdev;
0125
0126     return __mtk_create_ept(mtk_subdev, rpdev, cb, priv, chinfo.src);
0127 }
0128
0129 static void mtk_rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
0130 {
0131     struct mtk_rpmsg_rproc_subdev *mtk_subdev =
0132         to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
0133
0134     mtk_subdev->info->unregister_ipi(mtk_subdev->pdev, ept->addr);
0135     kref_put(&ept->refcount, __mtk_ept_release);
0136 }
0137
0138 static int mtk_rpmsg_send(struct rpmsg_endpoint *ept, void *data, int len)
0139 {
0140     struct mtk_rpmsg_rproc_subdev *mtk_subdev =
0141         to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
0142
0143     return mtk_subdev->info->send_ipi(mtk_subdev->pdev, ept->addr, data,
0144                       len, 0);
0145 }
0146
0147 static int mtk_rpmsg_trysend(struct rpmsg_endpoint *ept, void *data, int len)
0148 {
0149     struct mtk_rpmsg_rproc_subdev *mtk_subdev =
0150         to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
0151
0152     /*
0153      * TODO: This currently is same as mtk_rpmsg_send, and wait until SCP
0154      * received the last command.
0155      */
0156     return mtk_subdev->info->send_ipi(mtk_subdev->pdev, ept->addr, data,
0157                       len, 0);
0158 }
0159
0160 static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops = {
0161     .destroy_ept = mtk_rpmsg_destroy_ept,
0162     .send = mtk_rpmsg_send,
0163     .trysend = mtk_rpmsg_trysend,
0164 };
0165
0166 static void mtk_rpmsg_release_device(struct device *dev)
0167 {
0168     struct rpmsg_device *rpdev = to_rpmsg_device(dev);
0169     struct mtk_rpmsg_device *mdev = to_mtk_rpmsg_device(rpdev);
0170
0171     kfree(mdev);
0172 }
0173
0174 static const struct rpmsg_device_ops mtk_rpmsg_device_ops = {
0175     .create_ept = mtk_rpmsg_create_ept,
0176 };
0177
0178 static struct device_node *
0179 mtk_rpmsg_match_device_subnode(struct device_node *node, const char *channel)
0180 {
0181     struct device_node *child;
0182     const char *name;
0183     int ret;
0184
0185     for_each_available_child_of_node(node, child) {
0186         ret = of_property_read_string(child, "mediatek,rpmsg-name", &name);
0187         if (ret)
0188             continue;
0189
0190         if (strcmp(name, channel) == 0)
0191             return child;
0192     }
0193
0194     return NULL;
0195 }
0196
0197 static int mtk_rpmsg_register_device(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
0198                      struct rpmsg_channel_info *info)
0199 {
0200     struct rpmsg_device *rpdev;
0201     struct mtk_rpmsg_device *mdev;
0202     struct platform_device *pdev = mtk_subdev->pdev;
0203
0204     mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
0205     if (!mdev)
0206         return -ENOMEM;
0207
0208     mdev->mtk_subdev = mtk_subdev;
0209
0210     rpdev = &mdev->rpdev;
0211     rpdev->ops = &mtk_rpmsg_device_ops;
0212     rpdev->src = info->src;
0213     rpdev->dst = info->dst;
0214     strscpy(rpdev->id.name, info->name, RPMSG_NAME_SIZE);
0215
0216     rpdev->dev.of_node =
0217         mtk_rpmsg_match_device_subnode(pdev->dev.of_node, info->name);
0218     rpdev->dev.parent = &pdev->dev;
0219     rpdev->dev.release = mtk_rpmsg_release_device;
0220
0221     return rpmsg_register_device(rpdev);
0222 }
0223
0224 static void mtk_register_device_work_function(struct work_struct *register_work)
0225 {
0226     struct mtk_rpmsg_rproc_subdev *subdev = container_of(
0227         register_work, struct mtk_rpmsg_rproc_subdev, register_work);
0228     struct platform_device *pdev = subdev->pdev;
0229     struct mtk_rpmsg_channel_info *info;
0230     int ret;
0231
0232     mutex_lock(&subdev->channels_lock);
0233     list_for_each_entry(info, &subdev->channels, list) {
0234         if (info->registered)
0235             continue;
0236
0237         mutex_unlock(&subdev->channels_lock);
0238         ret = mtk_rpmsg_register_device(subdev, &info->info);
0239         mutex_lock(&subdev->channels_lock);
0240         if (ret) {
0241             dev_err(&pdev->dev, "Can't create rpmsg_device\n");
0242             continue;
0243         }
0244
0245         info->registered = true;
0246     }
0247     mutex_unlock(&subdev->channels_lock);
0248 }
0249
0250 static int mtk_rpmsg_create_device(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
0251                    char *name, u32 addr)
0252 {
0253     struct mtk_rpmsg_channel_info *info;
0254
0255     info = kzalloc(sizeof(*info), GFP_KERNEL);
0256     if (!info)
0257         return -ENOMEM;
0258
0259     strscpy(info->info.name, name, RPMSG_NAME_SIZE);
0260     info->info.src = addr;
0261     info->info.dst = RPMSG_ADDR_ANY;
0262     mutex_lock(&mtk_subdev->channels_lock);
0263     list_add(&info->list, &mtk_subdev->channels);
0264     mutex_unlock(&mtk_subdev->channels_lock);
0265
0266     schedule_work(&mtk_subdev->register_work);
0267     return 0;
0268 }
0269
0270 static int mtk_rpmsg_ns_cb(struct rpmsg_device *rpdev, void *data, int len,
0271                void *priv, u32 src)
0272 {
0273     struct rpmsg_ns_msg *msg = data;
0274     struct mtk_rpmsg_rproc_subdev *mtk_subdev = priv;
0275     struct device *dev = &mtk_subdev->pdev->dev;
0276
0277     int ret;
0278
0279     if (len != sizeof(*msg)) {
0280         dev_err(dev, "malformed ns msg (%d)\n", len);
0281         return -EINVAL;
0282     }
0283
0284     /*
0285      * the name service ept does _not_ belong to a real rpmsg channel,
0286      * and is handled by the rpmsg bus itself.
0287      * for sanity reasons, make sure a valid rpdev has _not_ sneaked
0288      * in somehow.
0289      */
0290     if (rpdev) {
0291         dev_err(dev, "anomaly: ns ept has an rpdev handle\n");
0292         return -EINVAL;
0293     }
0294
0295     /* don't trust the remote processor for null terminating the name */
0296     msg->name[RPMSG_NAME_SIZE - 1] = '\0';
0297
0298     dev_info(dev, "creating channel %s addr 0x%x\n", msg->name, msg->addr);
0299
0300     ret = mtk_rpmsg_create_device(mtk_subdev, msg->name, msg->addr);
0301     if (ret) {
0302         dev_err(dev, "create rpmsg device failed\n");
0303         return ret;
0304     }
0305
0306     return 0;
0307 }
0308
0309 static int mtk_rpmsg_prepare(struct rproc_subdev *subdev)
0310 {
0311     struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
0312
0313     /* a dedicated endpoint handles the name service msgs */
0314     if (mtk_subdev->info->ns_ipi_id >= 0) {
0315         mtk_subdev->ns_ept =
0316             __mtk_create_ept(mtk_subdev, NULL, mtk_rpmsg_ns_cb,
0317                      mtk_subdev,
0318                      mtk_subdev->info->ns_ipi_id);
0319         if (!mtk_subdev->ns_ept) {
0320             dev_err(&mtk_subdev->pdev->dev,
0321                 "failed to create name service endpoint\n");
0322             return -ENOMEM;
0323         }
0324     }
0325
0326     return 0;
0327 }
0328
0329 static void mtk_rpmsg_unprepare(struct rproc_subdev *subdev)
0330 {
0331     struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
0332
0333     if (mtk_subdev->ns_ept) {
0334         mtk_rpmsg_destroy_ept(mtk_subdev->ns_ept);
0335         mtk_subdev->ns_ept = NULL;
0336     }
0337 }
0338
0339 static void mtk_rpmsg_stop(struct rproc_subdev *subdev, bool crashed)
0340 {
0341     struct mtk_rpmsg_channel_info *info, *next;
0342     struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
0343     struct device *dev = &mtk_subdev->pdev->dev;
0344
0345     /*
0346      * Destroy the name service endpoint here, to avoid new channel being
0347      * created after the rpmsg_unregister_device loop below.
0348      */
0349     if (mtk_subdev->ns_ept) {
0350         mtk_rpmsg_destroy_ept(mtk_subdev->ns_ept);
0351         mtk_subdev->ns_ept = NULL;
0352     }
0353
0354     cancel_work_sync(&mtk_subdev->register_work);
0355
0356     mutex_lock(&mtk_subdev->channels_lock);
0357     list_for_each_entry(info, &mtk_subdev->channels, list) {
0358         if (!info->registered)
0359             continue;
0360         if (rpmsg_unregister_device(dev, &info->info)) {
0361             dev_warn(
0362                 dev,
0363                 "rpmsg_unregister_device failed for %s.%d.%d\n",
0364                 info->info.name, info->info.src,
0365                 info->info.dst);
0366         }
0367     }
0368
0369     list_for_each_entry_safe(info, next,
0370                  &mtk_subdev->channels, list) {
0371         list_del(&info->list);
0372         kfree(info);
0373     }
0374     mutex_unlock(&mtk_subdev->channels_lock);
0375 }
0376
0377 struct rproc_subdev *
0378 mtk_rpmsg_create_rproc_subdev(struct platform_device *pdev,
0379                   struct mtk_rpmsg_info *info)
0380 {
0381     struct mtk_rpmsg_rproc_subdev *mtk_subdev;
0382
0383     mtk_subdev = kzalloc(sizeof(*mtk_subdev), GFP_KERNEL);
0384     if (!mtk_subdev)
0385         return NULL;
0386
0387     mtk_subdev->pdev = pdev;
0388     mtk_subdev->subdev.prepare = mtk_rpmsg_prepare;
0389     mtk_subdev->subdev.stop = mtk_rpmsg_stop;
0390     mtk_subdev->subdev.unprepare = mtk_rpmsg_unprepare;
0391     mtk_subdev->info = info;
0392     INIT_LIST_HEAD(&mtk_subdev->channels);
0393     INIT_WORK(&mtk_subdev->register_work,
0394           mtk_register_device_work_function);
0395     mutex_init(&mtk_subdev->channels_lock);
0396
0397     return &mtk_subdev->subdev;
0398 }
0399 EXPORT_SYMBOL_GPL(mtk_rpmsg_create_rproc_subdev);
0400
0401 void mtk_rpmsg_destroy_rproc_subdev(struct rproc_subdev *subdev)
0402 {
0403     struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
0404
0405     kfree(mtk_subdev);
0406 }
0407 EXPORT_SYMBOL_GPL(mtk_rpmsg_destroy_rproc_subdev);
0408
0409 MODULE_LICENSE("GPL v2");
0410 MODULE_DESCRIPTION("MediaTek scp rpmsg driver");