drivers/misc/fastrpc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2011-2018, The Linux Foundation. All rights reserved.
   3 // Copyright (c) 2018, Linaro Limited
   4
   5 #include <linux/completion.h>
   6 #include <linux/device.h>
   7 #include <linux/dma-buf.h>
   8 #include <linux/dma-mapping.h>
   9 #include <linux/idr.h>
  10 #include <linux/list.h>
  11 #include <linux/miscdevice.h>
  12 #include <linux/module.h>
  13 #include <linux/of_address.h>
  14 #include <linux/of.h>
  15 #include <linux/sort.h>
  16 #include <linux/of_platform.h>
  17 #include <linux/rpmsg.h>
  18 #include <linux/scatterlist.h>
  19 #include <linux/slab.h>
  20 #include <linux/qcom_scm.h>
  21 #include <uapi/misc/fastrpc.h>
  22
  23 #define ADSP_DOMAIN_ID (0)
  24 #define MDSP_DOMAIN_ID (1)
  25 #define SDSP_DOMAIN_ID (2)
  26 #define CDSP_DOMAIN_ID (3)
  27 #define FASTRPC_DEV_MAX         4 /* adsp, mdsp, slpi, cdsp*/
  28 #define FASTRPC_MAX_SESSIONS    13 /*12 compute, 1 cpz*/
  29 #define FASTRPC_MAX_VMIDS       16
  30 #define FASTRPC_ALIGN           128
  31 #define FASTRPC_MAX_FDLIST      16
  32 #define FASTRPC_MAX_CRCLIST     64
  33 #define FASTRPC_PHYS(p) ((p) & 0xffffffff)
  34 #define FASTRPC_CTX_MAX (256)
  35 #define FASTRPC_INIT_HANDLE     1
  36 #define FASTRPC_DSP_UTILITIES_HANDLE    2
  37 #define FASTRPC_CTXID_MASK (0xFF0)
  38 #define INIT_FILELEN_MAX (2 * 1024 * 1024)
  39 #define FASTRPC_DEVICE_NAME     "fastrpc"
  40 #define ADSP_MMAP_ADD_PAGES 0x1000
  41 #define DSP_UNSUPPORTED_API (0x80000414)
  42 /* MAX NUMBER of DSP ATTRIBUTES SUPPORTED */
  43 #define FASTRPC_MAX_DSP_ATTRIBUTES (256)
  44 #define FASTRPC_MAX_DSP_ATTRIBUTES_LEN (sizeof(u32) * FASTRPC_MAX_DSP_ATTRIBUTES)
  45
  46 /* Retrives number of input buffers from the scalars parameter */
  47 #define REMOTE_SCALARS_INBUFS(sc)       (((sc) >> 16) & 0x0ff)
  48
  49 /* Retrives number of output buffers from the scalars parameter */
  50 #define REMOTE_SCALARS_OUTBUFS(sc)      (((sc) >> 8) & 0x0ff)
  51
  52 /* Retrives number of input handles from the scalars parameter */
  53 #define REMOTE_SCALARS_INHANDLES(sc)    (((sc) >> 4) & 0x0f)
  54
  55 /* Retrives number of output handles from the scalars parameter */
  56 #define REMOTE_SCALARS_OUTHANDLES(sc)   ((sc) & 0x0f)
  57
  58 #define REMOTE_SCALARS_LENGTH(sc)       (REMOTE_SCALARS_INBUFS(sc) +   \
  59                                          REMOTE_SCALARS_OUTBUFS(sc) +  \
  60                                          REMOTE_SCALARS_INHANDLES(sc)+ \
  61                                          REMOTE_SCALARS_OUTHANDLES(sc))
  62 #define FASTRPC_BUILD_SCALARS(attr, method, in, out, oin, oout)  \
  63                                 (((attr & 0x07) << 29) |                \
  64                                 ((method & 0x1f) << 24) |       \
  65                                 ((in & 0xff) << 16) |           \
  66                                 ((out & 0xff) <<  8) |          \
  67                                 ((oin & 0x0f) <<  4) |          \
  68                                 (oout & 0x0f))
  69
  70 #define FASTRPC_SCALARS(method, in, out) \
  71                 FASTRPC_BUILD_SCALARS(0, method, in, out, 0, 0)
  72
  73 #define FASTRPC_CREATE_PROCESS_NARGS    6
  74 /* Remote Method id table */
  75 #define FASTRPC_RMID_INIT_ATTACH        0
  76 #define FASTRPC_RMID_INIT_RELEASE       1
  77 #define FASTRPC_RMID_INIT_MMAP          4
  78 #define FASTRPC_RMID_INIT_MUNMAP        5
  79 #define FASTRPC_RMID_INIT_CREATE        6
  80 #define FASTRPC_RMID_INIT_CREATE_ATTR   7
  81 #define FASTRPC_RMID_INIT_CREATE_STATIC 8
  82 #define FASTRPC_RMID_INIT_MEM_MAP      10
  83 #define FASTRPC_RMID_INIT_MEM_UNMAP    11
  84
  85 /* Protection Domain(PD) ids */
  86 #define AUDIO_PD        (0) /* also GUEST_OS PD? */
  87 #define USER_PD         (1)
  88 #define SENSORS_PD      (2)
  89
  90 #define miscdev_to_fdevice(d) container_of(d, struct fastrpc_device, miscdev)
  91
  92 static const char *domains[FASTRPC_DEV_MAX] = { "adsp", "mdsp",
  93                                                 "sdsp", "cdsp"};
  94 struct fastrpc_phy_page {
  95         u64 addr;               /* physical address */
  96         u64 size;               /* size of contiguous region */
  97 };
  98
  99 struct fastrpc_invoke_buf {
 100         u32 num;                /* number of contiguous regions */
 101         u32 pgidx;              /* index to start of contiguous region */
 102 };
 103
 104 struct fastrpc_remote_dmahandle {
 105         s32 fd;         /* dma handle fd */
 106         u32 offset;     /* dma handle offset */
 107         u32 len;        /* dma handle length */
 108 };
 109
 110 struct fastrpc_remote_buf {
 111         u64 pv;         /* buffer pointer */
 112         u64 len;        /* length of buffer */
 113 };
 114
 115 union fastrpc_remote_arg {
 116         struct fastrpc_remote_buf buf;
 117         struct fastrpc_remote_dmahandle dma;
 118 };
 119
 120 struct fastrpc_mmap_rsp_msg {
 121         u64 vaddr;
 122 };
 123
 124 struct fastrpc_mmap_req_msg {
 125         s32 pgid;
 126         u32 flags;
 127         u64 vaddr;
 128         s32 num;
 129 };
 130
 131 struct fastrpc_mem_map_req_msg {
 132         s32 pgid;
 133         s32 fd;
 134         s32 offset;
 135         u32 flags;
 136         u64 vaddrin;
 137         s32 num;
 138         s32 data_len;
 139 };
 140
 141 struct fastrpc_munmap_req_msg {
 142         s32 pgid;
 143         u64 vaddr;
 144         u64 size;
 145 };
 146
 147 struct fastrpc_mem_unmap_req_msg {
 148         s32 pgid;
 149         s32 fd;
 150         u64 vaddrin;
 151         u64 len;
 152 };
 153
 154 struct fastrpc_msg {
 155         int pid;                /* process group id */
 156         int tid;                /* thread id */
 157         u64 ctx;                /* invoke caller context */
 158         u32 handle;     /* handle to invoke */
 159         u32 sc;         /* scalars structure describing the data */
 160         u64 addr;               /* physical address */
 161         u64 size;               /* size of contiguous region */
 162 };
 163
 164 struct fastrpc_invoke_rsp {
 165         u64 ctx;                /* invoke caller context */
 166         int retval;             /* invoke return value */
 167 };
 168
 169 struct fastrpc_buf_overlap {
 170         u64 start;
 171         u64 end;
 172         int raix;
 173         u64 mstart;
 174         u64 mend;
 175         u64 offset;
 176 };
 177
 178 struct fastrpc_buf {
 179         struct fastrpc_user *fl;
 180         struct dma_buf *dmabuf;
 181         struct device *dev;
 182         void *virt;
 183         u64 phys;
 184         u64 size;
 185         /* Lock for dma buf attachments */
 186         struct mutex lock;
 187         struct list_head attachments;
 188         /* mmap support */
 189         struct list_head node; /* list of user requested mmaps */
 190         uintptr_t raddr;
 191 };
 192
 193 struct fastrpc_dma_buf_attachment {
 194         struct device *dev;
 195         struct sg_table sgt;
 196         struct list_head node;
 197 };
 198
 199 struct fastrpc_map {
 200         struct list_head node;
 201         struct fastrpc_user *fl;
 202         int fd;
 203         struct dma_buf *buf;
 204         struct sg_table *table;
 205         struct dma_buf_attachment *attach;
 206         u64 phys;
 207         u64 size;
 208         void *va;
 209         u64 len;
 210         u64 raddr;
 211         u32 attr;
 212         struct kref refcount;
 213 };
 214
 215 struct fastrpc_invoke_ctx {
 216         int nscalars;
 217         int nbufs;
 218         int retval;
 219         int pid;
 220         int tgid;
 221         u32 sc;
 222         u32 *crc;
 223         u64 ctxid;
 224         u64 msg_sz;
 225         struct kref refcount;
 226         struct list_head node; /* list of ctxs */
 227         struct completion work;
 228         struct work_struct put_work;
 229         struct fastrpc_msg msg;
 230         struct fastrpc_user *fl;
 231         union fastrpc_remote_arg *rpra;
 232         struct fastrpc_map **maps;
 233         struct fastrpc_buf *buf;
 234         struct fastrpc_invoke_args *args;
 235         struct fastrpc_buf_overlap *olaps;
 236         struct fastrpc_channel_ctx *cctx;
 237 };
 238
 239 struct fastrpc_session_ctx {
 240         struct device *dev;
 241         int sid;
 242         bool used;
 243         bool valid;
 244 };
 245
 246 struct fastrpc_channel_ctx {
 247         int domain_id;
 248         int sesscount;
 249         int vmcount;
 250         u32 perms;
 251         struct qcom_scm_vmperm vmperms[FASTRPC_MAX_VMIDS];
 252         struct rpmsg_device *rpdev;
 253         struct fastrpc_session_ctx session[FASTRPC_MAX_SESSIONS];
 254         spinlock_t lock;
 255         struct idr ctx_idr;
 256         struct list_head users;
 257         struct kref refcount;
 258         /* Flag if dsp attributes are cached */
 259         bool valid_attributes;
 260         u32 dsp_attributes[FASTRPC_MAX_DSP_ATTRIBUTES];
 261         struct fastrpc_device *secure_fdevice;
 262         struct fastrpc_device *fdevice;
 263         bool secure;
 264         bool unsigned_support;
 265 };
 266
 267 struct fastrpc_device {
 268         struct fastrpc_channel_ctx *cctx;
 269         struct miscdevice miscdev;
 270         bool secure;
 271 };
 272
 273 struct fastrpc_user {
 274         struct list_head user;
 275         struct list_head maps;
 276         struct list_head pending;
 277         struct list_head mmaps;
 278
 279         struct fastrpc_channel_ctx *cctx;
 280         struct fastrpc_session_ctx *sctx;
 281         struct fastrpc_buf *init_mem;
 282
 283         int tgid;
 284         int pd;
 285         bool is_secure_dev;
 286         /* Lock for lists */
 287         spinlock_t lock;
 288         /* lock for allocations */
 289         struct mutex mutex;
 290 };
 291
 292 static void fastrpc_free_map(struct kref *ref)
 293 {
 294         struct fastrpc_map *map;
 295
 296         map = container_of(ref, struct fastrpc_map, refcount);
 297
 298         if (map->table) {
 299                 if (map->attr & FASTRPC_ATTR_SECUREMAP) {
 300                         struct qcom_scm_vmperm perm;
 301                         int err = 0;
 302
 303                         perm.vmid = QCOM_SCM_VMID_HLOS;
 304                         perm.perm = QCOM_SCM_PERM_RWX;
 305                         err = qcom_scm_assign_mem(map->phys, map->size,
 306                                 &(map->fl->cctx->vmperms[0].vmid), &perm, 1);
 307                         if (err) {
 308                                 dev_err(map->fl->sctx->dev, "Failed to assign memory phys 0x%llx size 0x%llx err %d",
 309                                                 map->phys, map->size, err);
 310                                 return;
 311                         }
 312                 }
 313                 dma_buf_unmap_attachment(map->attach, map->table,
 314                                          DMA_BIDIRECTIONAL);
 315                 dma_buf_detach(map->buf, map->attach);
 316                 dma_buf_put(map->buf);
 317         }
 318
 319         kfree(map);
 320 }
 321
 322 static void fastrpc_map_put(struct fastrpc_map *map)
 323 {
 324         if (map)
 325                 kref_put(&map->refcount, fastrpc_free_map);
 326 }
 327
 328 static void fastrpc_map_get(struct fastrpc_map *map)
 329 {
 330         if (map)
 331                 kref_get(&map->refcount);
 332 }
 333
 334
 335 static int fastrpc_map_lookup(struct fastrpc_user *fl, int fd,
 336                             struct fastrpc_map **ppmap)
 337 {
 338         struct fastrpc_map *map = NULL;
 339
 340         mutex_lock(&fl->mutex);
 341         list_for_each_entry(map, &fl->maps, node) {
 342                 if (map->fd == fd) {
 343                         *ppmap = map;
 344                         mutex_unlock(&fl->mutex);
 345                         return 0;
 346                 }
 347         }
 348         mutex_unlock(&fl->mutex);
 349
 350         return -ENOENT;
 351 }
 352
 353 static int fastrpc_map_find(struct fastrpc_user *fl, int fd,
 354                             struct fastrpc_map **ppmap)
 355 {
 356         int ret = fastrpc_map_lookup(fl, fd, ppmap);
 357
 358         if (!ret)
 359                 fastrpc_map_get(*ppmap);
 360
 361         return ret;
 362 }
 363
 364 static void fastrpc_buf_free(struct fastrpc_buf *buf)
 365 {
 366         dma_free_coherent(buf->dev, buf->size, buf->virt,
 367                           FASTRPC_PHYS(buf->phys));
 368         kfree(buf);
 369 }
 370
 371 static int fastrpc_buf_alloc(struct fastrpc_user *fl, struct device *dev,
 372                              u64 size, struct fastrpc_buf **obuf)
 373 {
 374         struct fastrpc_buf *buf;
 375
 376         buf = kzalloc(sizeof(*buf), GFP_KERNEL);
 377         if (!buf)
 378                 return -ENOMEM;
 379
 380         INIT_LIST_HEAD(&buf->attachments);
 381         INIT_LIST_HEAD(&buf->node);
 382         mutex_init(&buf->lock);
 383
 384         buf->fl = fl;
 385         buf->virt = NULL;
 386         buf->phys = 0;
 387         buf->size = size;
 388         buf->dev = dev;
 389         buf->raddr = 0;
 390
 391         buf->virt = dma_alloc_coherent(dev, buf->size, (dma_addr_t *)&buf->phys,
 392                                        GFP_KERNEL);
 393         if (!buf->virt) {
 394                 mutex_destroy(&buf->lock);
 395                 kfree(buf);
 396                 return -ENOMEM;
 397         }
 398
 399         if (fl->sctx && fl->sctx->sid)
 400                 buf->phys += ((u64)fl->sctx->sid << 32);
 401
 402         *obuf = buf;
 403
 404         return 0;
 405 }
 406
 407 static void fastrpc_channel_ctx_free(struct kref *ref)
 408 {
 409         struct fastrpc_channel_ctx *cctx;
 410
 411         cctx = container_of(ref, struct fastrpc_channel_ctx, refcount);
 412
 413         kfree(cctx);
 414 }
 415
 416 static void fastrpc_channel_ctx_get(struct fastrpc_channel_ctx *cctx)
 417 {
 418         kref_get(&cctx->refcount);
 419 }
 420
 421 static void fastrpc_channel_ctx_put(struct fastrpc_channel_ctx *cctx)
 422 {
 423         kref_put(&cctx->refcount, fastrpc_channel_ctx_free);
 424 }
 425
 426 static void fastrpc_context_free(struct kref *ref)
 427 {
 428         struct fastrpc_invoke_ctx *ctx;
 429         struct fastrpc_channel_ctx *cctx;
 430         unsigned long flags;
 431         int i;
 432
 433         ctx = container_of(ref, struct fastrpc_invoke_ctx, refcount);
 434         cctx = ctx->cctx;
 435
 436         for (i = 0; i < ctx->nbufs; i++)
 437                 fastrpc_map_put(ctx->maps[i]);
 438
 439         if (ctx->buf)
 440                 fastrpc_buf_free(ctx->buf);
 441
 442         spin_lock_irqsave(&cctx->lock, flags);
 443         idr_remove(&cctx->ctx_idr, ctx->ctxid >> 4);
 444         spin_unlock_irqrestore(&cctx->lock, flags);
 445
 446         kfree(ctx->maps);
 447         kfree(ctx->olaps);
 448         kfree(ctx);
 449
 450         fastrpc_channel_ctx_put(cctx);
 451 }
 452
 453 static void fastrpc_context_get(struct fastrpc_invoke_ctx *ctx)
 454 {
 455         kref_get(&ctx->refcount);
 456 }
 457
 458 static void fastrpc_context_put(struct fastrpc_invoke_ctx *ctx)
 459 {
 460         kref_put(&ctx->refcount, fastrpc_context_free);
 461 }
 462
 463 static void fastrpc_context_put_wq(struct work_struct *work)
 464 {
 465         struct fastrpc_invoke_ctx *ctx =
 466                         container_of(work, struct fastrpc_invoke_ctx, put_work);
 467
 468         fastrpc_context_put(ctx);
 469 }
 470
 471 #define CMP(aa, bb) ((aa) == (bb) ? 0 : (aa) < (bb) ? -1 : 1)
 472 static int olaps_cmp(const void *a, const void *b)
 473 {
 474         struct fastrpc_buf_overlap *pa = (struct fastrpc_buf_overlap *)a;
 475         struct fastrpc_buf_overlap *pb = (struct fastrpc_buf_overlap *)b;
 476         /* sort with lowest starting buffer first */
 477         int st = CMP(pa->start, pb->start);
 478         /* sort with highest ending buffer first */
 479         int ed = CMP(pb->end, pa->end);
 480
 481         return st == 0 ? ed : st;
 482 }
 483
 484 static void fastrpc_get_buff_overlaps(struct fastrpc_invoke_ctx *ctx)
 485 {
 486         u64 max_end = 0;
 487         int i;
 488
 489         for (i = 0; i < ctx->nbufs; ++i) {
 490                 ctx->olaps[i].start = ctx->args[i].ptr;
 491                 ctx->olaps[i].end = ctx->olaps[i].start + ctx->args[i].length;
 492                 ctx->olaps[i].raix = i;
 493         }
 494
 495         sort(ctx->olaps, ctx->nbufs, sizeof(*ctx->olaps), olaps_cmp, NULL);
 496
 497         for (i = 0; i < ctx->nbufs; ++i) {
 498                 /* Falling inside previous range */
 499                 if (ctx->olaps[i].start < max_end) {
 500                         ctx->olaps[i].mstart = max_end;
 501                         ctx->olaps[i].mend = ctx->olaps[i].end;
 502                         ctx->olaps[i].offset = max_end - ctx->olaps[i].start;
 503
 504                         if (ctx->olaps[i].end > max_end) {
 505                                 max_end = ctx->olaps[i].end;
 506                         } else {
 507                                 ctx->olaps[i].mend = 0;
 508                                 ctx->olaps[i].mstart = 0;
 509                         }
 510
 511                 } else  {
 512                         ctx->olaps[i].mend = ctx->olaps[i].end;
 513                         ctx->olaps[i].mstart = ctx->olaps[i].start;
 514                         ctx->olaps[i].offset = 0;
 515                         max_end = ctx->olaps[i].end;
 516                 }
 517         }
 518 }
 519
 520 static struct fastrpc_invoke_ctx *fastrpc_context_alloc(
 521                         struct fastrpc_user *user, u32 kernel, u32 sc,
 522                         struct fastrpc_invoke_args *args)
 523 {
 524         struct fastrpc_channel_ctx *cctx = user->cctx;
 525         struct fastrpc_invoke_ctx *ctx = NULL;
 526         unsigned long flags;
 527         int ret;
 528
 529         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 530         if (!ctx)
 531                 return ERR_PTR(-ENOMEM);
 532
 533         INIT_LIST_HEAD(&ctx->node);
 534         ctx->fl = user;
 535         ctx->nscalars = REMOTE_SCALARS_LENGTH(sc);
 536         ctx->nbufs = REMOTE_SCALARS_INBUFS(sc) +
 537                      REMOTE_SCALARS_OUTBUFS(sc);
 538
 539         if (ctx->nscalars) {
 540                 ctx->maps = kcalloc(ctx->nscalars,
 541                                     sizeof(*ctx->maps), GFP_KERNEL);
 542                 if (!ctx->maps) {
 543                         kfree(ctx);
 544                         return ERR_PTR(-ENOMEM);
 545                 }
 546                 ctx->olaps = kcalloc(ctx->nscalars,
 547                                     sizeof(*ctx->olaps), GFP_KERNEL);
 548                 if (!ctx->olaps) {
 549                         kfree(ctx->maps);
 550                         kfree(ctx);
 551                         return ERR_PTR(-ENOMEM);
 552                 }
 553                 ctx->args = args;
 554                 fastrpc_get_buff_overlaps(ctx);
 555         }
 556
 557         /* Released in fastrpc_context_put() */
 558         fastrpc_channel_ctx_get(cctx);
 559
 560         ctx->sc = sc;
 561         ctx->retval = -1;
 562         ctx->pid = current->pid;
 563         ctx->tgid = user->tgid;
 564         ctx->cctx = cctx;
 565         init_completion(&ctx->work);
 566         INIT_WORK(&ctx->put_work, fastrpc_context_put_wq);
 567
 568         spin_lock(&user->lock);
 569         list_add_tail(&ctx->node, &user->pending);
 570         spin_unlock(&user->lock);
 571
 572         spin_lock_irqsave(&cctx->lock, flags);
 573         ret = idr_alloc_cyclic(&cctx->ctx_idr, ctx, 1,
 574                                FASTRPC_CTX_MAX, GFP_ATOMIC);
 575         if (ret < 0) {
 576                 spin_unlock_irqrestore(&cctx->lock, flags);
 577                 goto err_idr;
 578         }
 579         ctx->ctxid = ret << 4;
 580         spin_unlock_irqrestore(&cctx->lock, flags);
 581
 582         kref_init(&ctx->refcount);
 583
 584         return ctx;
 585 err_idr:
 586         spin_lock(&user->lock);
 587         list_del(&ctx->node);
 588         spin_unlock(&user->lock);
 589         fastrpc_channel_ctx_put(cctx);
 590         kfree(ctx->maps);
 591         kfree(ctx->olaps);
 592         kfree(ctx);
 593
 594         return ERR_PTR(ret);
 595 }
 596
 597 static struct sg_table *
 598 fastrpc_map_dma_buf(struct dma_buf_attachment *attachment,
 599                     enum dma_data_direction dir)
 600 {
 601         struct fastrpc_dma_buf_attachment *a = attachment->priv;
 602         struct sg_table *table;
 603         int ret;
 604
 605         table = &a->sgt;
 606
 607         ret = dma_map_sgtable(attachment->dev, table, dir, 0);
 608         if (ret)
 609                 table = ERR_PTR(ret);
 610         return table;
 611 }
 612
 613 static void fastrpc_unmap_dma_buf(struct dma_buf_attachment *attach,
 614                                   struct sg_table *table,
 615                                   enum dma_data_direction dir)
 616 {
 617         dma_unmap_sgtable(attach->dev, table, dir, 0);
 618 }
 619
 620 static void fastrpc_release(struct dma_buf *dmabuf)
 621 {
 622         struct fastrpc_buf *buffer = dmabuf->priv;
 623
 624         fastrpc_buf_free(buffer);
 625 }
 626
 627 static int fastrpc_dma_buf_attach(struct dma_buf *dmabuf,
 628                                   struct dma_buf_attachment *attachment)
 629 {
 630         struct fastrpc_dma_buf_attachment *a;
 631         struct fastrpc_buf *buffer = dmabuf->priv;
 632         int ret;
 633
 634         a = kzalloc(sizeof(*a), GFP_KERNEL);
 635         if (!a)
 636                 return -ENOMEM;
 637
 638         ret = dma_get_sgtable(buffer->dev, &a->sgt, buffer->virt,
 639                               FASTRPC_PHYS(buffer->phys), buffer->size);
 640         if (ret < 0) {
 641                 dev_err(buffer->dev, "failed to get scatterlist from DMA API\n");
 642                 kfree(a);
 643                 return -EINVAL;
 644         }
 645
 646         a->dev = attachment->dev;
 647         INIT_LIST_HEAD(&a->node);
 648         attachment->priv = a;
 649
 650         mutex_lock(&buffer->lock);
 651         list_add(&a->node, &buffer->attachments);
 652         mutex_unlock(&buffer->lock);
 653
 654         return 0;
 655 }
 656
 657 static void fastrpc_dma_buf_detatch(struct dma_buf *dmabuf,
 658                                     struct dma_buf_attachment *attachment)
 659 {
 660         struct fastrpc_dma_buf_attachment *a = attachment->priv;
 661         struct fastrpc_buf *buffer = dmabuf->priv;
 662
 663         mutex_lock(&buffer->lock);
 664         list_del(&a->node);
 665         mutex_unlock(&buffer->lock);
 666         sg_free_table(&a->sgt);
 667         kfree(a);
 668 }
 669
 670 static int fastrpc_vmap(struct dma_buf *dmabuf, struct iosys_map *map)
 671 {
 672         struct fastrpc_buf *buf = dmabuf->priv;
 673
 674         iosys_map_set_vaddr(map, buf->virt);
 675
 676         return 0;
 677 }
 678
 679 static int fastrpc_mmap(struct dma_buf *dmabuf,
 680                         struct vm_area_struct *vma)
 681 {
 682         struct fastrpc_buf *buf = dmabuf->priv;
 683         size_t size = vma->vm_end - vma->vm_start;
 684
 685         return dma_mmap_coherent(buf->dev, vma, buf->virt,
 686                                  FASTRPC_PHYS(buf->phys), size);
 687 }
 688
 689 static const struct dma_buf_ops fastrpc_dma_buf_ops = {
 690         .attach = fastrpc_dma_buf_attach,
 691         .detach = fastrpc_dma_buf_detatch,
 692         .map_dma_buf = fastrpc_map_dma_buf,
 693         .unmap_dma_buf = fastrpc_unmap_dma_buf,
 694         .mmap = fastrpc_mmap,
 695         .vmap = fastrpc_vmap,
 696         .release = fastrpc_release,
 697 };
 698
 699 static int fastrpc_map_create(struct fastrpc_user *fl, int fd,
 700                               u64 len, u32 attr, struct fastrpc_map **ppmap)
 701 {
 702         struct fastrpc_session_ctx *sess = fl->sctx;
 703         struct fastrpc_map *map = NULL;
 704         int err = 0;
 705
 706         if (!fastrpc_map_find(fl, fd, ppmap))
 707                 return 0;
 708
 709         map = kzalloc(sizeof(*map), GFP_KERNEL);
 710         if (!map)
 711                 return -ENOMEM;
 712
 713         INIT_LIST_HEAD(&map->node);
 714         map->fl = fl;
 715         map->fd = fd;
 716         map->buf = dma_buf_get(fd);
 717         if (IS_ERR(map->buf)) {
 718                 err = PTR_ERR(map->buf);
 719                 goto get_err;
 720         }
 721
 722         map->attach = dma_buf_attach(map->buf, sess->dev);
 723         if (IS_ERR(map->attach)) {
 724                 dev_err(sess->dev, "Failed to attach dmabuf\n");
 725                 err = PTR_ERR(map->attach);
 726                 goto attach_err;
 727         }
 728
 729         map->table = dma_buf_map_attachment(map->attach, DMA_BIDIRECTIONAL);
 730         if (IS_ERR(map->table)) {
 731                 err = PTR_ERR(map->table);
 732                 goto map_err;
 733         }
 734
 735         map->phys = sg_dma_address(map->table->sgl);
 736         map->phys += ((u64)fl->sctx->sid << 32);
 737         map->size = len;
 738         map->va = sg_virt(map->table->sgl);
 739         map->len = len;
 740         kref_init(&map->refcount);
 741
 742         if (attr & FASTRPC_ATTR_SECUREMAP) {
 743                 /*
 744                  * If subsystem VMIDs are defined in DTSI, then do
 745                  * hyp_assign from HLOS to those VM(s)
 746                  */
 747                 unsigned int perms = BIT(QCOM_SCM_VMID_HLOS);
 748
 749                 map->attr = attr;
 750                 err = qcom_scm_assign_mem(map->phys, (u64)map->size, &perms,
 751                                 fl->cctx->vmperms, fl->cctx->vmcount);
 752                 if (err) {
 753                         dev_err(sess->dev, "Failed to assign memory with phys 0x%llx size 0x%llx err %d",
 754                                         map->phys, map->size, err);
 755                         goto map_err;
 756                 }
 757         }
 758         spin_lock(&fl->lock);
 759         list_add_tail(&map->node, &fl->maps);
 760         spin_unlock(&fl->lock);
 761         *ppmap = map;
 762
 763         return 0;
 764
 765 map_err:
 766         dma_buf_detach(map->buf, map->attach);
 767 attach_err:
 768         dma_buf_put(map->buf);
 769 get_err:
 770         kfree(map);
 771
 772         return err;
 773 }
 774
 775 /*
 776  * Fastrpc payload buffer with metadata looks like:
 777  *
 778  * >>>>>>  START of METADATA <<<<<<<<<
 779  * +---------------------------------+
 780  * |           Arguments             |
 781  * | type:(union fastrpc_remote_arg)|
 782  * |             (0 - N)             |
 783  * +---------------------------------+
 784  * |         Invoke Buffer list      |
 785  * | type:(struct fastrpc_invoke_buf)|
 786  * |           (0 - N)               |
 787  * +---------------------------------+
 788  * |         Page info list          |
 789  * | type:(struct fastrpc_phy_page)  |
 790  * |             (0 - N)             |
 791  * +---------------------------------+
 792  * |         Optional info           |
 793  * |(can be specific to SoC/Firmware)|
 794  * +---------------------------------+
 795  * >>>>>>>>  END of METADATA <<<<<<<<<
 796  * +---------------------------------+
 797  * |         Inline ARGS             |
 798  * |            (0-N)                |
 799  * +---------------------------------+
 800  */
 801
 802 static int fastrpc_get_meta_size(struct fastrpc_invoke_ctx *ctx)
 803 {
 804         int size = 0;
 805
 806         size = (sizeof(struct fastrpc_remote_buf) +
 807                 sizeof(struct fastrpc_invoke_buf) +
 808                 sizeof(struct fastrpc_phy_page)) * ctx->nscalars +
 809                 sizeof(u64) * FASTRPC_MAX_FDLIST +
 810                 sizeof(u32) * FASTRPC_MAX_CRCLIST;
 811
 812         return size;
 813 }
 814
 815 static u64 fastrpc_get_payload_size(struct fastrpc_invoke_ctx *ctx, int metalen)
 816 {
 817         u64 size = 0;
 818         int oix;
 819
 820         size = ALIGN(metalen, FASTRPC_ALIGN);
 821         for (oix = 0; oix < ctx->nbufs; oix++) {
 822                 int i = ctx->olaps[oix].raix;
 823
 824                 if (ctx->args[i].fd == 0 || ctx->args[i].fd == -1) {
 825
 826                         if (ctx->olaps[oix].offset == 0)
 827                                 size = ALIGN(size, FASTRPC_ALIGN);
 828
 829                         size += (ctx->olaps[oix].mend - ctx->olaps[oix].mstart);
 830                 }
 831         }
 832
 833         return size;
 834 }
 835
 836 static int fastrpc_create_maps(struct fastrpc_invoke_ctx *ctx)
 837 {
 838         struct device *dev = ctx->fl->sctx->dev;
 839         int i, err;
 840
 841         for (i = 0; i < ctx->nscalars; ++i) {
 842
 843                 if (ctx->args[i].fd == 0 || ctx->args[i].fd == -1 ||
 844                     ctx->args[i].length == 0)
 845                         continue;
 846
 847                 err = fastrpc_map_create(ctx->fl, ctx->args[i].fd,
 848                          ctx->args[i].length, ctx->args[i].attr, &ctx->maps[i]);
 849                 if (err) {
 850                         dev_err(dev, "Error Creating map %d\n", err);
 851                         return -EINVAL;
 852                 }
 853
 854         }
 855         return 0;
 856 }
 857
 858 static struct fastrpc_invoke_buf *fastrpc_invoke_buf_start(union fastrpc_remote_arg *pra, int len)
 859 {
 860         return (struct fastrpc_invoke_buf *)(&pra[len]);
 861 }
 862
 863 static struct fastrpc_phy_page *fastrpc_phy_page_start(struct fastrpc_invoke_buf *buf, int len)
 864 {
 865         return (struct fastrpc_phy_page *)(&buf[len]);
 866 }
 867
 868 static int fastrpc_get_args(u32 kernel, struct fastrpc_invoke_ctx *ctx)
 869 {
 870         struct device *dev = ctx->fl->sctx->dev;
 871         union fastrpc_remote_arg *rpra;
 872         struct fastrpc_invoke_buf *list;
 873         struct fastrpc_phy_page *pages;
 874         int inbufs, i, oix, err = 0;
 875         u64 len, rlen, pkt_size;
 876         u64 pg_start, pg_end;
 877         uintptr_t args;
 878         int metalen;
 879
 880         inbufs = REMOTE_SCALARS_INBUFS(ctx->sc);
 881         metalen = fastrpc_get_meta_size(ctx);
 882         pkt_size = fastrpc_get_payload_size(ctx, metalen);
 883
 884         err = fastrpc_create_maps(ctx);
 885         if (err)
 886                 return err;
 887
 888         ctx->msg_sz = pkt_size;
 889
 890         err = fastrpc_buf_alloc(ctx->fl, dev, pkt_size, &ctx->buf);
 891         if (err)
 892                 return err;
 893
 894         rpra = ctx->buf->virt;
 895         list = fastrpc_invoke_buf_start(rpra, ctx->nscalars);
 896         pages = fastrpc_phy_page_start(list, ctx->nscalars);
 897         args = (uintptr_t)ctx->buf->virt + metalen;
 898         rlen = pkt_size - metalen;
 899         ctx->rpra = rpra;
 900
 901         for (oix = 0; oix < ctx->nbufs; ++oix) {
 902                 int mlen;
 903
 904                 i = ctx->olaps[oix].raix;
 905                 len = ctx->args[i].length;
 906
 907                 rpra[i].buf.pv = 0;
 908                 rpra[i].buf.len = len;
 909                 list[i].num = len ? 1 : 0;
 910                 list[i].pgidx = i;
 911
 912                 if (!len)
 913                         continue;
 914
 915                 if (ctx->maps[i]) {
 916                         struct vm_area_struct *vma = NULL;
 917
 918                         rpra[i].buf.pv = (u64) ctx->args[i].ptr;
 919                         pages[i].addr = ctx->maps[i]->phys;
 920
 921                         mmap_read_lock(current->mm);
 922                         vma = find_vma(current->mm, ctx->args[i].ptr);
 923                         if (vma)
 924                                 pages[i].addr += ctx->args[i].ptr -
 925                                                  vma->vm_start;
 926                         mmap_read_unlock(current->mm);
 927
 928                         pg_start = (ctx->args[i].ptr & PAGE_MASK) >> PAGE_SHIFT;
 929                         pg_end = ((ctx->args[i].ptr + len - 1) & PAGE_MASK) >>
 930                                   PAGE_SHIFT;
 931                         pages[i].size = (pg_end - pg_start + 1) * PAGE_SIZE;
 932
 933                 } else {
 934
 935                         if (ctx->olaps[oix].offset == 0) {
 936                                 rlen -= ALIGN(args, FASTRPC_ALIGN) - args;
 937                                 args = ALIGN(args, FASTRPC_ALIGN);
 938                         }
 939
 940                         mlen = ctx->olaps[oix].mend - ctx->olaps[oix].mstart;
 941
 942                         if (rlen < mlen)
 943                                 goto bail;
 944
 945                         rpra[i].buf.pv = args - ctx->olaps[oix].offset;
 946                         pages[i].addr = ctx->buf->phys -
 947                                         ctx->olaps[oix].offset +
 948                                         (pkt_size - rlen);
 949                         pages[i].addr = pages[i].addr & PAGE_MASK;
 950
 951                         pg_start = (args & PAGE_MASK) >> PAGE_SHIFT;
 952                         pg_end = ((args + len - 1) & PAGE_MASK) >> PAGE_SHIFT;
 953                         pages[i].size = (pg_end - pg_start + 1) * PAGE_SIZE;
 954                         args = args + mlen;
 955                         rlen -= mlen;
 956                 }
 957
 958                 if (i < inbufs && !ctx->maps[i]) {
 959                         void *dst = (void *)(uintptr_t)rpra[i].buf.pv;
 960                         void *src = (void *)(uintptr_t)ctx->args[i].ptr;
 961
 962                         if (!kernel) {
 963                                 if (copy_from_user(dst, (void __user *)src,
 964                                                    len)) {
 965                                         err = -EFAULT;
 966                                         goto bail;
 967                                 }
 968                         } else {
 969                                 memcpy(dst, src, len);
 970                         }
 971                 }
 972         }
 973
 974         for (i = ctx->nbufs; i < ctx->nscalars; ++i) {
 975                 list[i].num = ctx->args[i].length ? 1 : 0;
 976                 list[i].pgidx = i;
 977                 if (ctx->maps[i]) {
 978                         pages[i].addr = ctx->maps[i]->phys;
 979                         pages[i].size = ctx->maps[i]->size;
 980                 }
 981                 rpra[i].dma.fd = ctx->args[i].fd;
 982                 rpra[i].dma.len = ctx->args[i].length;
 983                 rpra[i].dma.offset = (u64) ctx->args[i].ptr;
 984         }
 985
 986 bail:
 987         if (err)
 988                 dev_err(dev, "Error: get invoke args failed:%d\n", err);
 989
 990         return err;
 991 }
 992
 993 static int fastrpc_put_args(struct fastrpc_invoke_ctx *ctx,
 994                             u32 kernel)
 995 {
 996         union fastrpc_remote_arg *rpra = ctx->rpra;
 997         struct fastrpc_user *fl = ctx->fl;
 998         struct fastrpc_map *mmap = NULL;
 999         struct fastrpc_invoke_buf *list;
1000         struct fastrpc_phy_page *pages;
1001         u64 *fdlist;
1002         int i, inbufs, outbufs, handles;
1003
1004         inbufs = REMOTE_SCALARS_INBUFS(ctx->sc);
1005         outbufs = REMOTE_SCALARS_OUTBUFS(ctx->sc);
1006         handles = REMOTE_SCALARS_INHANDLES(ctx->sc) + REMOTE_SCALARS_OUTHANDLES(ctx->sc);
1007         list = fastrpc_invoke_buf_start(rpra, ctx->nscalars);
1008         pages = fastrpc_phy_page_start(list, ctx->nscalars);
1009         fdlist = (uint64_t *)(pages + inbufs + outbufs + handles);
1010
1011         for (i = inbufs; i < ctx->nbufs; ++i) {
1012                 if (!ctx->maps[i]) {
1013                         void *src = (void *)(uintptr_t)rpra[i].buf.pv;
1014                         void *dst = (void *)(uintptr_t)ctx->args[i].ptr;
1015                         u64 len = rpra[i].buf.len;
1016
1017                         if (!kernel) {
1018                                 if (copy_to_user((void __user *)dst, src, len))
1019                                         return -EFAULT;
1020                         } else {
1021                                 memcpy(dst, src, len);
1022                         }
1023                 }
1024         }
1025
1026         for (i = 0; i < FASTRPC_MAX_FDLIST; i++) {
1027                 if (!fdlist[i])
1028                         break;
1029                 if (!fastrpc_map_lookup(fl, (int)fdlist[i], &mmap))
1030                         fastrpc_map_put(mmap);
1031         }
1032
1033         return 0;
1034 }
1035
1036 static int fastrpc_invoke_send(struct fastrpc_session_ctx *sctx,
1037                                struct fastrpc_invoke_ctx *ctx,
1038                                u32 kernel, uint32_t handle)
1039 {
1040         struct fastrpc_channel_ctx *cctx;
1041         struct fastrpc_user *fl = ctx->fl;
1042         struct fastrpc_msg *msg = &ctx->msg;
1043         int ret;
1044
1045         cctx = fl->cctx;
1046         msg->pid = fl->tgid;
1047         msg->tid = current->pid;
1048
1049         if (kernel)
1050                 msg->pid = 0;
1051
1052         msg->ctx = ctx->ctxid | fl->pd;
1053         msg->handle = handle;
1054         msg->sc = ctx->sc;
1055         msg->addr = ctx->buf ? ctx->buf->phys : 0;
1056         msg->size = roundup(ctx->msg_sz, PAGE_SIZE);
1057         fastrpc_context_get(ctx);
1058
1059         ret = rpmsg_send(cctx->rpdev->ept, (void *)msg, sizeof(*msg));
1060
1061         if (ret)
1062                 fastrpc_context_put(ctx);
1063
1064         return ret;
1065
1066 }
1067
1068 static int fastrpc_internal_invoke(struct fastrpc_user *fl,  u32 kernel,
1069                                    u32 handle, u32 sc,
1070                                    struct fastrpc_invoke_args *args)
1071 {
1072         struct fastrpc_invoke_ctx *ctx = NULL;
1073         int err = 0;
1074
1075         if (!fl->sctx)
1076                 return -EINVAL;
1077
1078         if (!fl->cctx->rpdev)
1079                 return -EPIPE;
1080
1081         if (handle == FASTRPC_INIT_HANDLE && !kernel) {
1082                 dev_warn_ratelimited(fl->sctx->dev, "user app trying to send a kernel RPC message (%d)\n",  handle);
1083                 return -EPERM;
1084         }
1085
1086         ctx = fastrpc_context_alloc(fl, kernel, sc, args);
1087         if (IS_ERR(ctx))
1088                 return PTR_ERR(ctx);
1089
1090         if (ctx->nscalars) {
1091                 err = fastrpc_get_args(kernel, ctx);
1092                 if (err)
1093                         goto bail;
1094         }
1095
1096         /* make sure that all CPU memory writes are seen by DSP */
1097         dma_wmb();
1098         /* Send invoke buffer to remote dsp */
1099         err = fastrpc_invoke_send(fl->sctx, ctx, kernel, handle);
1100         if (err)
1101                 goto bail;
1102
1103         if (kernel) {
1104                 if (!wait_for_completion_timeout(&ctx->work, 10 * HZ))
1105                         err = -ETIMEDOUT;
1106         } else {
1107                 err = wait_for_completion_interruptible(&ctx->work);
1108         }
1109
1110         if (err)
1111                 goto bail;
1112
1113         /* Check the response from remote dsp */
1114         err = ctx->retval;
1115         if (err)
1116                 goto bail;
1117
1118         if (ctx->nscalars) {
1119                 /* make sure that all memory writes by DSP are seen by CPU */
1120                 dma_rmb();
1121                 /* populate all the output buffers with results */
1122                 err = fastrpc_put_args(ctx, kernel);
1123                 if (err)
1124                         goto bail;
1125         }
1126
1127 bail:
1128         if (err != -ERESTARTSYS && err != -ETIMEDOUT) {
1129                 /* We are done with this compute context */
1130                 spin_lock(&fl->lock);
1131                 list_del(&ctx->node);
1132                 spin_unlock(&fl->lock);
1133                 fastrpc_context_put(ctx);
1134         }
1135         if (err)
1136                 dev_dbg(fl->sctx->dev, "Error: Invoke Failed %d\n", err);
1137
1138         return err;
1139 }
1140
1141 static bool is_session_rejected(struct fastrpc_user *fl, bool unsigned_pd_request)
1142 {
1143         /* Check if the device node is non-secure and channel is secure*/
1144         if (!fl->is_secure_dev && fl->cctx->secure) {
1145                 /*
1146                  * Allow untrusted applications to offload only to Unsigned PD when
1147                  * channel is configured as secure and block untrusted apps on channel
1148                  * that does not support unsigned PD offload
1149                  */
1150                 if (!fl->cctx->unsigned_support || !unsigned_pd_request) {
1151                         dev_err(&fl->cctx->rpdev->dev, "Error: Untrusted application trying to offload to signed PD");
1152                         return true;
1153                 }
1154         }
1155
1156         return false;
1157 }
1158
1159 static int fastrpc_init_create_process(struct fastrpc_user *fl,
1160                                         char __user *argp)
1161 {
1162         struct fastrpc_init_create init;
1163         struct fastrpc_invoke_args *args;
1164         struct fastrpc_phy_page pages[1];
1165         struct fastrpc_map *map = NULL;
1166         struct fastrpc_buf *imem = NULL;
1167         int memlen;
1168         int err;
1169         struct {
1170                 int pgid;
1171                 u32 namelen;
1172                 u32 filelen;
1173                 u32 pageslen;
1174                 u32 attrs;
1175                 u32 siglen;
1176         } inbuf;
1177         u32 sc;
1178         bool unsigned_module = false;
1179
1180         args = kcalloc(FASTRPC_CREATE_PROCESS_NARGS, sizeof(*args), GFP_KERNEL);
1181         if (!args)
1182                 return -ENOMEM;
1183
1184         if (copy_from_user(&init, argp, sizeof(init))) {
1185                 err = -EFAULT;
1186                 goto err;
1187         }
1188
1189         if (init.attrs & FASTRPC_MODE_UNSIGNED_MODULE)
1190                 unsigned_module = true;
1191
1192         if (is_session_rejected(fl, unsigned_module)) {
1193                 err = -ECONNREFUSED;
1194                 goto err;
1195         }
1196
1197         if (init.filelen > INIT_FILELEN_MAX) {
1198                 err = -EINVAL;
1199                 goto err;
1200         }
1201
1202         inbuf.pgid = fl->tgid;
1203         inbuf.namelen = strlen(current->comm) + 1;
1204         inbuf.filelen = init.filelen;
1205         inbuf.pageslen = 1;
1206         inbuf.attrs = init.attrs;
1207         inbuf.siglen = init.siglen;
1208         fl->pd = USER_PD;
1209
1210         if (init.filelen && init.filefd) {
1211                 err = fastrpc_map_create(fl, init.filefd, init.filelen, 0, &map);
1212                 if (err)
1213                         goto err;
1214         }
1215
1216         memlen = ALIGN(max(INIT_FILELEN_MAX, (int)init.filelen * 4),
1217                        1024 * 1024);
1218         err = fastrpc_buf_alloc(fl, fl->sctx->dev, memlen,
1219                                 &imem);
1220         if (err)
1221                 goto err_alloc;
1222
1223         fl->init_mem = imem;
1224         args[0].ptr = (u64)(uintptr_t)&inbuf;
1225         args[0].length = sizeof(inbuf);
1226         args[0].fd = -1;
1227
1228         args[1].ptr = (u64)(uintptr_t)current->comm;
1229         args[1].length = inbuf.namelen;
1230         args[1].fd = -1;
1231
1232         args[2].ptr = (u64) init.file;
1233         args[2].length = inbuf.filelen;
1234         args[2].fd = init.filefd;
1235
1236         pages[0].addr = imem->phys;
1237         pages[0].size = imem->size;
1238
1239         args[3].ptr = (u64)(uintptr_t) pages;
1240         args[3].length = 1 * sizeof(*pages);
1241         args[3].fd = -1;
1242
1243         args[4].ptr = (u64)(uintptr_t)&inbuf.attrs;
1244         args[4].length = sizeof(inbuf.attrs);
1245         args[4].fd = -1;
1246
1247         args[5].ptr = (u64)(uintptr_t) &inbuf.siglen;
1248         args[5].length = sizeof(inbuf.siglen);
1249         args[5].fd = -1;
1250
1251         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_CREATE, 4, 0);
1252         if (init.attrs)
1253                 sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_CREATE_ATTR, 6, 0);
1254
1255         err = fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE,
1256                                       sc, args);
1257         if (err)
1258                 goto err_invoke;
1259
1260         kfree(args);
1261
1262         return 0;
1263
1264 err_invoke:
1265         fl->init_mem = NULL;
1266         fastrpc_buf_free(imem);
1267 err_alloc:
1268         if (map) {
1269                 spin_lock(&fl->lock);
1270                 list_del(&map->node);
1271                 spin_unlock(&fl->lock);
1272                 fastrpc_map_put(map);
1273         }
1274 err:
1275         kfree(args);
1276
1277         return err;
1278 }
1279
1280 static struct fastrpc_session_ctx *fastrpc_session_alloc(
1281                                         struct fastrpc_channel_ctx *cctx)
1282 {
1283         struct fastrpc_session_ctx *session = NULL;
1284         unsigned long flags;
1285         int i;
1286
1287         spin_lock_irqsave(&cctx->lock, flags);
1288         for (i = 0; i < cctx->sesscount; i++) {
1289                 if (!cctx->session[i].used && cctx->session[i].valid) {
1290                         cctx->session[i].used = true;
1291                         session = &cctx->session[i];
1292                         break;
1293                 }
1294         }
1295         spin_unlock_irqrestore(&cctx->lock, flags);
1296
1297         return session;
1298 }
1299
1300 static void fastrpc_session_free(struct fastrpc_channel_ctx *cctx,
1301                                  struct fastrpc_session_ctx *session)
1302 {
1303         unsigned long flags;
1304
1305         spin_lock_irqsave(&cctx->lock, flags);
1306         session->used = false;
1307         spin_unlock_irqrestore(&cctx->lock, flags);
1308 }
1309
1310 static int fastrpc_release_current_dsp_process(struct fastrpc_user *fl)
1311 {
1312         struct fastrpc_invoke_args args[1];
1313         int tgid = 0;
1314         u32 sc;
1315
1316         tgid = fl->tgid;
1317         args[0].ptr = (u64)(uintptr_t) &tgid;
1318         args[0].length = sizeof(tgid);
1319         args[0].fd = -1;
1320         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_RELEASE, 1, 0);
1321
1322         return fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE,
1323                                        sc, &args[0]);
1324 }
1325
1326 static int fastrpc_device_release(struct inode *inode, struct file *file)
1327 {
1328         struct fastrpc_user *fl = (struct fastrpc_user *)file->private_data;
1329         struct fastrpc_channel_ctx *cctx = fl->cctx;
1330         struct fastrpc_invoke_ctx *ctx, *n;
1331         struct fastrpc_map *map, *m;
1332         struct fastrpc_buf *buf, *b;
1333         unsigned long flags;
1334
1335         fastrpc_release_current_dsp_process(fl);
1336
1337         spin_lock_irqsave(&cctx->lock, flags);
1338         list_del(&fl->user);
1339         spin_unlock_irqrestore(&cctx->lock, flags);
1340
1341         if (fl->init_mem)
1342                 fastrpc_buf_free(fl->init_mem);
1343
1344         list_for_each_entry_safe(ctx, n, &fl->pending, node) {
1345                 list_del(&ctx->node);
1346                 fastrpc_context_put(ctx);
1347         }
1348
1349         list_for_each_entry_safe(map, m, &fl->maps, node) {
1350                 list_del(&map->node);
1351                 fastrpc_map_put(map);
1352         }
1353
1354         list_for_each_entry_safe(buf, b, &fl->mmaps, node) {
1355                 list_del(&buf->node);
1356                 fastrpc_buf_free(buf);
1357         }
1358
1359         fastrpc_session_free(cctx, fl->sctx);
1360         fastrpc_channel_ctx_put(cctx);
1361
1362         mutex_destroy(&fl->mutex);
1363         kfree(fl);
1364         file->private_data = NULL;
1365
1366         return 0;
1367 }
1368
1369 static int fastrpc_device_open(struct inode *inode, struct file *filp)
1370 {
1371         struct fastrpc_channel_ctx *cctx;
1372         struct fastrpc_device *fdevice;
1373         struct fastrpc_user *fl = NULL;
1374         unsigned long flags;
1375
1376         fdevice = miscdev_to_fdevice(filp->private_data);
1377         cctx = fdevice->cctx;
1378
1379         fl = kzalloc(sizeof(*fl), GFP_KERNEL);
1380         if (!fl)
1381                 return -ENOMEM;
1382
1383         /* Released in fastrpc_device_release() */
1384         fastrpc_channel_ctx_get(cctx);
1385
1386         filp->private_data = fl;
1387         spin_lock_init(&fl->lock);
1388         mutex_init(&fl->mutex);
1389         INIT_LIST_HEAD(&fl->pending);
1390         INIT_LIST_HEAD(&fl->maps);
1391         INIT_LIST_HEAD(&fl->mmaps);
1392         INIT_LIST_HEAD(&fl->user);
1393         fl->tgid = current->tgid;
1394         fl->cctx = cctx;
1395         fl->is_secure_dev = fdevice->secure;
1396
1397         fl->sctx = fastrpc_session_alloc(cctx);
1398         if (!fl->sctx) {
1399                 dev_err(&cctx->rpdev->dev, "No session available\n");
1400                 mutex_destroy(&fl->mutex);
1401                 kfree(fl);
1402
1403                 return -EBUSY;
1404         }
1405
1406         spin_lock_irqsave(&cctx->lock, flags);
1407         list_add_tail(&fl->user, &cctx->users);
1408         spin_unlock_irqrestore(&cctx->lock, flags);
1409
1410         return 0;
1411 }
1412
1413 static int fastrpc_dmabuf_alloc(struct fastrpc_user *fl, char __user *argp)
1414 {
1415         struct fastrpc_alloc_dma_buf bp;
1416         DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
1417         struct fastrpc_buf *buf = NULL;
1418         int err;
1419
1420         if (copy_from_user(&bp, argp, sizeof(bp)))
1421                 return -EFAULT;
1422
1423         err = fastrpc_buf_alloc(fl, fl->sctx->dev, bp.size, &buf);
1424         if (err)
1425                 return err;
1426         exp_info.ops = &fastrpc_dma_buf_ops;
1427         exp_info.size = bp.size;
1428         exp_info.flags = O_RDWR;
1429         exp_info.priv = buf;
1430         buf->dmabuf = dma_buf_export(&exp_info);
1431         if (IS_ERR(buf->dmabuf)) {
1432                 err = PTR_ERR(buf->dmabuf);
1433                 fastrpc_buf_free(buf);
1434                 return err;
1435         }
1436
1437         bp.fd = dma_buf_fd(buf->dmabuf, O_ACCMODE);
1438         if (bp.fd < 0) {
1439                 dma_buf_put(buf->dmabuf);
1440                 return -EINVAL;
1441         }
1442
1443         if (copy_to_user(argp, &bp, sizeof(bp))) {
1444                 /*
1445                  * The usercopy failed, but we can't do much about it, as
1446                  * dma_buf_fd() already called fd_install() and made the
1447                  * file descriptor accessible for the current process. It
1448                  * might already be closed and dmabuf no longer valid when
1449                  * we reach this point. Therefore "leak" the fd and rely on
1450                  * the process exit path to do any required cleanup.
1451                  */
1452                 return -EFAULT;
1453         }
1454
1455         return 0;
1456 }
1457
1458 static int fastrpc_init_attach(struct fastrpc_user *fl, int pd)
1459 {
1460         struct fastrpc_invoke_args args[1];
1461         int tgid = fl->tgid;
1462         u32 sc;
1463
1464         args[0].ptr = (u64)(uintptr_t) &tgid;
1465         args[0].length = sizeof(tgid);
1466         args[0].fd = -1;
1467         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_ATTACH, 1, 0);
1468         fl->pd = pd;
1469
1470         return fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE,
1471                                        sc, &args[0]);
1472 }
1473
1474 static int fastrpc_invoke(struct fastrpc_user *fl, char __user *argp)
1475 {
1476         struct fastrpc_invoke_args *args = NULL;
1477         struct fastrpc_invoke inv;
1478         u32 nscalars;
1479         int err;
1480
1481         if (copy_from_user(&inv, argp, sizeof(inv)))
1482                 return -EFAULT;
1483
1484         /* nscalars is truncated here to max supported value */
1485         nscalars = REMOTE_SCALARS_LENGTH(inv.sc);
1486         if (nscalars) {
1487                 args = kcalloc(nscalars, sizeof(*args), GFP_KERNEL);
1488                 if (!args)
1489                         return -ENOMEM;
1490
1491                 if (copy_from_user(args, (void __user *)(uintptr_t)inv.args,
1492                                    nscalars * sizeof(*args))) {
1493                         kfree(args);
1494                         return -EFAULT;
1495                 }
1496         }
1497
1498         err = fastrpc_internal_invoke(fl, false, inv.handle, inv.sc, args);
1499         kfree(args);
1500
1501         return err;
1502 }
1503
1504 static int fastrpc_get_info_from_dsp(struct fastrpc_user *fl, uint32_t *dsp_attr_buf,
1505                                      uint32_t dsp_attr_buf_len)
1506 {
1507         struct fastrpc_invoke_args args[2] = { 0 };
1508
1509         /* Capability filled in userspace */
1510         dsp_attr_buf[0] = 0;
1511
1512         args[0].ptr = (u64)(uintptr_t)&dsp_attr_buf_len;
1513         args[0].length = sizeof(dsp_attr_buf_len);
1514         args[0].fd = -1;
1515         args[1].ptr = (u64)(uintptr_t)&dsp_attr_buf[1];
1516         args[1].length = dsp_attr_buf_len;
1517         args[1].fd = -1;
1518         fl->pd = 1;
1519
1520         return fastrpc_internal_invoke(fl, true, FASTRPC_DSP_UTILITIES_HANDLE,
1521                                        FASTRPC_SCALARS(0, 1, 1), args);
1522 }
1523
1524 static int fastrpc_get_info_from_kernel(struct fastrpc_ioctl_capability *cap,
1525                                         struct fastrpc_user *fl)
1526 {
1527         struct fastrpc_channel_ctx *cctx = fl->cctx;
1528         uint32_t attribute_id = cap->attribute_id;
1529         uint32_t *dsp_attributes;
1530         unsigned long flags;
1531         uint32_t domain = cap->domain;
1532         int err;
1533
1534         spin_lock_irqsave(&cctx->lock, flags);
1535         /* check if we already have queried dsp for attributes */
1536         if (cctx->valid_attributes) {
1537                 spin_unlock_irqrestore(&cctx->lock, flags);
1538                 goto done;
1539         }
1540         spin_unlock_irqrestore(&cctx->lock, flags);
1541
1542         dsp_attributes = kzalloc(FASTRPC_MAX_DSP_ATTRIBUTES_LEN, GFP_KERNEL);
1543         if (!dsp_attributes)
1544                 return -ENOMEM;
1545
1546         err = fastrpc_get_info_from_dsp(fl, dsp_attributes, FASTRPC_MAX_DSP_ATTRIBUTES_LEN);
1547         if (err == DSP_UNSUPPORTED_API) {
1548                 dev_info(&cctx->rpdev->dev,
1549                          "Warning: DSP capabilities not supported on domain: %d\n", domain);
1550                 kfree(dsp_attributes);
1551                 return -EOPNOTSUPP;
1552         } else if (err) {
1553                 dev_err(&cctx->rpdev->dev, "Error: dsp information is incorrect err: %d\n", err);
1554                 kfree(dsp_attributes);
1555                 return err;
1556         }
1557
1558         spin_lock_irqsave(&cctx->lock, flags);
1559         memcpy(cctx->dsp_attributes, dsp_attributes, FASTRPC_MAX_DSP_ATTRIBUTES_LEN);
1560         cctx->valid_attributes = true;
1561         spin_unlock_irqrestore(&cctx->lock, flags);
1562         kfree(dsp_attributes);
1563 done:
1564         cap->capability = cctx->dsp_attributes[attribute_id];
1565         return 0;
1566 }
1567
1568 static int fastrpc_get_dsp_info(struct fastrpc_user *fl, char __user *argp)
1569 {
1570         struct fastrpc_ioctl_capability cap = {0};
1571         int err = 0;
1572
1573         if (copy_from_user(&cap, argp, sizeof(cap)))
1574                 return  -EFAULT;
1575
1576         cap.capability = 0;
1577         if (cap.domain >= FASTRPC_DEV_MAX) {
1578                 dev_err(&fl->cctx->rpdev->dev, "Error: Invalid domain id:%d, err:%d\n",
1579                         cap.domain, err);
1580                 return -ECHRNG;
1581         }
1582
1583         /* Fastrpc Capablities does not support modem domain */
1584         if (cap.domain == MDSP_DOMAIN_ID) {
1585                 dev_err(&fl->cctx->rpdev->dev, "Error: modem not supported %d\n", err);
1586                 return -ECHRNG;
1587         }
1588
1589         if (cap.attribute_id >= FASTRPC_MAX_DSP_ATTRIBUTES) {
1590                 dev_err(&fl->cctx->rpdev->dev, "Error: invalid attribute: %d, err: %d\n",
1591                         cap.attribute_id, err);
1592                 return -EOVERFLOW;
1593         }
1594
1595         err = fastrpc_get_info_from_kernel(&cap, fl);
1596         if (err)
1597                 return err;
1598
1599         if (copy_to_user(argp, &cap.capability, sizeof(cap.capability)))
1600                 return -EFAULT;
1601
1602         return 0;
1603 }
1604
1605 static int fastrpc_req_munmap_impl(struct fastrpc_user *fl,
1606                                    struct fastrpc_req_munmap *req)
1607 {
1608         struct fastrpc_invoke_args args[1] = { [0] = { 0 } };
1609         struct fastrpc_buf *buf = NULL, *iter, *b;
1610         struct fastrpc_munmap_req_msg req_msg;
1611         struct device *dev = fl->sctx->dev;
1612         int err;
1613         u32 sc;
1614
1615         spin_lock(&fl->lock);
1616         list_for_each_entry_safe(iter, b, &fl->mmaps, node) {
1617                 if ((iter->raddr == req->vaddrout) && (iter->size == req->size)) {
1618                         buf = iter;
1619                         break;
1620                 }
1621         }
1622         spin_unlock(&fl->lock);
1623
1624         if (!buf) {
1625                 dev_err(dev, "mmap not in list\n");
1626                 return -EINVAL;
1627         }
1628
1629         req_msg.pgid = fl->tgid;
1630         req_msg.size = buf->size;
1631         req_msg.vaddr = buf->raddr;
1632
1633         args[0].ptr = (u64) (uintptr_t) &req_msg;
1634         args[0].length = sizeof(req_msg);
1635
1636         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_MUNMAP, 1, 0);
1637         err = fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE, sc,
1638                                       &args[0]);
1639         if (!err) {
1640                 dev_dbg(dev, "unmmap\tpt 0x%09lx OK\n", buf->raddr);
1641                 spin_lock(&fl->lock);
1642                 list_del(&buf->node);
1643                 spin_unlock(&fl->lock);
1644                 fastrpc_buf_free(buf);
1645         } else {
1646                 dev_err(dev, "unmmap\tpt 0x%09lx ERROR\n", buf->raddr);
1647         }
1648
1649         return err;
1650 }
1651
1652 static int fastrpc_req_munmap(struct fastrpc_user *fl, char __user *argp)
1653 {
1654         struct fastrpc_req_munmap req;
1655
1656         if (copy_from_user(&req, argp, sizeof(req)))
1657                 return -EFAULT;
1658
1659         return fastrpc_req_munmap_impl(fl, &req);
1660 }
1661
1662 static int fastrpc_req_mmap(struct fastrpc_user *fl, char __user *argp)
1663 {
1664         struct fastrpc_invoke_args args[3] = { [0 ... 2] = { 0 } };
1665         struct fastrpc_buf *buf = NULL;
1666         struct fastrpc_mmap_req_msg req_msg;
1667         struct fastrpc_mmap_rsp_msg rsp_msg;
1668         struct fastrpc_req_munmap req_unmap;
1669         struct fastrpc_phy_page pages;
1670         struct fastrpc_req_mmap req;
1671         struct device *dev = fl->sctx->dev;
1672         int err;
1673         u32 sc;
1674
1675         if (copy_from_user(&req, argp, sizeof(req)))
1676                 return -EFAULT;
1677
1678         if (req.flags != ADSP_MMAP_ADD_PAGES) {
1679                 dev_err(dev, "flag not supported 0x%x\n", req.flags);
1680                 return -EINVAL;
1681         }
1682
1683         if (req.vaddrin) {
1684                 dev_err(dev, "adding user allocated pages is not supported\n");
1685                 return -EINVAL;
1686         }
1687
1688         err = fastrpc_buf_alloc(fl, fl->sctx->dev, req.size, &buf);
1689         if (err) {
1690                 dev_err(dev, "failed to allocate buffer\n");
1691                 return err;
1692         }
1693
1694         req_msg.pgid = fl->tgid;
1695         req_msg.flags = req.flags;
1696         req_msg.vaddr = req.vaddrin;
1697         req_msg.num = sizeof(pages);
1698
1699         args[0].ptr = (u64) (uintptr_t) &req_msg;
1700         args[0].length = sizeof(req_msg);
1701
1702         pages.addr = buf->phys;
1703         pages.size = buf->size;
1704
1705         args[1].ptr = (u64) (uintptr_t) &pages;
1706         args[1].length = sizeof(pages);
1707
1708         args[2].ptr = (u64) (uintptr_t) &rsp_msg;
1709         args[2].length = sizeof(rsp_msg);
1710
1711         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_MMAP, 2, 1);
1712         err = fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE, sc,
1713                                       &args[0]);
1714         if (err) {
1715                 dev_err(dev, "mmap error (len 0x%08llx)\n", buf->size);
1716                 goto err_invoke;
1717         }
1718
1719         /* update the buffer to be able to deallocate the memory on the DSP */
1720         buf->raddr = (uintptr_t) rsp_msg.vaddr;
1721
1722         /* let the client know the address to use */
1723         req.vaddrout = rsp_msg.vaddr;
1724
1725         spin_lock(&fl->lock);
1726         list_add_tail(&buf->node, &fl->mmaps);
1727         spin_unlock(&fl->lock);
1728
1729         if (copy_to_user((void __user *)argp, &req, sizeof(req))) {
1730                 /* unmap the memory and release the buffer */
1731                 req_unmap.vaddrout = buf->raddr;
1732                 req_unmap.size = buf->size;
1733                 fastrpc_req_munmap_impl(fl, &req_unmap);
1734                 return -EFAULT;
1735         }
1736
1737         dev_dbg(dev, "mmap\t\tpt 0x%09lx OK [len 0x%08llx]\n",
1738                 buf->raddr, buf->size);
1739
1740         return 0;
1741
1742 err_invoke:
1743         fastrpc_buf_free(buf);
1744
1745         return err;
1746 }
1747
1748 static int fastrpc_req_mem_unmap_impl(struct fastrpc_user *fl, struct fastrpc_mem_unmap *req)
1749 {
1750         struct fastrpc_invoke_args args[1] = { [0] = { 0 } };
1751         struct fastrpc_map *map = NULL, *iter, *m;
1752         struct fastrpc_mem_unmap_req_msg req_msg = { 0 };
1753         int err = 0;
1754         u32 sc;
1755         struct device *dev = fl->sctx->dev;
1756
1757         spin_lock(&fl->lock);
1758         list_for_each_entry_safe(iter, m, &fl->maps, node) {
1759                 if ((req->fd < 0 || iter->fd == req->fd) && (iter->raddr == req->vaddr)) {
1760                         map = iter;
1761                         break;
1762                 }
1763         }
1764
1765         spin_unlock(&fl->lock);
1766
1767         if (!map) {
1768                 dev_err(dev, "map not in list\n");
1769                 return -EINVAL;
1770         }
1771
1772         req_msg.pgid = fl->tgid;
1773         req_msg.len = map->len;
1774         req_msg.vaddrin = map->raddr;
1775         req_msg.fd = map->fd;
1776
1777         args[0].ptr = (u64) (uintptr_t) &req_msg;
1778         args[0].length = sizeof(req_msg);
1779
1780         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_MEM_UNMAP, 1, 0);
1781         err = fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE, sc,
1782                                       &args[0]);
1783         fastrpc_map_put(map);
1784         if (err)
1785                 dev_err(dev, "unmmap\tpt fd = %d, 0x%09llx error\n",  map->fd, map->raddr);
1786
1787         return err;
1788 }
1789
1790 static int fastrpc_req_mem_unmap(struct fastrpc_user *fl, char __user *argp)
1791 {
1792         struct fastrpc_mem_unmap req;
1793
1794         if (copy_from_user(&req, argp, sizeof(req)))
1795                 return -EFAULT;
1796
1797         return fastrpc_req_mem_unmap_impl(fl, &req);
1798 }
1799
1800 static int fastrpc_req_mem_map(struct fastrpc_user *fl, char __user *argp)
1801 {
1802         struct fastrpc_invoke_args args[4] = { [0 ... 3] = { 0 } };
1803         struct fastrpc_mem_map_req_msg req_msg = { 0 };
1804         struct fastrpc_mmap_rsp_msg rsp_msg = { 0 };
1805         struct fastrpc_mem_unmap req_unmap = { 0 };
1806         struct fastrpc_phy_page pages = { 0 };
1807         struct fastrpc_mem_map req;
1808         struct device *dev = fl->sctx->dev;
1809         struct fastrpc_map *map = NULL;
1810         int err;
1811         u32 sc;
1812
1813         if (copy_from_user(&req, argp, sizeof(req)))
1814                 return -EFAULT;
1815
1816         /* create SMMU mapping */
1817         err = fastrpc_map_create(fl, req.fd, req.length, 0, &map);
1818         if (err) {
1819                 dev_err(dev, "failed to map buffer, fd = %d\n", req.fd);
1820                 return err;
1821         }
1822
1823         req_msg.pgid = fl->tgid;
1824         req_msg.fd = req.fd;
1825         req_msg.offset = req.offset;
1826         req_msg.vaddrin = req.vaddrin;
1827         map->va = (void *) (uintptr_t) req.vaddrin;
1828         req_msg.flags = req.flags;
1829         req_msg.num = sizeof(pages);
1830         req_msg.data_len = 0;
1831
1832         args[0].ptr = (u64) (uintptr_t) &req_msg;
1833         args[0].length = sizeof(req_msg);
1834
1835         pages.addr = map->phys;
1836         pages.size = map->size;
1837
1838         args[1].ptr = (u64) (uintptr_t) &pages;
1839         args[1].length = sizeof(pages);
1840
1841         args[2].ptr = (u64) (uintptr_t) &pages;
1842         args[2].length = 0;
1843
1844         args[3].ptr = (u64) (uintptr_t) &rsp_msg;
1845         args[3].length = sizeof(rsp_msg);
1846
1847         sc = FASTRPC_SCALARS(FASTRPC_RMID_INIT_MEM_MAP, 3, 1);
1848         err = fastrpc_internal_invoke(fl, true, FASTRPC_INIT_HANDLE, sc, &args[0]);
1849         if (err) {
1850                 dev_err(dev, "mem mmap error, fd %d, vaddr %llx, size %lld\n",
1851                         req.fd, req.vaddrin, map->size);
1852                 goto err_invoke;
1853         }
1854
1855         /* update the buffer to be able to deallocate the memory on the DSP */
1856         map->raddr = rsp_msg.vaddr;
1857
1858         /* let the client know the address to use */
1859         req.vaddrout = rsp_msg.vaddr;
1860
1861         if (copy_to_user((void __user *)argp, &req, sizeof(req))) {
1862                 /* unmap the memory and release the buffer */
1863                 req_unmap.vaddr = (uintptr_t) rsp_msg.vaddr;
1864                 req_unmap.length = map->size;
1865                 fastrpc_req_mem_unmap_impl(fl, &req_unmap);
1866                 return -EFAULT;
1867         }
1868
1869         return 0;
1870
1871 err_invoke:
1872         fastrpc_map_put(map);
1873
1874         return err;
1875 }
1876
1877 static long fastrpc_device_ioctl(struct file *file, unsigned int cmd,
1878                                  unsigned long arg)
1879 {
1880         struct fastrpc_user *fl = (struct fastrpc_user *)file->private_data;
1881         char __user *argp = (char __user *)arg;
1882         int err;
1883
1884         switch (cmd) {
1885         case FASTRPC_IOCTL_INVOKE:
1886                 err = fastrpc_invoke(fl, argp);
1887                 break;
1888         case FASTRPC_IOCTL_INIT_ATTACH:
1889                 err = fastrpc_init_attach(fl, AUDIO_PD);
1890                 break;
1891         case FASTRPC_IOCTL_INIT_ATTACH_SNS:
1892                 err = fastrpc_init_attach(fl, SENSORS_PD);
1893                 break;
1894         case FASTRPC_IOCTL_INIT_CREATE:
1895                 err = fastrpc_init_create_process(fl, argp);
1896                 break;
1897         case FASTRPC_IOCTL_ALLOC_DMA_BUFF:
1898                 err = fastrpc_dmabuf_alloc(fl, argp);
1899                 break;
1900         case FASTRPC_IOCTL_MMAP:
1901                 err = fastrpc_req_mmap(fl, argp);
1902                 break;
1903         case FASTRPC_IOCTL_MUNMAP:
1904                 err = fastrpc_req_munmap(fl, argp);
1905                 break;
1906         case FASTRPC_IOCTL_MEM_MAP:
1907                 err = fastrpc_req_mem_map(fl, argp);
1908                 break;
1909         case FASTRPC_IOCTL_MEM_UNMAP:
1910                 err = fastrpc_req_mem_unmap(fl, argp);
1911                 break;
1912         case FASTRPC_IOCTL_GET_DSP_INFO:
1913                 err = fastrpc_get_dsp_info(fl, argp);
1914                 break;
1915         default:
1916                 err = -ENOTTY;
1917                 break;
1918         }
1919
1920         return err;
1921 }
1922
1923 static const struct file_operations fastrpc_fops = {
1924         .open = fastrpc_device_open,
1925         .release = fastrpc_device_release,
1926         .unlocked_ioctl = fastrpc_device_ioctl,
1927         .compat_ioctl = fastrpc_device_ioctl,
1928 };
1929
1930 static int fastrpc_cb_probe(struct platform_device *pdev)
1931 {
1932         struct fastrpc_channel_ctx *cctx;
1933         struct fastrpc_session_ctx *sess;
1934         struct device *dev = &pdev->dev;
1935         int i, sessions = 0;
1936         unsigned long flags;
1937         int rc;
1938
1939         cctx = dev_get_drvdata(dev->parent);
1940         if (!cctx)
1941                 return -EINVAL;
1942
1943         of_property_read_u32(dev->of_node, "qcom,nsessions", &sessions);
1944
1945         spin_lock_irqsave(&cctx->lock, flags);
1946         sess = &cctx->session[cctx->sesscount];
1947         sess->used = false;
1948         sess->valid = true;
1949         sess->dev = dev;
1950         dev_set_drvdata(dev, sess);
1951
1952         if (of_property_read_u32(dev->of_node, "reg", &sess->sid))
1953                 dev_info(dev, "FastRPC Session ID not specified in DT\n");
1954
1955         if (sessions > 0) {
1956                 struct fastrpc_session_ctx *dup_sess;
1957
1958                 for (i = 1; i < sessions; i++) {
1959                         if (cctx->sesscount++ >= FASTRPC_MAX_SESSIONS)
1960                                 break;
1961                         dup_sess = &cctx->session[cctx->sesscount];
1962                         memcpy(dup_sess, sess, sizeof(*dup_sess));
1963                 }
1964         }
1965         cctx->sesscount++;
1966         spin_unlock_irqrestore(&cctx->lock, flags);
1967         rc = dma_set_mask(dev, DMA_BIT_MASK(32));
1968         if (rc) {
1969                 dev_err(dev, "32-bit DMA enable failed\n");
1970                 return rc;
1971         }
1972
1973         return 0;
1974 }
1975
1976 static int fastrpc_cb_remove(struct platform_device *pdev)
1977 {
1978         struct fastrpc_channel_ctx *cctx = dev_get_drvdata(pdev->dev.parent);
1979         struct fastrpc_session_ctx *sess = dev_get_drvdata(&pdev->dev);
1980         unsigned long flags;
1981         int i;
1982
1983         spin_lock_irqsave(&cctx->lock, flags);
1984         for (i = 1; i < FASTRPC_MAX_SESSIONS; i++) {
1985                 if (cctx->session[i].sid == sess->sid) {
1986                         cctx->session[i].valid = false;
1987                         cctx->sesscount--;
1988                 }
1989         }
1990         spin_unlock_irqrestore(&cctx->lock, flags);
1991
1992         return 0;
1993 }
1994
1995 static const struct of_device_id fastrpc_match_table[] = {
1996         { .compatible = "qcom,fastrpc-compute-cb", },
1997         {}
1998 };
1999
2000 static struct platform_driver fastrpc_cb_driver = {
2001         .probe = fastrpc_cb_probe,
2002         .remove = fastrpc_cb_remove,
2003         .driver = {
2004                 .name = "qcom,fastrpc-cb",
2005                 .of_match_table = fastrpc_match_table,
2006                 .suppress_bind_attrs = true,
2007         },
2008 };
2009
2010 static int fastrpc_device_register(struct device *dev, struct fastrpc_channel_ctx *cctx,
2011                                    bool is_secured, const char *domain)
2012 {
2013         struct fastrpc_device *fdev;
2014         int err;
2015
2016         fdev = devm_kzalloc(dev, sizeof(*fdev), GFP_KERNEL);
2017         if (!fdev)
2018                 return -ENOMEM;
2019
2020         fdev->secure = is_secured;
2021         fdev->cctx = cctx;
2022         fdev->miscdev.minor = MISC_DYNAMIC_MINOR;
2023         fdev->miscdev.fops = &fastrpc_fops;
2024         fdev->miscdev.name = devm_kasprintf(dev, GFP_KERNEL, "fastrpc-%s%s",
2025                                             domain, is_secured ? "-secure" : "");
2026         err = misc_register(&fdev->miscdev);
2027         if (!err) {
2028                 if (is_secured)
2029                         cctx->secure_fdevice = fdev;
2030                 else
2031                         cctx->fdevice = fdev;
2032         }
2033
2034         return err;
2035 }
2036
2037 static int fastrpc_rpmsg_probe(struct rpmsg_device *rpdev)
2038 {
2039         struct device *rdev = &rpdev->dev;
2040         struct fastrpc_channel_ctx *data;
2041         int i, err, domain_id = -1, vmcount;
2042         const char *domain;
2043         bool secure_dsp;
2044         unsigned int vmids[FASTRPC_MAX_VMIDS];
2045
2046         err = of_property_read_string(rdev->of_node, "label", &domain);
2047         if (err) {
2048                 dev_info(rdev, "FastRPC Domain not specified in DT\n");
2049                 return err;
2050         }
2051
2052         for (i = 0; i <= CDSP_DOMAIN_ID; i++) {
2053                 if (!strcmp(domains[i], domain)) {
2054                         domain_id = i;
2055                         break;
2056                 }
2057         }
2058
2059         if (domain_id < 0) {
2060                 dev_info(rdev, "FastRPC Invalid Domain ID %d\n", domain_id);
2061                 return -EINVAL;
2062         }
2063
2064         vmcount = of_property_read_variable_u32_array(rdev->of_node,
2065                                 "qcom,vmids", &vmids[0], 0, FASTRPC_MAX_VMIDS);
2066         if (vmcount < 0)
2067                 vmcount = 0;
2068         else if (!qcom_scm_is_available())
2069                 return -EPROBE_DEFER;
2070
2071         data = kzalloc(sizeof(*data), GFP_KERNEL);
2072         if (!data)
2073                 return -ENOMEM;
2074
2075         if (vmcount) {
2076                 data->vmcount = vmcount;
2077                 data->perms = BIT(QCOM_SCM_VMID_HLOS);
2078                 for (i = 0; i < data->vmcount; i++) {
2079                         data->vmperms[i].vmid = vmids[i];
2080                         data->vmperms[i].perm = QCOM_SCM_PERM_RWX;
2081                 }
2082         }
2083
2084         secure_dsp = !(of_property_read_bool(rdev->of_node, "qcom,non-secure-domain"));
2085         data->secure = secure_dsp;
2086
2087         switch (domain_id) {
2088         case ADSP_DOMAIN_ID:
2089         case MDSP_DOMAIN_ID:
2090         case SDSP_DOMAIN_ID:
2091                 /* Unsigned PD offloading is only supported on CDSP*/
2092                 data->unsigned_support = false;
2093                 err = fastrpc_device_register(rdev, data, secure_dsp, domains[domain_id]);
2094                 if (err)
2095                         goto fdev_error;
2096                 break;
2097         case CDSP_DOMAIN_ID:
2098                 data->unsigned_support = true;
2099                 /* Create both device nodes so that we can allow both Signed and Unsigned PD */
2100                 err = fastrpc_device_register(rdev, data, true, domains[domain_id]);
2101                 if (err)
2102                         goto fdev_error;
2103
2104                 err = fastrpc_device_register(rdev, data, false, domains[domain_id]);
2105                 if (err)
2106                         goto fdev_error;
2107                 break;
2108         default:
2109                 err = -EINVAL;
2110                 goto fdev_error;
2111         }
2112
2113         kref_init(&data->refcount);
2114
2115         dev_set_drvdata(&rpdev->dev, data);
2116         dma_set_mask_and_coherent(rdev, DMA_BIT_MASK(32));
2117         INIT_LIST_HEAD(&data->users);
2118         spin_lock_init(&data->lock);
2119         idr_init(&data->ctx_idr);
2120         data->domain_id = domain_id;
2121         data->rpdev = rpdev;
2122
2123         return of_platform_populate(rdev->of_node, NULL, NULL, rdev);
2124 fdev_error:
2125         kfree(data);
2126         return err;
2127 }
2128
2129 static void fastrpc_notify_users(struct fastrpc_user *user)
2130 {
2131         struct fastrpc_invoke_ctx *ctx;
2132
2133         spin_lock(&user->lock);
2134         list_for_each_entry(ctx, &user->pending, node)
2135                 complete(&ctx->work);
2136         spin_unlock(&user->lock);
2137 }
2138
2139 static void fastrpc_rpmsg_remove(struct rpmsg_device *rpdev)
2140 {
2141         struct fastrpc_channel_ctx *cctx = dev_get_drvdata(&rpdev->dev);
2142         struct fastrpc_user *user;
2143         unsigned long flags;
2144
2145         spin_lock_irqsave(&cctx->lock, flags);
2146         list_for_each_entry(user, &cctx->users, user)
2147                 fastrpc_notify_users(user);
2148         spin_unlock_irqrestore(&cctx->lock, flags);
2149
2150         if (cctx->fdevice)
2151                 misc_deregister(&cctx->fdevice->miscdev);
2152
2153         if (cctx->secure_fdevice)
2154                 misc_deregister(&cctx->secure_fdevice->miscdev);
2155
2156         of_platform_depopulate(&rpdev->dev);
2157
2158         cctx->rpdev = NULL;
2159         fastrpc_channel_ctx_put(cctx);
2160 }
2161
2162 static int fastrpc_rpmsg_callback(struct rpmsg_device *rpdev, void *data,
2163                                   int len, void *priv, u32 addr)
2164 {
2165         struct fastrpc_channel_ctx *cctx = dev_get_drvdata(&rpdev->dev);
2166         struct fastrpc_invoke_rsp *rsp = data;
2167         struct fastrpc_invoke_ctx *ctx;
2168         unsigned long flags;
2169         unsigned long ctxid;
2170
2171         if (len < sizeof(*rsp))
2172                 return -EINVAL;
2173
2174         ctxid = ((rsp->ctx & FASTRPC_CTXID_MASK) >> 4);
2175
2176         spin_lock_irqsave(&cctx->lock, flags);
2177         ctx = idr_find(&cctx->ctx_idr, ctxid);
2178         spin_unlock_irqrestore(&cctx->lock, flags);
2179
2180         if (!ctx) {
2181                 dev_err(&rpdev->dev, "No context ID matches response\n");
2182                 return -ENOENT;
2183         }
2184
2185         ctx->retval = rsp->retval;
2186         complete(&ctx->work);
2187
2188         /*
2189          * The DMA buffer associated with the context cannot be freed in
2190          * interrupt context so schedule it through a worker thread to
2191          * avoid a kernel BUG.
2192          */
2193         schedule_work(&ctx->put_work);
2194
2195         return 0;
2196 }
2197
2198 static const struct of_device_id fastrpc_rpmsg_of_match[] = {
2199         { .compatible = "qcom,fastrpc" },
2200         { },
2201 };
2202 MODULE_DEVICE_TABLE(of, fastrpc_rpmsg_of_match);
2203
2204 static struct rpmsg_driver fastrpc_driver = {
2205         .probe = fastrpc_rpmsg_probe,
2206         .remove = fastrpc_rpmsg_remove,
2207         .callback = fastrpc_rpmsg_callback,
2208         .drv = {
2209                 .name = "qcom,fastrpc",
2210                 .of_match_table = fastrpc_rpmsg_of_match,
2211         },
2212 };
2213
2214 static int fastrpc_init(void)
2215 {
2216         int ret;
2217
2218         ret = platform_driver_register(&fastrpc_cb_driver);
2219         if (ret < 0) {
2220                 pr_err("fastrpc: failed to register cb driver\n");
2221                 return ret;
2222         }
2223
2224         ret = register_rpmsg_driver(&fastrpc_driver);
2225         if (ret < 0) {
2226                 pr_err("fastrpc: failed to register rpmsg driver\n");
2227                 platform_driver_unregister(&fastrpc_cb_driver);
2228                 return ret;
2229         }
2230
2231         return 0;
2232 }
2233 module_init(fastrpc_init);
2234
2235 static void fastrpc_exit(void)
2236 {
2237         platform_driver_unregister(&fastrpc_cb_driver);
2238         unregister_rpmsg_driver(&fastrpc_driver);
2239 }
2240 module_exit(fastrpc_exit);
2241
2242 MODULE_LICENSE("GPL v2");
2243 MODULE_IMPORT_NS(DMA_BUF);