drivers/rpmsg/mtk_rpmsg.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Copyright 2019 Google LLC.
   4
   5 #include <linux/kernel.h>
   6 #include <linux/module.h>
   7 #include <linux/of.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/remoteproc.h>
  10 #include <linux/rpmsg/mtk_rpmsg.h>
  11 #include <linux/slab.h>
  12 #include <linux/workqueue.h>
  13
  14 #include "rpmsg_internal.h"
  15
  16 struct mtk_rpmsg_rproc_subdev {
  17         struct platform_device *pdev;
  18         struct mtk_rpmsg_info *info;
  19         struct rpmsg_endpoint *ns_ept;
  20         struct rproc_subdev subdev;
  21
  22         struct work_struct register_work;
  23         struct list_head channels;
  24         struct mutex channels_lock;
  25 };
  26
  27 #define to_mtk_subdev(d) container_of(d, struct mtk_rpmsg_rproc_subdev, subdev)
  28
  29 struct mtk_rpmsg_channel_info {
  30         struct rpmsg_channel_info info;
  31         bool registered;
  32         struct list_head list;
  33 };
  34
  35 /**
  36  * struct rpmsg_ns_msg - dynamic name service announcement message
  37  * @name: name of remote service that is published
  38  * @addr: address of remote service that is published
  39  *
  40  * This message is sent across to publish a new service. When we receive these
  41  * messages, an appropriate rpmsg channel (i.e device) is created. In turn, the
  42  * ->probe() handler of the appropriate rpmsg driver will be invoked
  43  *  (if/as-soon-as one is registered).
  44  */
  45 struct rpmsg_ns_msg {
  46         char name[RPMSG_NAME_SIZE];
  47         u32 addr;
  48 } __packed;
  49
  50 struct mtk_rpmsg_device {
  51         struct rpmsg_device rpdev;
  52         struct mtk_rpmsg_rproc_subdev *mtk_subdev;
  53 };
  54
  55 struct mtk_rpmsg_endpoint {
  56         struct rpmsg_endpoint ept;
  57         struct mtk_rpmsg_rproc_subdev *mtk_subdev;
  58 };
  59
  60 #define to_mtk_rpmsg_device(r) container_of(r, struct mtk_rpmsg_device, rpdev)
  61 #define to_mtk_rpmsg_endpoint(r) container_of(r, struct mtk_rpmsg_endpoint, ept)
  62
  63 static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops;
  64
  65 static void __mtk_ept_release(struct kref *kref)
  66 {
  67         struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint,
  68                                                   refcount);
  69         kfree(to_mtk_rpmsg_endpoint(ept));
  70 }
  71
  72 static void mtk_rpmsg_ipi_handler(void *data, unsigned int len, void *priv)
  73 {
  74         struct mtk_rpmsg_endpoint *mept = priv;
  75         struct rpmsg_endpoint *ept = &mept->ept;
  76         int ret;
  77
  78         ret = (*ept->cb)(ept->rpdev, data, len, ept->priv, ept->addr);
  79         if (ret)
  80                 dev_warn(&ept->rpdev->dev, "rpmsg handler return error = %d",
  81                          ret);
  82 }
  83
  84 static struct rpmsg_endpoint *
  85 __mtk_create_ept(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
  86                  struct rpmsg_device *rpdev, rpmsg_rx_cb_t cb, void *priv,
  87                  u32 id)
  88 {
  89         struct mtk_rpmsg_endpoint *mept;
  90         struct rpmsg_endpoint *ept;
  91         struct platform_device *pdev = mtk_subdev->pdev;
  92         int ret;
  93
  94         mept = kzalloc(sizeof(*mept), GFP_KERNEL);
  95         if (!mept)
  96                 return NULL;
  97         mept->mtk_subdev = mtk_subdev;
  98
  99         ept = &mept->ept;
 100         kref_init(&ept->refcount);
 101
 102         ept->rpdev = rpdev;
 103         ept->cb = cb;
 104         ept->priv = priv;
 105         ept->ops = &mtk_rpmsg_endpoint_ops;
 106         ept->addr = id;
 107
 108         ret = mtk_subdev->info->register_ipi(pdev, id, mtk_rpmsg_ipi_handler,
 109                                              mept);
 110         if (ret) {
 111                 dev_err(&pdev->dev, "IPI register failed, id = %d", id);
 112                 kref_put(&ept->refcount, __mtk_ept_release);
 113                 return NULL;
 114         }
 115
 116         return ept;
 117 }
 118
 119 static struct rpmsg_endpoint *
 120 mtk_rpmsg_create_ept(struct rpmsg_device *rpdev, rpmsg_rx_cb_t cb, void *priv,
 121                      struct rpmsg_channel_info chinfo)
 122 {
 123         struct mtk_rpmsg_rproc_subdev *mtk_subdev =
 124                 to_mtk_rpmsg_device(rpdev)->mtk_subdev;
 125
 126         return __mtk_create_ept(mtk_subdev, rpdev, cb, priv, chinfo.src);
 127 }
 128
 129 static void mtk_rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
 130 {
 131         struct mtk_rpmsg_rproc_subdev *mtk_subdev =
 132                 to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
 133
 134         mtk_subdev->info->unregister_ipi(mtk_subdev->pdev, ept->addr);
 135         kref_put(&ept->refcount, __mtk_ept_release);
 136 }
 137
 138 static int mtk_rpmsg_send(struct rpmsg_endpoint *ept, void *data, int len)
 139 {
 140         struct mtk_rpmsg_rproc_subdev *mtk_subdev =
 141                 to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
 142
 143         return mtk_subdev->info->send_ipi(mtk_subdev->pdev, ept->addr, data,
 144                                           len, 0);
 145 }
 146
 147 static int mtk_rpmsg_trysend(struct rpmsg_endpoint *ept, void *data, int len)
 148 {
 149         struct mtk_rpmsg_rproc_subdev *mtk_subdev =
 150                 to_mtk_rpmsg_endpoint(ept)->mtk_subdev;
 151
 152         /*
 153          * TODO: This currently is same as mtk_rpmsg_send, and wait until SCP
 154          * received the last command.
 155          */
 156         return mtk_subdev->info->send_ipi(mtk_subdev->pdev, ept->addr, data,
 157                                           len, 0);
 158 }
 159
 160 static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops = {
 161         .destroy_ept = mtk_rpmsg_destroy_ept,
 162         .send = mtk_rpmsg_send,
 163         .trysend = mtk_rpmsg_trysend,
 164 };
 165
 166 static void mtk_rpmsg_release_device(struct device *dev)
 167 {
 168         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 169         struct mtk_rpmsg_device *mdev = to_mtk_rpmsg_device(rpdev);
 170
 171         kfree(mdev);
 172 }
 173
 174 static const struct rpmsg_device_ops mtk_rpmsg_device_ops = {
 175         .create_ept = mtk_rpmsg_create_ept,
 176 };
 177
 178 static struct device_node *
 179 mtk_rpmsg_match_device_subnode(struct device_node *node, const char *channel)
 180 {
 181         struct device_node *child;
 182         const char *name;
 183         int ret;
 184
 185         for_each_available_child_of_node(node, child) {
 186                 ret = of_property_read_string(child, "mtk,rpmsg-name", &name);
 187                 if (ret)
 188                         continue;
 189
 190                 if (strcmp(name, channel) == 0)
 191                         return child;
 192         }
 193
 194         return NULL;
 195 }
 196
 197 static int mtk_rpmsg_register_device(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
 198                                      struct rpmsg_channel_info *info)
 199 {
 200         struct rpmsg_device *rpdev;
 201         struct mtk_rpmsg_device *mdev;
 202         struct platform_device *pdev = mtk_subdev->pdev;
 203         int ret;
 204
 205         mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
 206         if (!mdev)
 207                 return -ENOMEM;
 208
 209         mdev->mtk_subdev = mtk_subdev;
 210
 211         rpdev = &mdev->rpdev;
 212         rpdev->ops = &mtk_rpmsg_device_ops;
 213         rpdev->src = info->src;
 214         rpdev->dst = info->dst;
 215         strscpy(rpdev->id.name, info->name, RPMSG_NAME_SIZE);
 216
 217         rpdev->dev.of_node =
 218                 mtk_rpmsg_match_device_subnode(pdev->dev.of_node, info->name);
 219         rpdev->dev.parent = &pdev->dev;
 220         rpdev->dev.release = mtk_rpmsg_release_device;
 221
 222         ret = rpmsg_register_device(rpdev);
 223         if (ret) {
 224                 kfree(mdev);
 225                 return ret;
 226         }
 227
 228         return 0;
 229 }
 230
 231 static void mtk_register_device_work_function(struct work_struct *register_work)
 232 {
 233         struct mtk_rpmsg_rproc_subdev *subdev = container_of(
 234                 register_work, struct mtk_rpmsg_rproc_subdev, register_work);
 235         struct platform_device *pdev = subdev->pdev;
 236         struct mtk_rpmsg_channel_info *info;
 237         int ret;
 238
 239         mutex_lock(&subdev->channels_lock);
 240         list_for_each_entry(info, &subdev->channels, list) {
 241                 if (info->registered)
 242                         continue;
 243
 244                 ret = mtk_rpmsg_register_device(subdev, &info->info);
 245                 if (ret) {
 246                         dev_err(&pdev->dev, "Can't create rpmsg_device\n");
 247                         continue;
 248                 }
 249
 250                 info->registered = true;
 251         }
 252         mutex_unlock(&subdev->channels_lock);
 253 }
 254
 255 static int mtk_rpmsg_create_device(struct mtk_rpmsg_rproc_subdev *mtk_subdev,
 256                                    char *name, u32 addr)
 257 {
 258         struct mtk_rpmsg_channel_info *info;
 259
 260         info = kzalloc(sizeof(*info), GFP_KERNEL);
 261         if (!info)
 262                 return -ENOMEM;
 263
 264         strscpy(info->info.name, name, RPMSG_NAME_SIZE);
 265         info->info.src = addr;
 266         info->info.dst = RPMSG_ADDR_ANY;
 267         mutex_lock(&mtk_subdev->channels_lock);
 268         list_add(&info->list, &mtk_subdev->channels);
 269         mutex_unlock(&mtk_subdev->channels_lock);
 270
 271         schedule_work(&mtk_subdev->register_work);
 272         return 0;
 273 }
 274
 275 static int mtk_rpmsg_ns_cb(struct rpmsg_device *rpdev, void *data, int len,
 276                            void *priv, u32 src)
 277 {
 278         struct rpmsg_ns_msg *msg = data;
 279         struct mtk_rpmsg_rproc_subdev *mtk_subdev = priv;
 280         struct device *dev = &mtk_subdev->pdev->dev;
 281
 282         int ret;
 283
 284         if (len != sizeof(*msg)) {
 285                 dev_err(dev, "malformed ns msg (%d)\n", len);
 286                 return -EINVAL;
 287         }
 288
 289         /*
 290          * the name service ept does _not_ belong to a real rpmsg channel,
 291          * and is handled by the rpmsg bus itself.
 292          * for sanity reasons, make sure a valid rpdev has _not_ sneaked
 293          * in somehow.
 294          */
 295         if (rpdev) {
 296                 dev_err(dev, "anomaly: ns ept has an rpdev handle\n");
 297                 return -EINVAL;
 298         }
 299
 300         /* don't trust the remote processor for null terminating the name */
 301         msg->name[RPMSG_NAME_SIZE - 1] = '\0';
 302
 303         dev_info(dev, "creating channel %s addr 0x%x\n", msg->name, msg->addr);
 304
 305         ret = mtk_rpmsg_create_device(mtk_subdev, msg->name, msg->addr);
 306         if (ret) {
 307                 dev_err(dev, "create rpmsg device failed\n");
 308                 return ret;
 309         }
 310
 311         return 0;
 312 }
 313
 314 static int mtk_rpmsg_prepare(struct rproc_subdev *subdev)
 315 {
 316         struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
 317
 318         /* a dedicated endpoint handles the name service msgs */
 319         if (mtk_subdev->info->ns_ipi_id >= 0) {
 320                 mtk_subdev->ns_ept =
 321                         __mtk_create_ept(mtk_subdev, NULL, mtk_rpmsg_ns_cb,
 322                                          mtk_subdev,
 323                                          mtk_subdev->info->ns_ipi_id);
 324                 if (!mtk_subdev->ns_ept) {
 325                         dev_err(&mtk_subdev->pdev->dev,
 326                                 "failed to create name service endpoint\n");
 327                         return -ENOMEM;
 328                 }
 329         }
 330
 331         return 0;
 332 }
 333
 334 static void mtk_rpmsg_unprepare(struct rproc_subdev *subdev)
 335 {
 336         struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
 337
 338         if (mtk_subdev->ns_ept) {
 339                 mtk_rpmsg_destroy_ept(mtk_subdev->ns_ept);
 340                 mtk_subdev->ns_ept = NULL;
 341         }
 342 }
 343
 344 static void mtk_rpmsg_stop(struct rproc_subdev *subdev, bool crashed)
 345 {
 346         struct mtk_rpmsg_channel_info *info, *next;
 347         struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
 348         struct device *dev = &mtk_subdev->pdev->dev;
 349
 350         /*
 351          * Destroy the name service endpoint here, to avoid new channel being
 352          * created after the rpmsg_unregister_device loop below.
 353          */
 354         if (mtk_subdev->ns_ept) {
 355                 mtk_rpmsg_destroy_ept(mtk_subdev->ns_ept);
 356                 mtk_subdev->ns_ept = NULL;
 357         }
 358
 359         cancel_work_sync(&mtk_subdev->register_work);
 360
 361         mutex_lock(&mtk_subdev->channels_lock);
 362         list_for_each_entry(info, &mtk_subdev->channels, list) {
 363                 if (!info->registered)
 364                         continue;
 365                 if (rpmsg_unregister_device(dev, &info->info)) {
 366                         dev_warn(
 367                                 dev,
 368                                 "rpmsg_unregister_device failed for %s.%d.%d\n",
 369                                 info->info.name, info->info.src,
 370                                 info->info.dst);
 371                 }
 372         }
 373
 374         list_for_each_entry_safe(info, next,
 375                                  &mtk_subdev->channels, list) {
 376                 list_del(&info->list);
 377                 kfree(info);
 378         }
 379         mutex_unlock(&mtk_subdev->channels_lock);
 380 }
 381
 382 struct rproc_subdev *
 383 mtk_rpmsg_create_rproc_subdev(struct platform_device *pdev,
 384                               struct mtk_rpmsg_info *info)
 385 {
 386         struct mtk_rpmsg_rproc_subdev *mtk_subdev;
 387
 388         mtk_subdev = kzalloc(sizeof(*mtk_subdev), GFP_KERNEL);
 389         if (!mtk_subdev)
 390                 return NULL;
 391
 392         mtk_subdev->pdev = pdev;
 393         mtk_subdev->subdev.prepare = mtk_rpmsg_prepare;
 394         mtk_subdev->subdev.stop = mtk_rpmsg_stop;
 395         mtk_subdev->subdev.unprepare = mtk_rpmsg_unprepare;
 396         mtk_subdev->info = info;
 397         INIT_LIST_HEAD(&mtk_subdev->channels);
 398         INIT_WORK(&mtk_subdev->register_work,
 399                   mtk_register_device_work_function);
 400         mutex_init(&mtk_subdev->channels_lock);
 401
 402         return &mtk_subdev->subdev;
 403 }
 404 EXPORT_SYMBOL_GPL(mtk_rpmsg_create_rproc_subdev);
 405
 406 void mtk_rpmsg_destroy_rproc_subdev(struct rproc_subdev *subdev)
 407 {
 408         struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev);
 409
 410         kfree(mtk_subdev);
 411 }
 412 EXPORT_SYMBOL_GPL(mtk_rpmsg_destroy_rproc_subdev);
 413
 414 MODULE_LICENSE("GPL v2");
 415 MODULE_DESCRIPTION("MediaTek scp rpmsg driver");