Pileus Git - ~andy/linux/blob - drivers/staging/tidspbridge/pmgr/dspapi.c

   1 /*
   2  * dspapi.c
   3  *
   4  * DSP-BIOS Bridge driver support functions for TI OMAP processors.
   5  *
   6  * Common DSP API functions, also includes the wrapper
   7  * functions called directly by the DeviceIOControl interface.
   8  *
   9  * Copyright (C) 2005-2006 Texas Instruments, Inc.
  10  *
  11  * This package is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19 #include <linux/types.h>
  20
  21 /*  ----------------------------------- Host OS */
  22 #include <dspbridge/host_os.h>
  23
  24 /*  ----------------------------------- DSP/BIOS Bridge */
  25 #include <dspbridge/dbdefs.h>
  26
  27 /*  ----------------------------------- OS Adaptation Layer */
  28 #include <dspbridge/ntfy.h>
  29
  30 /*  ----------------------------------- Platform Manager */
  31 #include <dspbridge/chnl.h>
  32 #include <dspbridge/dev.h>
  33 #include <dspbridge/drv.h>
  34
  35 #include <dspbridge/proc.h>
  36 #include <dspbridge/strm.h>
  37
  38 /*  ----------------------------------- Resource Manager */
  39 #include <dspbridge/disp.h>
  40 #include <dspbridge/mgr.h>
  41 #include <dspbridge/node.h>
  42 #include <dspbridge/rmm.h>
  43
  44 /*  ----------------------------------- Others */
  45 #include <dspbridge/msg.h>
  46 #include <dspbridge/cmm.h>
  47 #include <dspbridge/io.h>
  48
  49 /*  ----------------------------------- This */
  50 #include <dspbridge/dspapi.h>
  51 #include <dspbridge/dbdcd.h>
  52
  53 #include <dspbridge/resourcecleanup.h>
  54
  55 /*  ----------------------------------- Defines, Data Structures, Typedefs */
  56 #define MAX_TRACEBUFLEN 255
  57 #define MAX_LOADARGS    16
  58 #define MAX_NODES       64
  59 #define MAX_STREAMS     16
  60 #define MAX_BUFS        64
  61
  62 /* Used to get dspbridge ioctl table */
  63 #define DB_GET_IOC_TABLE(cmd)   (DB_GET_MODULE(cmd) >> DB_MODULE_SHIFT)
  64
  65 /* Device IOCtl function pointer */
  66 struct api_cmd {
  67         u32(*fxn) (union trapped_args *args, void *pr_ctxt);
  68         u32 index;
  69 };
  70
  71 /*  ----------------------------------- Globals */
  72 static u32 api_c_refs;
  73
  74 /*
  75  *  Function tables.
  76  *  The order of these functions MUST be the same as the order of the command
  77  *  numbers defined in dspapi-ioctl.h  This is how an IOCTL number in user mode
  78  *  turns into a function call in kernel mode.
  79  */
  80
  81 /* MGR wrapper functions */
  82 static struct api_cmd mgr_cmd[] = {
  83         {mgrwrap_enum_node_info},       /* MGR_ENUMNODE_INFO */
  84         {mgrwrap_enum_proc_info},       /* MGR_ENUMPROC_INFO */
  85         {mgrwrap_register_object},      /* MGR_REGISTEROBJECT */
  86         {mgrwrap_unregister_object},    /* MGR_UNREGISTEROBJECT */
  87         {mgrwrap_wait_for_bridge_events},       /* MGR_WAIT */
  88         {mgrwrap_get_process_resources_info},   /* MGR_GET_PROC_RES */
  89 };
  90
  91 /* PROC wrapper functions */
  92 static struct api_cmd proc_cmd[] = {
  93         {procwrap_attach},      /* PROC_ATTACH */
  94         {procwrap_ctrl},        /* PROC_CTRL */
  95         {procwrap_detach},      /* PROC_DETACH */
  96         {procwrap_enum_node_info},      /* PROC_ENUMNODE */
  97         {procwrap_enum_resources},      /* PROC_ENUMRESOURCES */
  98         {procwrap_get_state},   /* PROC_GET_STATE */
  99         {procwrap_get_trace},   /* PROC_GET_TRACE */
 100         {procwrap_load},        /* PROC_LOAD */
 101         {procwrap_register_notify},     /* PROC_REGISTERNOTIFY */
 102         {procwrap_start},       /* PROC_START */
 103         {procwrap_reserve_memory},      /* PROC_RSVMEM */
 104         {procwrap_un_reserve_memory},   /* PROC_UNRSVMEM */
 105         {procwrap_map},         /* PROC_MAPMEM */
 106         {procwrap_un_map},      /* PROC_UNMAPMEM */
 107         {procwrap_flush_memory},        /* PROC_FLUSHMEMORY */
 108         {procwrap_stop},        /* PROC_STOP */
 109         {procwrap_invalidate_memory},   /* PROC_INVALIDATEMEMORY */
 110         {procwrap_begin_dma},   /* PROC_BEGINDMA */
 111         {procwrap_end_dma},     /* PROC_ENDDMA */
 112 };
 113
 114 /* NODE wrapper functions */
 115 static struct api_cmd node_cmd[] = {
 116         {nodewrap_allocate},    /* NODE_ALLOCATE */
 117         {nodewrap_alloc_msg_buf},       /* NODE_ALLOCMSGBUF */
 118         {nodewrap_change_priority},     /* NODE_CHANGEPRIORITY */
 119         {nodewrap_connect},     /* NODE_CONNECT */
 120         {nodewrap_create},      /* NODE_CREATE */
 121         {nodewrap_delete},      /* NODE_DELETE */
 122         {nodewrap_free_msg_buf},        /* NODE_FREEMSGBUF */
 123         {nodewrap_get_attr},    /* NODE_GETATTR */
 124         {nodewrap_get_message}, /* NODE_GETMESSAGE */
 125         {nodewrap_pause},       /* NODE_PAUSE */
 126         {nodewrap_put_message}, /* NODE_PUTMESSAGE */
 127         {nodewrap_register_notify},     /* NODE_REGISTERNOTIFY */
 128         {nodewrap_run},         /* NODE_RUN */
 129         {nodewrap_terminate},   /* NODE_TERMINATE */
 130         {nodewrap_get_uuid_props},      /* NODE_GETUUIDPROPS */
 131 };
 132
 133 /* STRM wrapper functions */
 134 static struct api_cmd strm_cmd[] = {
 135         {strmwrap_allocate_buffer},     /* STRM_ALLOCATEBUFFER */
 136         {strmwrap_close},       /* STRM_CLOSE */
 137         {strmwrap_free_buffer}, /* STRM_FREEBUFFER */
 138         {strmwrap_get_event_handle},    /* STRM_GETEVENTHANDLE */
 139         {strmwrap_get_info},    /* STRM_GETINFO */
 140         {strmwrap_idle},        /* STRM_IDLE */
 141         {strmwrap_issue},       /* STRM_ISSUE */
 142         {strmwrap_open},        /* STRM_OPEN */
 143         {strmwrap_reclaim},     /* STRM_RECLAIM */
 144         {strmwrap_register_notify},     /* STRM_REGISTERNOTIFY */
 145         {strmwrap_select},      /* STRM_SELECT */
 146 };
 147
 148 /* CMM wrapper functions */
 149 static struct api_cmd cmm_cmd[] = {
 150         {cmmwrap_calloc_buf},   /* CMM_ALLOCBUF */
 151         {cmmwrap_free_buf},     /* CMM_FREEBUF */
 152         {cmmwrap_get_handle},   /* CMM_GETHANDLE */
 153         {cmmwrap_get_info},     /* CMM_GETINFO */
 154 };
 155
 156 /* Array used to store ioctl table sizes. It can hold up to 8 entries */
 157 static u8 size_cmd[] = {
 158         ARRAY_SIZE(mgr_cmd),
 159         ARRAY_SIZE(proc_cmd),
 160         ARRAY_SIZE(node_cmd),
 161         ARRAY_SIZE(strm_cmd),
 162         ARRAY_SIZE(cmm_cmd),
 163 };
 164
 165 static inline void _cp_fm_usr(void *to, const void __user * from,
 166                               int *err, unsigned long bytes)
 167 {
 168         if (*err)
 169                 return;
 170
 171         if (unlikely(!from)) {
 172                 *err = -EFAULT;
 173                 return;
 174         }
 175
 176         if (unlikely(copy_from_user(to, from, bytes)))
 177                 *err = -EFAULT;
 178 }
 179
 180 #define CP_FM_USR(to, from, err, n)                             \
 181         _cp_fm_usr(to, from, &(err), (n) * sizeof(*(to)))
 182
 183 static inline void _cp_to_usr(void __user *to, const void *from,
 184                               int *err, unsigned long bytes)
 185 {
 186         if (*err)
 187                 return;
 188
 189         if (unlikely(!to)) {
 190                 *err = -EFAULT;
 191                 return;
 192         }
 193
 194         if (unlikely(copy_to_user(to, from, bytes)))
 195                 *err = -EFAULT;
 196 }
 197
 198 #define CP_TO_USR(to, from, err, n)                             \
 199         _cp_to_usr(to, from, &(err), (n) * sizeof(*(from)))
 200
 201 /*
 202  *  ======== api_call_dev_ioctl ========
 203  *  Purpose:
 204  *      Call the (wrapper) function for the corresponding API IOCTL.
 205  */
 206 inline int api_call_dev_ioctl(u32 cmd, union trapped_args *args,
 207                                       u32 *result, void *pr_ctxt)
 208 {
 209         u32(*ioctl_cmd) (union trapped_args *args, void *pr_ctxt) = NULL;
 210         int i;
 211
 212         if (_IOC_TYPE(cmd) != DB) {
 213                 pr_err("%s: Incompatible dspbridge ioctl number\n", __func__);
 214                 goto err;
 215         }
 216
 217         if (DB_GET_IOC_TABLE(cmd) > ARRAY_SIZE(size_cmd)) {
 218                 pr_err("%s: undefined ioctl module\n", __func__);
 219                 goto err;
 220         }
 221
 222         /* Check the size of the required cmd table */
 223         i = DB_GET_IOC(cmd);
 224         if (i > size_cmd[DB_GET_IOC_TABLE(cmd)]) {
 225                 pr_err("%s: requested ioctl %d out of bounds for table %d\n",
 226                        __func__, i, DB_GET_IOC_TABLE(cmd));
 227                 goto err;
 228         }
 229
 230         switch (DB_GET_MODULE(cmd)) {
 231         case DB_MGR:
 232                 ioctl_cmd = mgr_cmd[i].fxn;
 233                 break;
 234         case DB_PROC:
 235                 ioctl_cmd = proc_cmd[i].fxn;
 236                 break;
 237         case DB_NODE:
 238                 ioctl_cmd = node_cmd[i].fxn;
 239                 break;
 240         case DB_STRM:
 241                 ioctl_cmd = strm_cmd[i].fxn;
 242                 break;
 243         case DB_CMM:
 244                 ioctl_cmd = cmm_cmd[i].fxn;
 245                 break;
 246         }
 247
 248         if (!ioctl_cmd) {
 249                 pr_err("%s: requested ioctl not defined\n", __func__);
 250                 goto err;
 251         } else {
 252                 *result = (*ioctl_cmd) (args, pr_ctxt);
 253         }
 254
 255         return 0;
 256
 257 err:
 258         return -EINVAL;
 259 }
 260
 261 /*
 262  *  ======== api_exit ========
 263  */
 264 void api_exit(void)
 265 {
 266         api_c_refs--;
 267
 268         if (api_c_refs == 0)
 269                 mgr_exit();
 270 }
 271
 272 /*
 273  *  ======== api_init ========
 274  *  Purpose:
 275  *      Module initialization used by Bridge API.
 276  */
 277 bool api_init(void)
 278 {
 279         bool ret = true;
 280
 281         if (api_c_refs == 0)
 282                 ret = mgr_init();
 283
 284         if (ret)
 285                 api_c_refs++;
 286
 287         return ret;
 288 }
 289
 290 /*
 291  *  ======== api_init_complete2 ========
 292  *  Purpose:
 293  *      Perform any required bridge initialization which cannot
 294  *      be performed in api_init() or dev_start_device() due
 295  *      to the fact that some services are not yet
 296  *      completely initialized.
 297  *  Parameters:
 298  *  Returns:
 299  *      0:      Allow this device to load
 300  *      -EPERM:      Failure.
 301  *  Requires:
 302  *      Bridge API initialized.
 303  *  Ensures:
 304  */
 305 int api_init_complete2(void)
 306 {
 307         int status = 0;
 308         struct cfg_devnode *dev_node;
 309         struct dev_object *hdev_obj;
 310         struct drv_data *drv_datap;
 311         u8 dev_type;
 312
 313         /*  Walk the list of DevObjects, get each devnode, and attempting to
 314          *  autostart the board. Note that this requires COF loading, which
 315          *  requires KFILE. */
 316         for (hdev_obj = dev_get_first(); hdev_obj != NULL;
 317              hdev_obj = dev_get_next(hdev_obj)) {
 318                 if (dev_get_dev_node(hdev_obj, &dev_node))
 319                         continue;
 320
 321                 if (dev_get_dev_type(hdev_obj, &dev_type))
 322                         continue;
 323
 324                 if ((dev_type == DSP_UNIT) || (dev_type == IVA_UNIT)) {
 325                         drv_datap = dev_get_drvdata(bridge);
 326
 327                         if (drv_datap && drv_datap->base_img)
 328                                 proc_auto_start(dev_node, hdev_obj);
 329                 }
 330         }
 331
 332         return status;
 333 }
 334
 335 /* TODO: Remove deprecated and not implemented ioctl wrappers */
 336
 337 /*
 338  * ======== mgrwrap_enum_node_info ========
 339  */
 340 u32 mgrwrap_enum_node_info(union trapped_args *args, void *pr_ctxt)
 341 {
 342         u8 *pndb_props;
 343         u32 num_nodes;
 344         int status = 0;
 345         u32 size = args->args_mgr_enumnode_info.ndb_props_size;
 346
 347         if (size < sizeof(struct dsp_ndbprops))
 348                 return -EINVAL;
 349
 350         pndb_props = kmalloc(size, GFP_KERNEL);
 351         if (pndb_props == NULL)
 352                 status = -ENOMEM;
 353
 354         if (!status) {
 355                 status =
 356                     mgr_enum_node_info(args->args_mgr_enumnode_info.node_id,
 357                                        (struct dsp_ndbprops *)pndb_props, size,
 358                                        &num_nodes);
 359         }
 360         CP_TO_USR(args->args_mgr_enumnode_info.ndb_props, pndb_props, status,
 361                   size);
 362         CP_TO_USR(args->args_mgr_enumnode_info.num_nodes, &num_nodes, status,
 363                   1);
 364         kfree(pndb_props);
 365
 366         return status;
 367 }
 368
 369 /*
 370  * ======== mgrwrap_enum_proc_info ========
 371  */
 372 u32 mgrwrap_enum_proc_info(union trapped_args *args, void *pr_ctxt)
 373 {
 374         u8 *processor_info;
 375         u8 num_procs;
 376         int status = 0;
 377         u32 size = args->args_mgr_enumproc_info.processor_info_size;
 378
 379         if (size < sizeof(struct dsp_processorinfo))
 380                 return -EINVAL;
 381
 382         processor_info = kmalloc(size, GFP_KERNEL);
 383         if (processor_info == NULL)
 384                 status = -ENOMEM;
 385
 386         if (!status) {
 387                 status =
 388                     mgr_enum_processor_info(args->args_mgr_enumproc_info.
 389                                             processor_id,
 390                                             (struct dsp_processorinfo *)
 391                                             processor_info, size, &num_procs);
 392         }
 393         CP_TO_USR(args->args_mgr_enumproc_info.processor_info, processor_info,
 394                   status, size);
 395         CP_TO_USR(args->args_mgr_enumproc_info.num_procs, &num_procs,
 396                   status, 1);
 397         kfree(processor_info);
 398
 399         return status;
 400 }
 401
 402 #define WRAP_MAP2CALLER(x) x
 403 /*
 404  * ======== mgrwrap_register_object ========
 405  */
 406 u32 mgrwrap_register_object(union trapped_args *args, void *pr_ctxt)
 407 {
 408         u32 ret;
 409         struct dsp_uuid uuid_obj;
 410         u32 path_size = 0;
 411         char *psz_path_name = NULL;
 412         int status = 0;
 413
 414         CP_FM_USR(&uuid_obj, args->args_mgr_registerobject.uuid_obj, status, 1);
 415         if (status)
 416                 goto func_end;
 417         /* path_size is increased by 1 to accommodate NULL */
 418         path_size = strlen_user((char *)
 419                                 args->args_mgr_registerobject.sz_path_name) +
 420             1;
 421         psz_path_name = kmalloc(path_size, GFP_KERNEL);
 422         if (!psz_path_name) {
 423                 status = -ENOMEM;
 424                 goto func_end;
 425         }
 426         ret = strncpy_from_user(psz_path_name,
 427                                 (char *)args->args_mgr_registerobject.
 428                                 sz_path_name, path_size);
 429         if (!ret) {
 430                 status = -EFAULT;
 431                 goto func_end;
 432         }
 433
 434         if (args->args_mgr_registerobject.obj_type >= DSP_DCDMAXOBJTYPE) {
 435                 status = -EINVAL;
 436                 goto func_end;
 437         }
 438
 439         status = dcd_register_object(&uuid_obj,
 440                                      args->args_mgr_registerobject.obj_type,
 441                                      (char *)psz_path_name);
 442 func_end:
 443         kfree(psz_path_name);
 444         return status;
 445 }
 446
 447 /*
 448  * ======== mgrwrap_unregister_object ========
 449  */
 450 u32 mgrwrap_unregister_object(union trapped_args *args, void *pr_ctxt)
 451 {
 452         int status = 0;
 453         struct dsp_uuid uuid_obj;
 454
 455         CP_FM_USR(&uuid_obj, args->args_mgr_registerobject.uuid_obj, status, 1);
 456         if (status)
 457                 goto func_end;
 458
 459         status = dcd_unregister_object(&uuid_obj,
 460                                        args->args_mgr_unregisterobject.
 461                                        obj_type);
 462 func_end:
 463         return status;
 464
 465 }
 466
 467 /*
 468  * ======== mgrwrap_wait_for_bridge_events ========
 469  */
 470 u32 mgrwrap_wait_for_bridge_events(union trapped_args *args, void *pr_ctxt)
 471 {
 472         int status = 0;
 473         struct dsp_notification *anotifications[MAX_EVENTS];
 474         struct dsp_notification notifications[MAX_EVENTS];
 475         u32 index, i;
 476         u32 count = args->args_mgr_wait.count;
 477
 478         if (count > MAX_EVENTS)
 479                 status = -EINVAL;
 480
 481         /* get the array of pointers to user structures */
 482         CP_FM_USR(anotifications, args->args_mgr_wait.anotifications,
 483                   status, count);
 484         /* get the events */
 485         for (i = 0; i < count; i++) {
 486                 CP_FM_USR(&notifications[i], anotifications[i], status, 1);
 487                 if (status || !notifications[i].handle) {
 488                         status = -EINVAL;
 489                         break;
 490                 }
 491                 /* set the array of pointers to kernel structures */
 492                 anotifications[i] = &notifications[i];
 493         }
 494         if (!status) {
 495                 status = mgr_wait_for_bridge_events(anotifications, count,
 496                                                          &index,
 497                                                          args->args_mgr_wait.
 498                                                          timeout);
 499         }
 500         CP_TO_USR(args->args_mgr_wait.index, &index, status, 1);
 501         return status;
 502 }
 503
 504 /*
 505  * ======== MGRWRAP_GetProcessResourceInfo ========
 506  */
 507 u32 __deprecated mgrwrap_get_process_resources_info(union trapped_args * args,
 508                                                     void *pr_ctxt)
 509 {
 510         pr_err("%s: deprecated dspbridge ioctl\n", __func__);
 511         return 0;
 512 }
 513
 514 /*
 515  * ======== procwrap_attach ========
 516  */
 517 u32 procwrap_attach(union trapped_args *args, void *pr_ctxt)
 518 {
 519         void *processor;
 520         int status = 0;
 521         struct dsp_processorattrin proc_attr_in, *attr_in = NULL;
 522
 523         /* Optional argument */
 524         if (args->args_proc_attach.attr_in) {
 525                 CP_FM_USR(&proc_attr_in, args->args_proc_attach.attr_in, status,
 526                           1);
 527                 if (!status)
 528                         attr_in = &proc_attr_in;
 529                 else
 530                         goto func_end;
 531
 532         }
 533         status = proc_attach(args->args_proc_attach.processor_id, attr_in,
 534                              &processor, pr_ctxt);
 535         CP_TO_USR(args->args_proc_attach.ph_processor, &processor, status, 1);
 536 func_end:
 537         return status;
 538 }
 539
 540 /*
 541  * ======== procwrap_ctrl ========
 542  */
 543 u32 procwrap_ctrl(union trapped_args *args, void *pr_ctxt)
 544 {
 545         u32 cb_data_size, __user * psize = (u32 __user *)
 546             args->args_proc_ctrl.args;
 547         u8 *pargs = NULL;
 548         int status = 0;
 549         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 550
 551         if (psize) {
 552                 if (get_user(cb_data_size, psize)) {
 553                         status = -EPERM;
 554                         goto func_end;
 555                 }
 556                 cb_data_size += sizeof(u32);
 557                 pargs = kmalloc(cb_data_size, GFP_KERNEL);
 558                 if (pargs == NULL) {
 559                         status = -ENOMEM;
 560                         goto func_end;
 561                 }
 562
 563                 CP_FM_USR(pargs, args->args_proc_ctrl.args, status,
 564                           cb_data_size);
 565         }
 566         if (!status) {
 567                 status = proc_ctrl(hprocessor,
 568                                    args->args_proc_ctrl.cmd,
 569                                    (struct dsp_cbdata *)pargs);
 570         }
 571
 572         /* CP_TO_USR(args->args_proc_ctrl.args, pargs, status, 1); */
 573         kfree(pargs);
 574 func_end:
 575         return status;
 576 }
 577
 578 /*
 579  * ======== procwrap_detach ========
 580  */
 581 u32 __deprecated procwrap_detach(union trapped_args * args, void *pr_ctxt)
 582 {
 583         /* proc_detach called at bridge_release only */
 584         pr_err("%s: deprecated dspbridge ioctl\n", __func__);
 585         return 0;
 586 }
 587
 588 /*
 589  * ======== procwrap_enum_node_info ========
 590  */
 591 u32 procwrap_enum_node_info(union trapped_args *args, void *pr_ctxt)
 592 {
 593         int status;
 594         void *node_tab[MAX_NODES];
 595         u32 num_nodes;
 596         u32 alloc_cnt;
 597         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 598
 599         if (!args->args_proc_enumnode_info.node_tab_size)
 600                 return -EINVAL;
 601
 602         status = proc_enum_nodes(hprocessor,
 603                                  node_tab,
 604                                  args->args_proc_enumnode_info.node_tab_size,
 605                                  &num_nodes, &alloc_cnt);
 606         CP_TO_USR(args->args_proc_enumnode_info.node_tab, node_tab, status,
 607                   num_nodes);
 608         CP_TO_USR(args->args_proc_enumnode_info.num_nodes, &num_nodes,
 609                   status, 1);
 610         CP_TO_USR(args->args_proc_enumnode_info.allocated, &alloc_cnt,
 611                   status, 1);
 612         return status;
 613 }
 614
 615 u32 procwrap_end_dma(union trapped_args *args, void *pr_ctxt)
 616 {
 617         int status;
 618
 619         if (args->args_proc_dma.dir >= DMA_NONE)
 620                 return -EINVAL;
 621
 622         status = proc_end_dma(pr_ctxt,
 623                                    args->args_proc_dma.mpu_addr,
 624                                    args->args_proc_dma.size,
 625                                    args->args_proc_dma.dir);
 626         return status;
 627 }
 628
 629 u32 procwrap_begin_dma(union trapped_args *args, void *pr_ctxt)
 630 {
 631         int status;
 632
 633         if (args->args_proc_dma.dir >= DMA_NONE)
 634                 return -EINVAL;
 635
 636         status = proc_begin_dma(pr_ctxt,
 637                                    args->args_proc_dma.mpu_addr,
 638                                    args->args_proc_dma.size,
 639                                    args->args_proc_dma.dir);
 640         return status;
 641 }
 642
 643 /*
 644  * ======== procwrap_flush_memory ========
 645  */
 646 u32 procwrap_flush_memory(union trapped_args *args, void *pr_ctxt)
 647 {
 648         int status;
 649
 650         if (args->args_proc_flushmemory.flags >
 651             PROC_WRITEBACK_INVALIDATE_MEM)
 652                 return -EINVAL;
 653
 654         status = proc_flush_memory(pr_ctxt,
 655                                    args->args_proc_flushmemory.mpu_addr,
 656                                    args->args_proc_flushmemory.size,
 657                                    args->args_proc_flushmemory.flags);
 658         return status;
 659 }
 660
 661 /*
 662  * ======== procwrap_invalidate_memory ========
 663  */
 664 u32 procwrap_invalidate_memory(union trapped_args *args, void *pr_ctxt)
 665 {
 666         int status;
 667
 668         status =
 669             proc_invalidate_memory(pr_ctxt,
 670                                    args->args_proc_invalidatememory.mpu_addr,
 671                                    args->args_proc_invalidatememory.size);
 672         return status;
 673 }
 674
 675 /*
 676  * ======== procwrap_enum_resources ========
 677  */
 678 u32 procwrap_enum_resources(union trapped_args *args, void *pr_ctxt)
 679 {
 680         int status = 0;
 681         struct dsp_resourceinfo resource_info;
 682         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 683
 684         if (args->args_proc_enumresources.resource_info_size <
 685             sizeof(struct dsp_resourceinfo))
 686                 return -EINVAL;
 687
 688         status =
 689             proc_get_resource_info(hprocessor,
 690                                    args->args_proc_enumresources.resource_type,
 691                                    &resource_info,
 692                                    args->args_proc_enumresources.
 693                                    resource_info_size);
 694
 695         CP_TO_USR(args->args_proc_enumresources.resource_info, &resource_info,
 696                   status, 1);
 697
 698         return status;
 699
 700 }
 701
 702 /*
 703  * ======== procwrap_get_state ========
 704  */
 705 u32 procwrap_get_state(union trapped_args *args, void *pr_ctxt)
 706 {
 707         int status;
 708         struct dsp_processorstate proc_state;
 709         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 710
 711         if (args->args_proc_getstate.state_info_size <
 712             sizeof(struct dsp_processorstate))
 713                 return -EINVAL;
 714
 715         status = proc_get_state(hprocessor, &proc_state,
 716                            args->args_proc_getstate.state_info_size);
 717         CP_TO_USR(args->args_proc_getstate.proc_state_obj, &proc_state, status,
 718                   1);
 719         return status;
 720
 721 }
 722
 723 /*
 724  * ======== procwrap_get_trace ========
 725  */
 726 u32 procwrap_get_trace(union trapped_args *args, void *pr_ctxt)
 727 {
 728         int status;
 729         u8 *pbuf;
 730         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 731
 732         if (args->args_proc_gettrace.max_size > MAX_TRACEBUFLEN)
 733                 return -EINVAL;
 734
 735         pbuf = kzalloc(args->args_proc_gettrace.max_size, GFP_KERNEL);
 736         if (pbuf != NULL) {
 737                 status = proc_get_trace(hprocessor, pbuf,
 738                                         args->args_proc_gettrace.max_size);
 739         } else {
 740                 status = -ENOMEM;
 741         }
 742         CP_TO_USR(args->args_proc_gettrace.buf, pbuf, status,
 743                   args->args_proc_gettrace.max_size);
 744         kfree(pbuf);
 745
 746         return status;
 747 }
 748
 749 /*
 750  * ======== procwrap_load ========
 751  */
 752 u32 procwrap_load(union trapped_args *args, void *pr_ctxt)
 753 {
 754         s32 i, len;
 755         int status = 0;
 756         char *temp;
 757         s32 count = args->args_proc_load.argc_index;
 758         u8 **argv = NULL, **envp = NULL;
 759         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 760
 761         if (count <= 0 || count > MAX_LOADARGS) {
 762                 status = -EINVAL;
 763                 goto func_cont;
 764         }
 765
 766         argv = kmalloc(count * sizeof(u8 *), GFP_KERNEL);
 767         if (!argv) {
 768                 status = -ENOMEM;
 769                 goto func_cont;
 770         }
 771
 772         CP_FM_USR(argv, args->args_proc_load.user_args, status, count);
 773         if (status) {
 774                 kfree(argv);
 775                 argv = NULL;
 776                 goto func_cont;
 777         }
 778
 779         for (i = 0; i < count; i++) {
 780                 if (argv[i]) {
 781                         /* User space pointer to argument */
 782                         temp = (char *)argv[i];
 783                         /* len is increased by 1 to accommodate NULL */
 784                         len = strlen_user((char *)temp) + 1;
 785                         /* Kernel space pointer to argument */
 786                         argv[i] = kmalloc(len, GFP_KERNEL);
 787                         if (argv[i]) {
 788                                 CP_FM_USR(argv[i], temp, status, len);
 789                                 if (status) {
 790                                         kfree(argv[i]);
 791                                         argv[i] = NULL;
 792                                         goto func_cont;
 793                                 }
 794                         } else {
 795                                 status = -ENOMEM;
 796                                 goto func_cont;
 797                         }
 798                 }
 799         }
 800         /* TODO: validate this */
 801         if (args->args_proc_load.user_envp) {
 802                 /* number of elements in the envp array including NULL */
 803                 count = 0;
 804                 do {
 805                         if (get_user(temp,
 806                                      args->args_proc_load.user_envp + count)) {
 807                                 status = -EFAULT;
 808                                 goto func_cont;
 809                         }
 810                         count++;
 811                 } while (temp);
 812                 envp = kmalloc(count * sizeof(u8 *), GFP_KERNEL);
 813                 if (!envp) {
 814                         status = -ENOMEM;
 815                         goto func_cont;
 816                 }
 817
 818                 CP_FM_USR(envp, args->args_proc_load.user_envp, status, count);
 819                 if (status) {
 820                         kfree(envp);
 821                         envp = NULL;
 822                         goto func_cont;
 823                 }
 824                 for (i = 0; envp[i]; i++) {
 825                         /* User space pointer to argument */
 826                         temp = (char *)envp[i];
 827                         /* len is increased by 1 to accommodate NULL */
 828                         len = strlen_user((char *)temp) + 1;
 829                         /* Kernel space pointer to argument */
 830                         envp[i] = kmalloc(len, GFP_KERNEL);
 831                         if (envp[i]) {
 832                                 CP_FM_USR(envp[i], temp, status, len);
 833                                 if (status) {
 834                                         kfree(envp[i]);
 835                                         envp[i] = NULL;
 836                                         goto func_cont;
 837                                 }
 838                         } else {
 839                                 status = -ENOMEM;
 840                                 goto func_cont;
 841                         }
 842                 }
 843         }
 844
 845         if (!status) {
 846                 status = proc_load(hprocessor,
 847                                    args->args_proc_load.argc_index,
 848                                    (const char **)argv, (const char **)envp);
 849         }
 850 func_cont:
 851         if (envp) {
 852                 i = 0;
 853                 while (envp[i])
 854                         kfree(envp[i++]);
 855
 856                 kfree(envp);
 857         }
 858
 859         if (argv) {
 860                 count = args->args_proc_load.argc_index;
 861                 for (i = 0; (i < count) && argv[i]; i++)
 862                         kfree(argv[i]);
 863
 864                 kfree(argv);
 865         }
 866
 867         return status;
 868 }
 869
 870 /*
 871  * ======== procwrap_map ========
 872  */
 873 u32 procwrap_map(union trapped_args *args, void *pr_ctxt)
 874 {
 875         int status;
 876         void *map_addr;
 877         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 878
 879         if (!args->args_proc_mapmem.size)
 880                 return -EINVAL;
 881
 882         status = proc_map(args->args_proc_mapmem.processor,
 883                           args->args_proc_mapmem.mpu_addr,
 884                           args->args_proc_mapmem.size,
 885                           args->args_proc_mapmem.req_addr, &map_addr,
 886                           args->args_proc_mapmem.map_attr, pr_ctxt);
 887         if (!status) {
 888                 if (put_user(map_addr, args->args_proc_mapmem.map_addr)) {
 889                         status = -EINVAL;
 890                         proc_un_map(hprocessor, map_addr, pr_ctxt);
 891                 }
 892
 893         }
 894         return status;
 895 }
 896
 897 /*
 898  * ======== procwrap_register_notify ========
 899  */
 900 u32 procwrap_register_notify(union trapped_args *args, void *pr_ctxt)
 901 {
 902         int status;
 903         struct dsp_notification notification;
 904         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 905
 906         /* Initialize the notification data structure */
 907         notification.name = NULL;
 908         notification.handle = NULL;
 909
 910         status = proc_register_notify(hprocessor,
 911                                  args->args_proc_register_notify.event_mask,
 912                                  args->args_proc_register_notify.notify_type,
 913                                  &notification);
 914         CP_TO_USR(args->args_proc_register_notify.notification, &notification,
 915                   status, 1);
 916         return status;
 917 }
 918
 919 /*
 920  * ======== procwrap_reserve_memory ========
 921  */
 922 u32 procwrap_reserve_memory(union trapped_args *args, void *pr_ctxt)
 923 {
 924         int status;
 925         void *prsv_addr;
 926         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 927
 928         if ((args->args_proc_rsvmem.size <= 0) ||
 929             (args->args_proc_rsvmem.size & (PG_SIZE4K - 1)) != 0)
 930                 return -EINVAL;
 931
 932         status = proc_reserve_memory(hprocessor,
 933                                      args->args_proc_rsvmem.size, &prsv_addr,
 934                                      pr_ctxt);
 935         if (!status) {
 936                 if (put_user(prsv_addr, args->args_proc_rsvmem.rsv_addr)) {
 937                         status = -EINVAL;
 938                         proc_un_reserve_memory(args->args_proc_rsvmem.
 939                                                processor, prsv_addr, pr_ctxt);
 940                 }
 941         }
 942         return status;
 943 }
 944
 945 /*
 946  * ======== procwrap_start ========
 947  */
 948 u32 procwrap_start(union trapped_args *args, void *pr_ctxt)
 949 {
 950         u32 ret;
 951
 952         ret = proc_start(((struct process_context *)pr_ctxt)->processor);
 953         return ret;
 954 }
 955
 956 /*
 957  * ======== procwrap_un_map ========
 958  */
 959 u32 procwrap_un_map(union trapped_args *args, void *pr_ctxt)
 960 {
 961         int status;
 962
 963         status = proc_un_map(((struct process_context *)pr_ctxt)->processor,
 964                              args->args_proc_unmapmem.map_addr, pr_ctxt);
 965         return status;
 966 }
 967
 968 /*
 969  * ======== procwrap_un_reserve_memory ========
 970  */
 971 u32 procwrap_un_reserve_memory(union trapped_args *args, void *pr_ctxt)
 972 {
 973         int status;
 974         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
 975
 976         status = proc_un_reserve_memory(hprocessor,
 977                                         args->args_proc_unrsvmem.rsv_addr,
 978                                         pr_ctxt);
 979         return status;
 980 }
 981
 982 /*
 983  * ======== procwrap_stop ========
 984  */
 985 u32 procwrap_stop(union trapped_args *args, void *pr_ctxt)
 986 {
 987         u32 ret;
 988
 989         ret = proc_stop(((struct process_context *)pr_ctxt)->processor);
 990
 991         return ret;
 992 }
 993
 994 /*
 995  * ======== find_handle =========
 996  */
 997 inline void find_node_handle(struct node_res_object **noderes,
 998                                 void *pr_ctxt, void *hnode)
 999 {
1000         rcu_read_lock();
1001         *noderes = idr_find(((struct process_context *)pr_ctxt)->node_id,
1002                                                                 (int)hnode - 1);
1003         rcu_read_unlock();
1004         return;
1005 }
1006
1007
1008 /*
1009  * ======== nodewrap_allocate ========
1010  */
1011 u32 nodewrap_allocate(union trapped_args *args, void *pr_ctxt)
1012 {
1013         int status = 0;
1014         struct dsp_uuid node_uuid;
1015         u32 cb_data_size = 0;
1016         u32 __user *psize = (u32 __user *) args->args_node_allocate.args;
1017         u8 *pargs = NULL;
1018         struct dsp_nodeattrin proc_attr_in, *attr_in = NULL;
1019         struct node_res_object *node_res;
1020         int nodeid;
1021         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
1022
1023         /* Optional argument */
1024         if (psize) {
1025                 if (get_user(cb_data_size, psize))
1026                         status = -EPERM;
1027
1028                 cb_data_size += sizeof(u32);
1029                 if (!status) {
1030                         pargs = kmalloc(cb_data_size, GFP_KERNEL);
1031                         if (pargs == NULL)
1032                                 status = -ENOMEM;
1033
1034                 }
1035                 CP_FM_USR(pargs, args->args_node_allocate.args, status,
1036                           cb_data_size);
1037         }
1038         CP_FM_USR(&node_uuid, args->args_node_allocate.node_id_ptr, status, 1);
1039         if (status)
1040                 goto func_cont;
1041         /* Optional argument */
1042         if (args->args_node_allocate.attr_in) {
1043                 CP_FM_USR(&proc_attr_in, args->args_node_allocate.attr_in,
1044                           status, 1);
1045                 if (!status)
1046                         attr_in = &proc_attr_in;
1047                 else
1048                         status = -ENOMEM;
1049
1050         }
1051         if (!status) {
1052                 status = node_allocate(hprocessor,
1053                                        &node_uuid, (struct dsp_cbdata *)pargs,
1054                                        attr_in, &node_res, pr_ctxt);
1055         }
1056         if (!status) {
1057                 nodeid = node_res->id + 1;
1058                 CP_TO_USR(args->args_node_allocate.node, &nodeid,
1059                         status, 1);
1060                 if (status) {
1061                         status = -EFAULT;
1062                         node_delete(node_res, pr_ctxt);
1063                 }
1064         }
1065 func_cont:
1066         kfree(pargs);
1067
1068         return status;
1069 }
1070
1071 /*
1072  *  ======== nodewrap_alloc_msg_buf ========
1073  */
1074 u32 nodewrap_alloc_msg_buf(union trapped_args *args, void *pr_ctxt)
1075 {
1076         int status = 0;
1077         struct dsp_bufferattr *pattr = NULL;
1078         struct dsp_bufferattr attr;
1079         u8 *pbuffer = NULL;
1080         struct node_res_object *node_res;
1081
1082         find_node_handle(&node_res,  pr_ctxt,
1083                                 args->args_node_allocmsgbuf.node);
1084
1085         if (!node_res)
1086                 return -EFAULT;
1087
1088         if (!args->args_node_allocmsgbuf.size)
1089                 return -EINVAL;
1090
1091         if (args->args_node_allocmsgbuf.attr) { /* Optional argument */
1092                 CP_FM_USR(&attr, args->args_node_allocmsgbuf.attr, status, 1);
1093                 if (!status)
1094                         pattr = &attr;
1095
1096         }
1097         /* argument */
1098         CP_FM_USR(&pbuffer, args->args_node_allocmsgbuf.buffer, status, 1);
1099         if (!status) {
1100                 status = node_alloc_msg_buf(node_res->node,
1101                                             args->args_node_allocmsgbuf.size,
1102                                             pattr, &pbuffer);
1103         }
1104         CP_TO_USR(args->args_node_allocmsgbuf.buffer, &pbuffer, status, 1);
1105         return status;
1106 }
1107
1108 /*
1109  * ======== nodewrap_change_priority ========
1110  */
1111 u32 nodewrap_change_priority(union trapped_args *args, void *pr_ctxt)
1112 {
1113         u32 ret;
1114         struct node_res_object *node_res;
1115
1116         find_node_handle(&node_res, pr_ctxt,
1117                                 args->args_node_changepriority.node);
1118
1119         if (!node_res)
1120                 return -EFAULT;
1121
1122         ret = node_change_priority(node_res->node,
1123                                    args->args_node_changepriority.prio);
1124
1125         return ret;
1126 }
1127
1128 /*
1129  * ======== nodewrap_connect ========
1130  */
1131 u32 nodewrap_connect(union trapped_args *args, void *pr_ctxt)
1132 {
1133         int status = 0;
1134         struct dsp_strmattr attrs;
1135         struct dsp_strmattr *pattrs = NULL;
1136         u32 cb_data_size;
1137         u32 __user *psize = (u32 __user *) args->args_node_connect.conn_param;
1138         u8 *pargs = NULL;
1139         struct node_res_object *node_res1, *node_res2;
1140         struct node_object *node1 = NULL, *node2 = NULL;
1141
1142         if ((int)args->args_node_connect.node != DSP_HGPPNODE) {
1143                 find_node_handle(&node_res1, pr_ctxt,
1144                                 args->args_node_connect.node);
1145                 if (node_res1)
1146                         node1 = node_res1->node;
1147         } else {
1148                 node1 = args->args_node_connect.node;
1149         }
1150
1151         if ((int)args->args_node_connect.other_node != DSP_HGPPNODE) {
1152                 find_node_handle(&node_res2, pr_ctxt,
1153                                 args->args_node_connect.other_node);
1154                 if (node_res2)
1155                         node2 = node_res2->node;
1156         } else {
1157                 node2 = args->args_node_connect.other_node;
1158         }
1159
1160         if (!node1 || !node2)
1161                 return -EFAULT;
1162
1163         /* Optional argument */
1164         if (psize) {
1165                 if (get_user(cb_data_size, psize))
1166                         status = -EPERM;
1167
1168                 cb_data_size += sizeof(u32);
1169                 if (!status) {
1170                         pargs = kmalloc(cb_data_size, GFP_KERNEL);
1171                         if (pargs == NULL) {
1172                                 status = -ENOMEM;
1173                                 goto func_cont;
1174                         }
1175
1176                 }
1177                 CP_FM_USR(pargs, args->args_node_connect.conn_param, status,
1178                           cb_data_size);
1179                 if (status)
1180                         goto func_cont;
1181         }
1182         if (args->args_node_connect.attrs) {    /* Optional argument */
1183                 CP_FM_USR(&attrs, args->args_node_connect.attrs, status, 1);
1184                 if (!status)
1185                         pattrs = &attrs;
1186
1187         }
1188         if (!status) {
1189                 status = node_connect(node1,
1190                                       args->args_node_connect.stream_id,
1191                                       node2,
1192                                       args->args_node_connect.other_stream,
1193                                       pattrs, (struct dsp_cbdata *)pargs);
1194         }
1195 func_cont:
1196         kfree(pargs);
1197
1198         return status;
1199 }
1200
1201 /*
1202  * ======== nodewrap_create ========
1203  */
1204 u32 nodewrap_create(union trapped_args *args, void *pr_ctxt)
1205 {
1206         u32 ret;
1207         struct node_res_object *node_res;
1208
1209         find_node_handle(&node_res, pr_ctxt, args->args_node_create.node);
1210
1211         if (!node_res)
1212                 return -EFAULT;
1213
1214         ret = node_create(node_res->node);
1215
1216         return ret;
1217 }
1218
1219 /*
1220  * ======== nodewrap_delete ========
1221  */
1222 u32 nodewrap_delete(union trapped_args *args, void *pr_ctxt)
1223 {
1224         u32 ret;
1225         struct node_res_object *node_res;
1226
1227         find_node_handle(&node_res, pr_ctxt, args->args_node_delete.node);
1228
1229         if (!node_res)
1230                 return -EFAULT;
1231
1232         ret = node_delete(node_res, pr_ctxt);
1233
1234         return ret;
1235 }
1236
1237 /*
1238  *  ======== nodewrap_free_msg_buf ========
1239  */
1240 u32 nodewrap_free_msg_buf(union trapped_args *args, void *pr_ctxt)
1241 {
1242         int status = 0;
1243         struct dsp_bufferattr *pattr = NULL;
1244         struct dsp_bufferattr attr;
1245         struct node_res_object *node_res;
1246
1247         find_node_handle(&node_res, pr_ctxt, args->args_node_freemsgbuf.node);
1248
1249         if (!node_res)
1250                 return -EFAULT;
1251
1252         if (args->args_node_freemsgbuf.attr) {  /* Optional argument */
1253                 CP_FM_USR(&attr, args->args_node_freemsgbuf.attr, status, 1);
1254                 if (!status)
1255                         pattr = &attr;
1256
1257         }
1258
1259         if (!args->args_node_freemsgbuf.buffer)
1260                 return -EFAULT;
1261
1262         if (!status) {
1263                 status = node_free_msg_buf(node_res->node,
1264                                            args->args_node_freemsgbuf.buffer,
1265                                            pattr);
1266         }
1267
1268         return status;
1269 }
1270
1271 /*
1272  * ======== nodewrap_get_attr ========
1273  */
1274 u32 nodewrap_get_attr(union trapped_args *args, void *pr_ctxt)
1275 {
1276         int status = 0;
1277         struct dsp_nodeattr attr;
1278         struct node_res_object *node_res;
1279
1280         find_node_handle(&node_res, pr_ctxt, args->args_node_getattr.node);
1281
1282         if (!node_res)
1283                 return -EFAULT;
1284
1285         status = node_get_attr(node_res->node, &attr,
1286                                args->args_node_getattr.attr_size);
1287         CP_TO_USR(args->args_node_getattr.attr, &attr, status, 1);
1288
1289         return status;
1290 }
1291
1292 /*
1293  * ======== nodewrap_get_message ========
1294  */
1295 u32 nodewrap_get_message(union trapped_args *args, void *pr_ctxt)
1296 {
1297         int status;
1298         struct dsp_msg msg;
1299         struct node_res_object *node_res;
1300
1301         find_node_handle(&node_res, pr_ctxt, args->args_node_getmessage.node);
1302
1303         if (!node_res)
1304                 return -EFAULT;
1305
1306         status = node_get_message(node_res->node, &msg,
1307                                   args->args_node_getmessage.timeout);
1308
1309         CP_TO_USR(args->args_node_getmessage.message, &msg, status, 1);
1310
1311         return status;
1312 }
1313
1314 /*
1315  * ======== nodewrap_pause ========
1316  */
1317 u32 nodewrap_pause(union trapped_args *args, void *pr_ctxt)
1318 {
1319         u32 ret;
1320         struct node_res_object *node_res;
1321
1322         find_node_handle(&node_res, pr_ctxt, args->args_node_pause.node);
1323
1324         if (!node_res)
1325                 return -EFAULT;
1326
1327         ret = node_pause(node_res->node);
1328
1329         return ret;
1330 }
1331
1332 /*
1333  * ======== nodewrap_put_message ========
1334  */
1335 u32 nodewrap_put_message(union trapped_args *args, void *pr_ctxt)
1336 {
1337         int status = 0;
1338         struct dsp_msg msg;
1339         struct node_res_object *node_res;
1340
1341         find_node_handle(&node_res, pr_ctxt, args->args_node_putmessage.node);
1342
1343         if (!node_res)
1344                 return -EFAULT;
1345
1346         CP_FM_USR(&msg, args->args_node_putmessage.message, status, 1);
1347
1348         if (!status) {
1349                 status =
1350                     node_put_message(node_res->node, &msg,
1351                                      args->args_node_putmessage.timeout);
1352         }
1353
1354         return status;
1355 }
1356
1357 /*
1358  * ======== nodewrap_register_notify ========
1359  */
1360 u32 nodewrap_register_notify(union trapped_args *args, void *pr_ctxt)
1361 {
1362         int status = 0;
1363         struct dsp_notification notification;
1364         struct node_res_object *node_res;
1365
1366         find_node_handle(&node_res, pr_ctxt,
1367                         args->args_node_registernotify.node);
1368
1369         if (!node_res)
1370                 return -EFAULT;
1371
1372         /* Initialize the notification data structure */
1373         notification.name = NULL;
1374         notification.handle = NULL;
1375
1376         if (!args->args_proc_register_notify.event_mask)
1377                 CP_FM_USR(&notification,
1378                           args->args_proc_register_notify.notification,
1379                           status, 1);
1380
1381         status = node_register_notify(node_res->node,
1382                                       args->args_node_registernotify.event_mask,
1383                                       args->args_node_registernotify.
1384                                       notify_type, &notification);
1385         CP_TO_USR(args->args_node_registernotify.notification, &notification,
1386                   status, 1);
1387         return status;
1388 }
1389
1390 /*
1391  * ======== nodewrap_run ========
1392  */
1393 u32 nodewrap_run(union trapped_args *args, void *pr_ctxt)
1394 {
1395         u32 ret;
1396         struct node_res_object *node_res;
1397
1398         find_node_handle(&node_res, pr_ctxt, args->args_node_run.node);
1399
1400         if (!node_res)
1401                 return -EFAULT;
1402
1403         ret = node_run(node_res->node);
1404
1405         return ret;
1406 }
1407
1408 /*
1409  * ======== nodewrap_terminate ========
1410  */
1411 u32 nodewrap_terminate(union trapped_args *args, void *pr_ctxt)
1412 {
1413         int status;
1414         int tempstatus;
1415         struct node_res_object *node_res;
1416
1417         find_node_handle(&node_res, pr_ctxt, args->args_node_terminate.node);
1418
1419         if (!node_res)
1420                 return -EFAULT;
1421
1422         status = node_terminate(node_res->node, &tempstatus);
1423
1424         CP_TO_USR(args->args_node_terminate.status, &tempstatus, status, 1);
1425
1426         return status;
1427 }
1428
1429 /*
1430  * ======== nodewrap_get_uuid_props ========
1431  */
1432 u32 nodewrap_get_uuid_props(union trapped_args *args, void *pr_ctxt)
1433 {
1434         int status = 0;
1435         struct dsp_uuid node_uuid;
1436         struct dsp_ndbprops *pnode_props = NULL;
1437         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
1438
1439         CP_FM_USR(&node_uuid, args->args_node_getuuidprops.node_id_ptr, status,
1440                   1);
1441         if (status)
1442                 goto func_cont;
1443         pnode_props = kmalloc(sizeof(struct dsp_ndbprops), GFP_KERNEL);
1444         if (pnode_props != NULL) {
1445                 status =
1446                     node_get_uuid_props(hprocessor, &node_uuid, pnode_props);
1447                 CP_TO_USR(args->args_node_getuuidprops.node_props, pnode_props,
1448                           status, 1);
1449         } else
1450                 status = -ENOMEM;
1451 func_cont:
1452         kfree(pnode_props);
1453         return status;
1454 }
1455
1456 /*
1457  * ======== find_strm_handle =========
1458  */
1459 inline void find_strm_handle(struct strm_res_object **strmres,
1460                                 void *pr_ctxt, void *hstream)
1461 {
1462         rcu_read_lock();
1463         *strmres = idr_find(((struct process_context *)pr_ctxt)->stream_id,
1464                                                         (int)hstream - 1);
1465         rcu_read_unlock();
1466         return;
1467 }
1468
1469 /*
1470  * ======== strmwrap_allocate_buffer ========
1471  */
1472 u32 strmwrap_allocate_buffer(union trapped_args *args, void *pr_ctxt)
1473 {
1474         int status;
1475         u8 **ap_buffer = NULL;
1476         u32 num_bufs = args->args_strm_allocatebuffer.num_bufs;
1477         struct strm_res_object *strm_res;
1478
1479         find_strm_handle(&strm_res, pr_ctxt,
1480                 args->args_strm_allocatebuffer.stream);
1481
1482         if (!strm_res)
1483                 return -EFAULT;
1484
1485         if (num_bufs > MAX_BUFS)
1486                 return -EINVAL;
1487
1488         ap_buffer = kmalloc((num_bufs * sizeof(u8 *)), GFP_KERNEL);
1489         if (ap_buffer == NULL)
1490                 return -ENOMEM;
1491
1492         status = strm_allocate_buffer(strm_res,
1493                                       args->args_strm_allocatebuffer.size,
1494                                       ap_buffer, num_bufs, pr_ctxt);
1495         if (!status) {
1496                 CP_TO_USR(args->args_strm_allocatebuffer.ap_buffer, ap_buffer,
1497                           status, num_bufs);
1498                 if (status) {
1499                         status = -EFAULT;
1500                         strm_free_buffer(strm_res,
1501                                          ap_buffer, num_bufs, pr_ctxt);
1502                 }
1503         }
1504         kfree(ap_buffer);
1505
1506         return status;
1507 }
1508
1509 /*
1510  * ======== strmwrap_close ========
1511  */
1512 u32 strmwrap_close(union trapped_args *args, void *pr_ctxt)
1513 {
1514         struct strm_res_object *strm_res;
1515
1516         find_strm_handle(&strm_res, pr_ctxt, args->args_strm_close.stream);
1517
1518         if (!strm_res)
1519                 return -EFAULT;
1520
1521         return strm_close(strm_res, pr_ctxt);
1522 }
1523
1524 /*
1525  * ======== strmwrap_free_buffer ========
1526  */
1527 u32 strmwrap_free_buffer(union trapped_args *args, void *pr_ctxt)
1528 {
1529         int status = 0;
1530         u8 **ap_buffer = NULL;
1531         u32 num_bufs = args->args_strm_freebuffer.num_bufs;
1532         struct strm_res_object *strm_res;
1533
1534         find_strm_handle(&strm_res, pr_ctxt,
1535                         args->args_strm_freebuffer.stream);
1536
1537         if (!strm_res)
1538                 return -EFAULT;
1539
1540         if (num_bufs > MAX_BUFS)
1541                 return -EINVAL;
1542
1543         ap_buffer = kmalloc((num_bufs * sizeof(u8 *)), GFP_KERNEL);
1544         if (ap_buffer == NULL)
1545                 return -ENOMEM;
1546
1547         CP_FM_USR(ap_buffer, args->args_strm_freebuffer.ap_buffer, status,
1548                   num_bufs);
1549
1550         if (!status)
1551                 status = strm_free_buffer(strm_res,
1552                                           ap_buffer, num_bufs, pr_ctxt);
1553
1554         CP_TO_USR(args->args_strm_freebuffer.ap_buffer, ap_buffer, status,
1555                   num_bufs);
1556         kfree(ap_buffer);
1557
1558         return status;
1559 }
1560
1561 /*
1562  * ======== strmwrap_get_event_handle ========
1563  */
1564 u32 __deprecated strmwrap_get_event_handle(union trapped_args * args,
1565                                            void *pr_ctxt)
1566 {
1567         pr_err("%s: deprecated dspbridge ioctl\n", __func__);
1568         return -ENOSYS;
1569 }
1570
1571 /*
1572  * ======== strmwrap_get_info ========
1573  */
1574 u32 strmwrap_get_info(union trapped_args *args, void *pr_ctxt)
1575 {
1576         int status = 0;
1577         struct stream_info strm_info;
1578         struct dsp_streaminfo user;
1579         struct dsp_streaminfo *temp;
1580         struct strm_res_object *strm_res;
1581
1582         find_strm_handle(&strm_res, pr_ctxt,
1583                         args->args_strm_getinfo.stream);
1584
1585         if (!strm_res)
1586                 return -EFAULT;
1587
1588         CP_FM_USR(&strm_info, args->args_strm_getinfo.stream_info, status, 1);
1589         temp = strm_info.user_strm;
1590
1591         strm_info.user_strm = &user;
1592
1593         if (!status) {
1594                 status = strm_get_info(strm_res->stream,
1595                                        &strm_info,
1596                                        args->args_strm_getinfo.
1597                                        stream_info_size);
1598         }
1599         CP_TO_USR(temp, strm_info.user_strm, status, 1);
1600         strm_info.user_strm = temp;
1601         CP_TO_USR(args->args_strm_getinfo.stream_info, &strm_info, status, 1);
1602         return status;
1603 }
1604
1605 /*
1606  * ======== strmwrap_idle ========
1607  */
1608 u32 strmwrap_idle(union trapped_args *args, void *pr_ctxt)
1609 {
1610         u32 ret;
1611         struct strm_res_object *strm_res;
1612
1613         find_strm_handle(&strm_res, pr_ctxt, args->args_strm_idle.stream);
1614
1615         if (!strm_res)
1616                 return -EFAULT;
1617
1618         ret = strm_idle(strm_res->stream, args->args_strm_idle.flush_flag);
1619
1620         return ret;
1621 }
1622
1623 /*
1624  * ======== strmwrap_issue ========
1625  */
1626 u32 strmwrap_issue(union trapped_args *args, void *pr_ctxt)
1627 {
1628         int status = 0;
1629         struct strm_res_object *strm_res;
1630
1631         find_strm_handle(&strm_res, pr_ctxt, args->args_strm_issue.stream);
1632
1633         if (!strm_res)
1634                 return -EFAULT;
1635
1636         if (!args->args_strm_issue.buffer)
1637                 return -EFAULT;
1638
1639         /* No need of doing CP_FM_USR for the user buffer (pbuffer)
1640            as this is done in Bridge internal function bridge_chnl_add_io_req
1641            in chnl_sm.c */
1642         status = strm_issue(strm_res->stream,
1643                             args->args_strm_issue.buffer,
1644                             args->args_strm_issue.bytes,
1645                             args->args_strm_issue.buf_size,
1646                             args->args_strm_issue.arg);
1647
1648         return status;
1649 }
1650
1651 /*
1652  * ======== strmwrap_open ========
1653  */
1654 u32 strmwrap_open(union trapped_args *args, void *pr_ctxt)
1655 {
1656         int status = 0;
1657         struct strm_attr attr;
1658         struct strm_res_object *strm_res_obj;
1659         struct dsp_streamattrin strm_attr_in;
1660         struct node_res_object *node_res;
1661         int strmid;
1662
1663         find_node_handle(&node_res, pr_ctxt, args->args_strm_open.node);
1664
1665         if (!node_res)
1666                 return -EFAULT;
1667
1668         CP_FM_USR(&attr, args->args_strm_open.attr_in, status, 1);
1669
1670         if (attr.stream_attr_in != NULL) {      /* Optional argument */
1671                 CP_FM_USR(&strm_attr_in, attr.stream_attr_in, status, 1);
1672                 if (!status) {
1673                         attr.stream_attr_in = &strm_attr_in;
1674                         if (attr.stream_attr_in->strm_mode == STRMMODE_LDMA)
1675                                 return -ENOSYS;
1676                 }
1677
1678         }
1679         status = strm_open(node_res->node,
1680                            args->args_strm_open.direction,
1681                            args->args_strm_open.index, &attr, &strm_res_obj,
1682                            pr_ctxt);
1683         if (!status) {
1684                 strmid = strm_res_obj->id + 1;
1685                 CP_TO_USR(args->args_strm_open.stream, &strmid, status, 1);
1686         }
1687         return status;
1688 }
1689
1690 /*
1691  * ======== strmwrap_reclaim ========
1692  */
1693 u32 strmwrap_reclaim(union trapped_args *args, void *pr_ctxt)
1694 {
1695         int status = 0;
1696         u8 *buf_ptr;
1697         u32 ul_bytes;
1698         u32 dw_arg;
1699         u32 ul_buf_size;
1700         struct strm_res_object *strm_res;
1701
1702         find_strm_handle(&strm_res, pr_ctxt, args->args_strm_reclaim.stream);
1703
1704         if (!strm_res)
1705                 return -EFAULT;
1706
1707         status = strm_reclaim(strm_res->stream, &buf_ptr,
1708                               &ul_bytes, &ul_buf_size, &dw_arg);
1709         CP_TO_USR(args->args_strm_reclaim.buf_ptr, &buf_ptr, status, 1);
1710         CP_TO_USR(args->args_strm_reclaim.bytes, &ul_bytes, status, 1);
1711         CP_TO_USR(args->args_strm_reclaim.arg, &dw_arg, status, 1);
1712
1713         if (args->args_strm_reclaim.buf_size_ptr != NULL) {
1714                 CP_TO_USR(args->args_strm_reclaim.buf_size_ptr, &ul_buf_size,
1715                           status, 1);
1716         }
1717
1718         return status;
1719 }
1720
1721 /*
1722  * ======== strmwrap_register_notify ========
1723  */
1724 u32 strmwrap_register_notify(union trapped_args *args, void *pr_ctxt)
1725 {
1726         int status = 0;
1727         struct dsp_notification notification;
1728         struct strm_res_object *strm_res;
1729
1730         find_strm_handle(&strm_res, pr_ctxt,
1731                         args->args_strm_registernotify.stream);
1732
1733         if (!strm_res)
1734                 return -EFAULT;
1735
1736         /* Initialize the notification data structure */
1737         notification.name = NULL;
1738         notification.handle = NULL;
1739
1740         status = strm_register_notify(strm_res->stream,
1741                                       args->args_strm_registernotify.event_mask,
1742                                       args->args_strm_registernotify.
1743                                       notify_type, &notification);
1744         CP_TO_USR(args->args_strm_registernotify.notification, &notification,
1745                   status, 1);
1746
1747         return status;
1748 }
1749
1750 /*
1751  * ======== strmwrap_select ========
1752  */
1753 u32 strmwrap_select(union trapped_args *args, void *pr_ctxt)
1754 {
1755         u32 mask;
1756         struct strm_object *strm_tab[MAX_STREAMS];
1757         int status = 0;
1758         struct strm_res_object *strm_res;
1759         int *ids[MAX_STREAMS];
1760         int i;
1761
1762         if (args->args_strm_select.strm_num > MAX_STREAMS)
1763                 return -EINVAL;
1764
1765         CP_FM_USR(ids, args->args_strm_select.stream_tab, status,
1766                 args->args_strm_select.strm_num);
1767
1768         if (status)
1769                 return status;
1770
1771         for (i = 0; i < args->args_strm_select.strm_num; i++) {
1772                 find_strm_handle(&strm_res, pr_ctxt, ids[i]);
1773
1774                 if (!strm_res)
1775                         return -EFAULT;
1776
1777                 strm_tab[i] = strm_res->stream;
1778         }
1779
1780         if (!status) {
1781                 status = strm_select(strm_tab, args->args_strm_select.strm_num,
1782                                      &mask, args->args_strm_select.timeout);
1783         }
1784         CP_TO_USR(args->args_strm_select.mask, &mask, status, 1);
1785         return status;
1786 }
1787
1788 /* CMM */
1789
1790 /*
1791  * ======== cmmwrap_calloc_buf ========
1792  */
1793 u32 __deprecated cmmwrap_calloc_buf(union trapped_args * args, void *pr_ctxt)
1794 {
1795         /* This operation is done in kernel */
1796         pr_err("%s: deprecated dspbridge ioctl\n", __func__);
1797         return -ENOSYS;
1798 }
1799
1800 /*
1801  * ======== cmmwrap_free_buf ========
1802  */
1803 u32 __deprecated cmmwrap_free_buf(union trapped_args * args, void *pr_ctxt)
1804 {
1805         /* This operation is done in kernel */
1806         pr_err("%s: deprecated dspbridge ioctl\n", __func__);
1807         return -ENOSYS;
1808 }
1809
1810 /*
1811  * ======== cmmwrap_get_handle ========
1812  */
1813 u32 cmmwrap_get_handle(union trapped_args *args, void *pr_ctxt)
1814 {
1815         int status = 0;
1816         struct cmm_object *hcmm_mgr;
1817         void *hprocessor = ((struct process_context *)pr_ctxt)->processor;
1818
1819         status = cmm_get_handle(hprocessor, &hcmm_mgr);
1820
1821         CP_TO_USR(args->args_cmm_gethandle.cmm_mgr, &hcmm_mgr, status, 1);
1822
1823         return status;
1824 }
1825
1826 /*
1827  * ======== cmmwrap_get_info ========
1828  */
1829 u32 cmmwrap_get_info(union trapped_args *args, void *pr_ctxt)
1830 {
1831         int status = 0;
1832         struct cmm_info cmm_info_obj;
1833
1834         status = cmm_get_info(args->args_cmm_getinfo.cmm_mgr, &cmm_info_obj);
1835
1836         CP_TO_USR(args->args_cmm_getinfo.cmm_info_obj, &cmm_info_obj, status,
1837                   1);
1838
1839         return status;
1840 }