static struct chnl_irp *make_new_chirp(void);
 
 static int search_free_channel(struct chnl_mgr *chnl_mgr_obj,
-                                     OUT u32 *chnl);
+                                     u32 *chnl);
 
 /*
  *  ======== bridge_chnl_add_io_req ========
  *      Create a channel manager object, responsible for opening new channels
  *      and closing old ones for a given board.
  */
-int bridge_chnl_create(OUT struct chnl_mgr **channel_mgr,
+int bridge_chnl_create(struct chnl_mgr **channel_mgr,
                              struct dev_object *hdev_obj,
                              const struct chnl_mgrattrs *mgr_attrts)
 {
  *      Retrieve information related to a channel.
  */
 int bridge_chnl_get_info(struct chnl_object *chnl_obj,
-                            OUT struct chnl_info *channel_info)
+                            struct chnl_info *channel_info)
 {
        int status = 0;
        struct chnl_object *pchnl = (struct chnl_object *)chnl_obj;
  *      Note: Ensures Channel Invariant (see notes above).
  */
 int bridge_chnl_get_ioc(struct chnl_object *chnl_obj, u32 timeout,
-                           OUT struct chnl_ioc *chan_ioc)
+                           struct chnl_ioc *chan_ioc)
 {
        int status = 0;
        struct chnl_object *pchnl = (struct chnl_object *)chnl_obj;
  *      Retrieve information related to the channel manager.
  */
 int bridge_chnl_get_mgr_info(struct chnl_mgr *hchnl_mgr, u32 ch_id,
-                                OUT struct chnl_mgrinfo *mgr_info)
+                                struct chnl_mgrinfo *mgr_info)
 {
        int status = 0;
        struct chnl_mgr *chnl_mgr_obj = (struct chnl_mgr *)hchnl_mgr;
  *  ======== bridge_chnl_open ========
  *      Open a new half-duplex channel to the DSP board.
  */
-int bridge_chnl_open(OUT struct chnl_object **chnl,
+int bridge_chnl_open(struct chnl_object **chnl,
                            struct chnl_mgr *hchnl_mgr, s8 chnl_mode,
                            u32 ch_id, const struct chnl_attr *pattrs)
 {
  *      Search for a free channel slot in the array of channel pointers.
  */
 static int search_free_channel(struct chnl_mgr *chnl_mgr_obj,
-                                     OUT u32 *chnl)
+                                     u32 *chnl)
 {
        int status = -ENOSR;
        u32 i;
 
 
 /* Function Prototypes */
 static void io_dispatch_chnl(struct io_mgr *pio_mgr,
-                               OUT struct chnl_object *pchnl, u8 io_mode);
+                               struct chnl_object *pchnl, u8 io_mode);
 static void io_dispatch_msg(struct io_mgr *pio_mgr,
                            struct msg_mgr *hmsg_mgr);
 static void io_dispatch_pm(struct io_mgr *pio_mgr);
  *  ======== bridge_io_create ========
  *      Create an IO manager object.
  */
-int bridge_io_create(OUT struct io_mgr **io_man,
+int bridge_io_create(struct io_mgr **io_man,
                            struct dev_object *hdev_obj,
                            const struct io_attrs *mgr_attrts)
 {
  *      Proc-copy chanl dispatch.
  */
 static void io_dispatch_chnl(struct io_mgr *pio_mgr,
-                               OUT struct chnl_object *pchnl, u8 io_mode)
+                               struct chnl_object *pchnl, u8 io_mode)
 {
        if (!pio_mgr)
                goto func_end;
  *      out the dispatch of I/O as a non-preemptible event.It can only be
  *      pre-empted      by an ISR.
  */
-void io_dpc(OUT unsigned long ref_data)
+void io_dpc(unsigned long ref_data)
 {
        struct io_mgr *pio_mgr = (struct io_mgr *)ref_data;
        struct chnl_mgr *chnl_mgr_obj;
  *      interrupts the DSP.
  */
 void io_request_chnl(struct io_mgr *io_manager, struct chnl_object *pchnl,
-                       u8 io_mode, OUT u16 *mbx_val)
+                       u8 io_mode, u16 *mbx_val)
 {
        struct chnl_mgr *chnl_mgr_obj;
        struct shm *sm;
  *      Gets the Processor's Load information
  */
 int bridge_io_get_proc_load(struct io_mgr *hio_mgr,
-                               OUT struct dsp_procloadstat *proc_lstat)
+                               struct dsp_procloadstat *proc_lstat)
 {
        proc_lstat->curr_load =
                        hio_mgr->shared_mem->load_mon_info.curr_dsp_load;
 
  *      Create an object to manage message queues. Only one of these objects
  *      can exist per device object.
  */
-int bridge_msg_create(OUT struct msg_mgr **msg_man,
+int bridge_msg_create(struct msg_mgr **msg_man,
                             struct dev_object *hdev_obj,
                             msg_onexit msg_callback)
 {
  *      on the DSP.
  */
 int bridge_msg_create_queue(struct msg_mgr *hmsg_mgr,
-                               OUT struct msg_queue **msgq,
+                               struct msg_queue **msgq,
                                u32 msgq_id, u32 max_msgs, void *arg)
 {
        u32 i;
 
 /* Forward Declarations: */
 static int bridge_brd_monitor(struct bridge_dev_context *dev_ctxt);
 static int bridge_brd_read(struct bridge_dev_context *dev_ctxt,
-                                 OUT u8 *host_buff,
+                                 u8 *host_buff,
                                  u32 dsp_addr, u32 ul_num_bytes,
                                  u32 mem_type);
 static int bridge_brd_start(struct bridge_dev_context *dev_ctxt,
                                  struct page **mapped_pages);
 static int bridge_brd_mem_un_map(struct bridge_dev_context *dev_ctxt,
                                     u32 virt_addr, u32 ul_num_bytes);
-static int bridge_dev_create(OUT struct bridge_dev_context
+static int bridge_dev_create(struct bridge_dev_context
                                        **dev_cntxt,
                                        struct dev_object *hdev_obj,
                                        struct cfg_hostres *config_param);
 static int bridge_dev_ctrl(struct bridge_dev_context *dev_context,
-                                 u32 dw_cmd, OUT void *pargs);
+                                 u32 dw_cmd, void *pargs);
 static int bridge_dev_destroy(struct bridge_dev_context *dev_ctxt);
 static u32 user_va2_pa(struct mm_struct *mm, u32 address);
 static int pte_update(struct bridge_dev_context *dev_ctxt, u32 pa,
  *  purpose:
  *      Bridge Driver entry point.
  */
-void bridge_drv_entry(OUT struct bridge_drv_interface **drv_intf,
+void bridge_drv_entry(struct bridge_drv_interface **drv_intf,
                   const char *driver_file_name)
 {
 
  *      Reads buffers for DSP memory.
  */
 static int bridge_brd_read(struct bridge_dev_context *dev_ctxt,
-                                 OUT u8 *host_buff, u32 dsp_addr,
+                                 u8 *host_buff, u32 dsp_addr,
                                  u32 ul_num_bytes, u32 mem_type)
 {
        int status = 0;
  *  ======== bridge_dev_create ========
  *      Creates a driver object. Puts DSP in self loop.
  */
-static int bridge_dev_create(OUT struct bridge_dev_context
+static int bridge_dev_create(struct bridge_dev_context
                                        **dev_cntxt,
                                        struct dev_object *hdev_obj,
                                        struct cfg_hostres *config_param)
  *      Receives device specific commands.
  */
 static int bridge_dev_ctrl(struct bridge_dev_context *dev_context,
-                                 u32 dw_cmd, OUT void *pargs)
+                                 u32 dw_cmd, void *pargs)
 {
        int status = 0;
        struct bridge_ioctl_extproc *pa_ext_proc =
 
  *      Copies DSP external memory buffers to the host side buffers.
  */
 int read_ext_dsp_data(struct bridge_dev_context *dev_ctxt,
-                            OUT u8 *host_buff, u32 dsp_addr,
+                            u8 *host_buff, u32 dsp_addr,
                             u32 ul_num_bytes, u32 mem_type)
 {
        int status = 0;
 
  * is configured by the combination of DSP MMU and shm Memory manager in the CDB
  */
 extern int read_ext_dsp_data(struct bridge_dev_context *dev_ctxt,
-                                   OUT u8 *host_buff, u32 dsp_addr,
+                                   u8 *host_buff, u32 dsp_addr,
                                    u32 ul_num_bytes, u32 mem_type);
 
 /*
  *  ======== write_dsp_data ========
  */
 extern int write_dsp_data(struct bridge_dev_context *dev_context,
-                                OUT u8 *host_buff, u32 dsp_addr,
+                                u8 *host_buff, u32 dsp_addr,
                                 u32 ul_num_bytes, u32 mem_type);
 
 /*
 
  *      Note: snprintf format specifier is:
  *      %[flags] [width] [.precision] [{h | l | I64 | L}]type
  */
-void uuid_uuid_to_string(struct dsp_uuid *uuid_obj, OUT char *sz_uuid,
+void uuid_uuid_to_string(struct dsp_uuid *uuid_obj, char *sz_uuid,
                         s32 size)
 {
        s32 i;                  /* return result from snprintf. */
  *  Purpose:
  *      Converts a string to a struct dsp_uuid.
  */
-void uuid_uuid_from_string(char *sz_uuid, OUT struct dsp_uuid *uuid_obj)
+void uuid_uuid_from_string(char *sz_uuid, struct dsp_uuid *uuid_obj)
 {
        s32 j;
 
 
  *      0:        *auto_start contains autostart mask for this devnode.
  */
 extern int cfg_get_auto_start(struct cfg_devnode *dev_node_obj,
-                                    OUT u32 *auto_start);
+                                    u32 *auto_start);
 
 /*
  *  ======== cfg_get_cd_version ========
  *      0:    Success.
  *      else:       *version is NULL.
  */
-extern int cfg_get_cd_version(OUT u32 *version);
+extern int cfg_get_cd_version(u32 *version);
 
 /*
  *  ======== cfg_get_dev_object ========
  *      else:       *value is set to 0L.
  */
 extern int cfg_get_dev_object(struct cfg_devnode *dev_node_obj,
-                                    OUT u32 *value);
+                                    u32 *value);
 
 /*
  *  ======== cfg_get_exec_file ========
  *                  devnode.
  */
 extern int cfg_get_exec_file(struct cfg_devnode *dev_node_obj,
-                                   u32 buf_size, OUT char *str_exec_file);
+                                   u32 buf_size, char *str_exec_file);
 
 /*
  *  ======== cfg_get_object ========
  *      0:    *value is set to the retrieved u32(non-Zero).
  *      else:       *value is set to 0L.
  */
-extern int cfg_get_object(OUT u32 *value, u8 dw_type);
+extern int cfg_get_object(u32 *value, u8 dw_type);
 
 /*
  *  ======== cfg_get_perf_value ========
  *      enable_perf != NULL;
  *  Ensures:
  */
-extern void cfg_get_perf_value(OUT bool *enable_perf);
+extern void cfg_get_perf_value(bool *enable_perf);
 
 /*
  *  ======== cfg_get_zl_file ========
  *                  for this devnode.
  */
 extern int cfg_get_zl_file(struct cfg_devnode *dev_node_obj,
-                                 u32 buf_size, OUT char *str_zl_file_name);
+                                 u32 buf_size, char *str_zl_file_name);
 
 /*
  *  ======== cfg_init ========
 
  *                              board without an intervening call to
  *                              chnl_destroy() will fail.
  */
-extern int chnl_create(OUT struct chnl_mgr **channel_mgr,
+extern int chnl_create(struct chnl_mgr **channel_mgr,
                              struct dev_object *hdev_obj,
                              const struct chnl_mgrattrs *mgr_attrts);
 
 
  */
 extern void *cmm_calloc_buf(struct cmm_object *hcmm_mgr,
                            u32 usize, struct cmm_attrs *pattrs,
-                           OUT void **pp_buf_va);
+                           void **pp_buf_va);
 
 /*
  *  ======== cmm_create ========
  *  Ensures:
  *
  */
-extern int cmm_create(OUT struct cmm_object **ph_cmm_mgr,
+extern int cmm_create(struct cmm_object **ph_cmm_mgr,
                             struct dev_object *hdev_obj,
                             const struct cmm_mgrattrs *mgr_attrts);
 
  *  Ensures:
  */
 extern int cmm_get_handle(void *hprocessor,
-                                OUT struct cmm_object **ph_cmm_mgr);
+                                struct cmm_object **ph_cmm_mgr);
 
 /*
  *  ======== cmm_get_info ========
  *
  */
 extern int cmm_get_info(struct cmm_object *hcmm_mgr,
-                              OUT struct cmm_info *cmm_info_obj);
+                              struct cmm_info *cmm_info_obj);
 
 /*
  *  ======== cmm_init ========
  *  Ensures:
  *
  */
-extern int cmm_xlator_create(OUT struct cmm_xlatorobject **xlator,
+extern int cmm_xlator_create(struct cmm_xlatorobject **xlator,
                                    struct cmm_object *hcmm_mgr,
                                    struct cmm_xlatorattrs *xlator_attrs);
 
  *
  */
 extern int cmm_xlator_info(struct cmm_xlatorobject *xlator,
-                                 OUT u8 **paddr,
+                                 u8 **paddr,
                                  u32 ul_size, u32 segm_id, bool set_info);
 
 /*
 
  *      str_zl_file != NULL
  *  Ensures:
  */
-extern int cod_create(OUT struct cod_manager **mgr,
+extern int cod_create(struct cod_manager **mgr,
                             char *str_zl_file,
                             const struct cod_attrs *attrs);
 
  */
 extern int cod_get_section(struct cod_libraryobj *lib,
                                  char *str_sect,
-                                 OUT u32 *addr, OUT u32 *len);
+                                 u32 *addr, u32 *len);
 
 /*
  *  ======== cod_get_sym_value ========
  *  Ensures:
  */
 extern int cod_get_sym_value(struct cod_manager *cod_mgr_obj,
-                                   char *str_sym, OUT u32 * pul_value);
+                                   char *str_sym, u32 * pul_value);
 
 /*
  *  ======== cod_init ========
  */
 extern int cod_open(struct cod_manager *hmgr,
                           char *sz_coff_path,
-                          u32 flags, OUT struct cod_libraryobj **lib_obj);
+                          u32 flags, struct cod_libraryobj **lib_obj);
 
 /*
  *  ======== cod_open_base ========
  */
 extern int cod_read_section(struct cod_libraryobj *lib,
                                   char *str_sect,
-                                  OUT char *str_content, u32 content_size);
+                                  char *str_content, u32 content_size);
 
 #endif /* COD_ */
 
  *      A DCD manager handle is created.
  */
 extern int dcd_create_manager(char *sz_zl_dll_name,
-                                    OUT struct dcd_manager **dcd_mgr);
+                                    struct dcd_manager **dcd_mgr);
 
 /*
  *  ======== dcd_destroy_manager ========
  */
 extern int dcd_enumerate_object(s32 index,
                                       enum dsp_dcdobjtype obj_type,
-                                      OUT struct dsp_uuid *uuid_obj);
+                                      struct dsp_uuid *uuid_obj);
 
 /*
  *  ======== dcd_exit ========
 extern int dcd_get_dep_libs(struct dcd_manager *hdcd_mgr,
                                   struct dsp_uuid *uuid_obj,
                                   u16 num_libs,
-                                  OUT struct dsp_uuid *dep_lib_uuids,
-                                  OUT bool *prstnt_dep_libs,
+                                  struct dsp_uuid *dep_lib_uuids,
+                                  bool *prstnt_dep_libs,
                                   enum nldr_phase phase);
 
 /*
  */
 extern int dcd_get_num_dep_libs(struct dcd_manager *hdcd_mgr,
                                       struct dsp_uuid *uuid_obj,
-                                      OUT u16 *num_libs,
-                                      OUT u16 *num_pers_libs,
+                                      u16 *num_libs,
+                                      u16 *num_pers_libs,
                                       enum nldr_phase phase);
 
 /*
  */
 extern int dcd_get_library_name(struct dcd_manager *hdcd_mgr,
                                       struct dsp_uuid *uuid_obj,
-                                      OUT char *str_lib_name,
-                                      OUT u32 *buff_size,
+                                      char *str_lib_name,
+                                      u32 *buff_size,
                                       enum nldr_phase phase,
-                                      OUT bool *phase_split);
+                                      bool *phase_split);
 
 /*
  *  ======== dcd_get_object_def ========
 extern int dcd_get_object_def(struct dcd_manager *hdcd_mgr,
                                     struct dsp_uuid *obj_uuid,
                                     enum dsp_dcdobjtype obj_type,
-                                    OUT struct dcd_genericobj *obj_def);
+                                    struct dcd_genericobj *obj_def);
 
 /*
  *  ======== dcd_get_objects ========
 
  *      Otherwise, does not create the device object, ensures the Bridge driver
  *      module is unloaded, and sets *device_obj to NULL.
  */
-extern int dev_create_device(OUT struct dev_object
+extern int dev_create_device(struct dev_object
                                    **device_obj,
                                    const char *driver_file_name,
                                    struct cfg_devnode *dev_node_obj);
  *      Otherwise, does not create the device object, ensures the Bridge driver
  *      module is unloaded, and sets *device_obj to NULL.
  */
-extern int dev_create_iva_device(OUT struct dev_object
+extern int dev_create_iva_device(struct dev_object
                                        **device_obj,
                                        const char *driver_file_name,
                                        const struct cfg_hostres
  *      else:           *mgr is NULL.
  */
 extern int dev_get_chnl_mgr(struct dev_object *hdev_obj,
-                                  OUT struct chnl_mgr **mgr);
+                                  struct chnl_mgr **mgr);
 
 /*
  *  ======== dev_get_cmm_mgr ========
  *      else:           *mgr is NULL.
  */
 extern int dev_get_cmm_mgr(struct dev_object *hdev_obj,
-                                 OUT struct cmm_object **mgr);
+                                 struct cmm_object **mgr);
 
 /*
  *  ======== dev_get_dmm_mgr ========
  *      else:           *mgr is NULL.
  */
 extern int dev_get_dmm_mgr(struct dev_object *hdev_obj,
-                                 OUT struct dmm_object **mgr);
+                                 struct dmm_object **mgr);
 
 /*
  *  ======== dev_get_cod_mgr ========
  *      else:           *cod_mgr is NULL.
  */
 extern int dev_get_cod_mgr(struct dev_object *hdev_obj,
-                                 OUT struct cod_manager **cod_mgr);
+                                 struct cod_manager **cod_mgr);
 
 /*
  *  ======== dev_get_deh_mgr ========
  *      else:       *deh_manager is NULL.
  */
 extern int dev_get_deh_mgr(struct dev_object *hdev_obj,
-                                 OUT struct deh_mgr **deh_manager);
+                                 struct deh_mgr **deh_manager);
 
 /*
  *  ======== dev_get_dev_node ========
  *      else:           *dev_nde is NULL.
  */
 extern int dev_get_dev_node(struct dev_object *hdev_obj,
-                                  OUT struct cfg_devnode **dev_nde);
+                                  struct cfg_devnode **dev_nde);
 
 /*
  *  ======== dev_get_dev_type ========
  *      else:           *if_fxns is NULL.
  */
 extern int dev_get_intf_fxns(struct dev_object *hdev_obj,
-                           OUT struct bridge_drv_interface **if_fxns);
+                           struct bridge_drv_interface **if_fxns);
 
 /*
  *  ======== dev_get_io_mgr ========
  *      else:           *mgr is NULL.
  */
 extern int dev_get_io_mgr(struct dev_object *hdev_obj,
-                                OUT struct io_mgr **mgr);
+                                struct io_mgr **mgr);
 
 /*
  *  ======== dev_get_next ========
  *  Ensures:
  */
 extern void dev_get_msg_mgr(struct dev_object *hdev_obj,
-                           OUT struct msg_mgr **msg_man);
+                           struct msg_mgr **msg_man);
 
 /*
  *  ========= dev_get_node_manager ========
  */
 extern int dev_get_node_manager(struct dev_object
                                       *hdev_obj,
-                                      OUT struct node_mgr **node_man);
+                                      struct node_mgr **node_man);
 
 /*
  *  ======== dev_get_symbol ========
  *      0:        *pul_value contains the symbol value;
  */
 extern int dev_get_symbol(struct dev_object *hdev_obj,
-                                const char *str_sym, OUT u32 * pul_value);
+                                const char *str_sym, u32 * pul_value);
 
 /*
  *  ======== dev_get_bridge_context ========
  *      else:           *phbridge_context is NULL;
  */
 extern int dev_get_bridge_context(struct dev_object *hdev_obj,
-                                     OUT struct bridge_dev_context
+                                     struct bridge_dev_context
                                      **phbridge_context);
 
 /*
 extern int dev_insert_proc_object(struct dev_object
                                         *hdev_obj,
                                         u32 proc_obj,
-                                        OUT bool *already_attached);
+                                        bool *already_attached);
 
 /*
  *  ======== dev_remove_proc_object ========
 
  *      0:        IS_VALID(*dispatch_obj).
  *      error:          *dispatch_obj == NULL.
  */
-extern int disp_create(OUT struct disp_object **dispatch_obj,
+extern int disp_create(struct disp_object **dispatch_obj,
                              struct dev_object *hdev_obj,
                              const struct disp_attr *disp_attrs);
 
                                   u32 rms_fxn,
                                   u32 ul_create_fxn,
                                   const struct node_createargs
-                                  *pargs, OUT nodeenv *node_env);
+                                  *pargs, nodeenv *node_env);
 
 /*
  *  ======== disp_node_delete ========
 
  */
 
 extern int dmm_get_handle(void *hprocessor,
-                                OUT struct dmm_object **dmm_manager);
+                                struct dmm_object **dmm_manager);
 
 extern int dmm_reserve_memory(struct dmm_object *dmm_mgr,
                                     u32 size, u32 *prsv_addr);
 
 extern int dmm_delete_tables(struct dmm_object *dmm_mgr);
 
-extern int dmm_create(OUT struct dmm_object **dmm_manager,
+extern int dmm_create(struct dmm_object **dmm_manager,
                             struct dev_object *hdev_obj,
                             const struct dmm_mgrattrs *mgr_attrts);
 
 
  *      later used by the CFG module.
  */
 extern int drv_request_resources(u32 dw_context,
-                                       OUT u32 *dev_node_strg);
+                                       u32 *dev_node_strg);
 
 /*
  *  ======== drv_release_resources ========
  *      location of memory.
  */
 extern void *mem_alloc_phys_mem(u32 byte_size,
-                               u32 align_mask, OUT u32 *physical_address);
+                               u32 align_mask, u32 *physical_address);
 
 /*
  *  ======== mem_free_phys_mem ========
 
                struct cmm_object *hcmm_mgr;
                u32 usize;
                struct cmm_attrs *pattrs;
-               OUT void **pp_buf_va;
+               void **pp_buf_va;
        } args_cmm_allocbuf;
 
        struct {
 
 #ifndef DSPCHNL_
 #define DSPCHNL_
 
-extern int bridge_chnl_create(OUT struct chnl_mgr **channel_mgr,
+extern int bridge_chnl_create(struct chnl_mgr **channel_mgr,
                                     struct dev_object *hdev_obj,
                                     const struct chnl_mgrattrs
                                     *mgr_attrts);
 
 extern int bridge_chnl_destroy(struct chnl_mgr *hchnl_mgr);
 
-extern int bridge_chnl_open(OUT struct chnl_object **chnl,
+extern int bridge_chnl_open(struct chnl_object **chnl,
                                   struct chnl_mgr *hchnl_mgr,
                                   s8 chnl_mode,
                                   u32 ch_id,
                                      u32 dw_dsp_addr, u32 dw_arg);
 
 extern int bridge_chnl_get_ioc(struct chnl_object *chnl_obj,
-                                  u32 timeout, OUT struct chnl_ioc *chan_ioc);
+                                  u32 timeout, struct chnl_ioc *chan_ioc);
 
 extern int bridge_chnl_cancel_io(struct chnl_object *chnl_obj);
 
                                    u32 timeout);
 
 extern int bridge_chnl_get_info(struct chnl_object *chnl_obj,
-                                   OUT struct chnl_info *channel_info);
+                                   struct chnl_info *channel_info);
 
 extern int bridge_chnl_get_mgr_info(struct chnl_mgr *hchnl_mgr,
-                                       u32 ch_id, OUT struct chnl_mgrinfo
+                                       u32 ch_id, struct chnl_mgrinfo
                                        *mgr_info);
 
 extern int bridge_chnl_idle(struct chnl_object *chnl_obj,
 
  *  Will not write more than ul_num_bytes bytes into host_buf.
  */
 typedef int(*fxn_brd_read) (struct bridge_dev_context *dev_ctxt,
-                                  OUT u8 *host_buf,
+                                  u8 *host_buf,
                                   u32 dsp_addr,
                                   u32 ul_num_bytes, u32 mem_type);
 
  *      No channel manager exists for this board.
  *  Ensures:
  */
-typedef int(*fxn_chnl_create) (OUT struct chnl_mgr
+typedef int(*fxn_chnl_create) (struct chnl_mgr
                                      **channel_mgr,
                                      struct dev_object
                                      * hdev_obj,
  *      0:                *chnl is a valid channel.
  *      else:                   *chnl is set to NULL if (chnl != NULL);
  */
-typedef int(*fxn_chnl_open) (OUT struct chnl_object
+typedef int(*fxn_chnl_open) (struct chnl_object
                                    **chnl,
                                    struct chnl_mgr *hchnl_mgr,
                                    s8 chnl_mode,
  */
 typedef int(*fxn_chnl_getioc) (struct chnl_object *chnl_obj,
                                      u32 timeout,
-                                     OUT struct chnl_ioc *chan_ioc);
+                                     struct chnl_ioc *chan_ioc);
 
 /*
  *  ======== bridge_chnl_cancel_io ========
  *                      if (channel_info != NULL).
  */
 typedef int(*fxn_chnl_getinfo) (struct chnl_object *chnl_obj,
-                                      OUT struct chnl_info *channel_info);
+                                      struct chnl_info *channel_info);
 
 /*
  *  ======== bridge_chnl_get_mgr_info ========
 typedef int(*fxn_chnl_getmgrinfo) (struct chnl_mgr
                                          * hchnl_mgr,
                                          u32 ch_id,
-                                         OUT struct chnl_mgrinfo *mgr_info);
+                                         struct chnl_mgrinfo *mgr_info);
 
 /*
  *  ======== bridge_chnl_idle ========
  *      function returns, they must not be stored into the device context
  *      structure.
  */
-typedef int(*fxn_dev_create) (OUT struct bridge_dev_context
+typedef int(*fxn_dev_create) (struct bridge_dev_context
                                     **device_ctx,
                                     struct dev_object
                                     * hdev_obj,
  *  Ensures:
  */
 typedef int(*fxn_dev_ctrl) (struct bridge_dev_context *dev_ctxt,
-                                  u32 dw_cmd, OUT void *pargs);
+                                  u32 dw_cmd, void *pargs);
 
 /*
  *  ======== bridge_dev_destroy ========
  *      io_man != NULL;
  *  Ensures:
  */
-typedef int(*fxn_io_create) (OUT struct io_mgr **io_man,
+typedef int(*fxn_io_create) (struct io_mgr **io_man,
                                    struct dev_object *hdev_obj,
                                    const struct io_attrs *mgr_attrts);
 
  *  Ensures:
  */
 typedef int(*fxn_msg_create)
- (OUT struct msg_mgr **msg_man,
+ (struct msg_mgr **msg_man,
   struct dev_object *hdev_obj, msg_onexit msg_callback);
 
 /*
  */
 typedef int(*fxn_msg_createqueue)
  (struct msg_mgr *hmsg_mgr,
-  OUT struct msg_queue **msgq, u32 msgq_id, u32 max_msgs, void *h);
+  struct msg_queue **msgq, u32 msgq_id, u32 max_msgs, void *h);
 
 /*
  *  ======== bridge_msg_delete ========
  *  Details:
  *      Called during the Device_Init phase.
  */
-void bridge_drv_entry(OUT struct bridge_drv_interface **drv_intf,
+void bridge_drv_entry(struct bridge_drv_interface **drv_intf,
                   const char *driver_file_name);
 
 #endif /* DSPDEFS_ */
 
  *      Succeeded:  device context > 0
  *      Failed:     device Context = 0
  */
-extern u32 dsp_init(OUT u32 *init_status);
+extern u32 dsp_init(u32 *init_status);
 
 #endif
 
 #include <dspbridge/devdefs.h>
 #include <dspbridge/iodefs.h>
 
-extern int bridge_io_create(OUT struct io_mgr **io_man,
+extern int bridge_io_create(struct io_mgr **io_man,
                                   struct dev_object *hdev_obj,
                                   const struct io_attrs *mgr_attrts);
 
 
 extern int iva_io_on_loaded(struct io_mgr *hio_mgr);
 extern int bridge_io_get_proc_load(struct io_mgr *hio_mgr,
-                                      OUT struct dsp_procloadstat *proc_lstat);
+                                      struct dsp_procloadstat *proc_lstat);
 
 #endif /* DSPIO_ */
 
 
 #include <dspbridge/msgdefs.h>
 
-extern int bridge_msg_create(OUT struct msg_mgr **msg_man,
+extern int bridge_msg_create(struct msg_mgr **msg_man,
                                    struct dev_object *hdev_obj,
                                    msg_onexit msg_callback);
 
 extern int bridge_msg_create_queue(struct msg_mgr *hmsg_mgr,
-                                      OUT struct msg_queue **msgq,
+                                      struct msg_queue **msgq,
                                       u32 msgq_id, u32 max_msgs, void *arg);
 
 extern void bridge_msg_delete(struct msg_mgr *hmsg_mgr);
 
  *      mgr_attrts != NULL.
  *  Ensures:
  */
-extern int io_create(OUT struct io_mgr **io_man,
+extern int io_create(struct io_mgr **io_man,
                            struct dev_object *hdev_obj,
                            const struct io_attrs *mgr_attrts);
 
 
  *  Ensures:
  *      Non-preemptible (but interruptible).
  */
-extern void io_dpc(OUT unsigned long ref_data);
+extern void io_dpc(unsigned long ref_data);
 
 /*
  *  ======== io_mbox_msg ========
  */
 extern void io_request_chnl(struct io_mgr *io_manager,
                            struct chnl_object *pchnl,
-                           u8 io_mode, OUT u16 *mbx_val);
+                           u8 io_mode, u16 *mbx_val);
 
 /*
  *  ======== iosm_schedule ========
 extern void io_ddma_request_chnl(struct io_mgr *hio_mgr,
                                 struct chnl_object *pchnl,
                                 struct chnl_irp *chnl_packet_obj,
-                                OUT u16 *mbx_val);
+                                u16 *mbx_val);
 
 /*
  * Zero-copy IO functions
 extern void io_ddzc_request_chnl(struct io_mgr *hio_mgr,
                                 struct chnl_object *pchnl,
                                 struct chnl_irp *chnl_packet_obj,
-                                OUT u16 *mbx_val);
+                                u16 *mbx_val);
 
 /*
  *  ======== io_sh_msetting ========
 
 
 int mgr_wait_for_bridge_events(struct dsp_notification
                                      **anotifications,
-                                     u32 count, OUT u32 *pu_index,
+                                     u32 count, u32 *pu_index,
                                      u32 utimeout);
 
 /*
  *  Details:
  *      DCD Dll is loaded and MGR Object stores the handle of the DLL.
  */
-extern int mgr_create(OUT struct mgr_object **mgr_obj,
+extern int mgr_create(struct mgr_object **mgr_obj,
                             struct cfg_devnode *dev_node_obj);
 
 /*
  *  Details:
  */
 extern int mgr_enum_node_info(u32 node_id,
-                                    OUT struct dsp_ndbprops *pndb_props,
+                                    struct dsp_ndbprops *pndb_props,
                                     u32 undb_props_size,
-                                    OUT u32 *pu_num_nodes);
+                                    u32 *pu_num_nodes);
 
 /*
  *  ======== mgr_enum_processor_info ========
  *  Details:
  */
 extern int mgr_enum_processor_info(u32 processor_id,
-                                         OUT struct dsp_processorinfo
+                                         struct dsp_processorinfo
                                          *processor_info,
                                          u32 processor_info_size,
-                                         OUT u8 *pu_num_procs);
+                                         u8 *pu_num_procs);
 /*
  *  ======== mgr_exit ========
  *  Purpose:
  *      -EPERM and *dcd_handle == NULL
  */
 extern int mgr_get_dcd_handle(struct mgr_object
-                                    *mgr_handle, OUT u32 *dcd_handle);
+                                    *mgr_handle, u32 *dcd_handle);
 
 /*
  *  ======== mgr_init ========
 
  *      msg_callback != NULL.
  *  Ensures:
  */
-extern int msg_create(OUT struct msg_mgr **msg_man,
+extern int msg_create(struct msg_mgr **msg_man,
                             struct dev_object *hdev_obj,
                             msg_onexit msg_callback);
 
 
 extern int nldr_allocate(struct nldr_object *nldr_obj,
                                void *priv_ref, const struct dcd_nodeprops
                                *node_props,
-                               OUT struct nldr_nodeobject **nldr_nodeobj,
+                               struct nldr_nodeobject **nldr_nodeobj,
                                bool *pf_phase_split);
 
-extern int nldr_create(OUT struct nldr_object **nldr,
+extern int nldr_create(struct nldr_object **nldr,
                              struct dev_object *hdev_obj,
                              const struct nldr_attrs *pattrs);
 
                                    char *str_fxn, u32 * addr);
 
 extern int nldr_get_rmm_manager(struct nldr_object *nldr,
-                                      OUT struct rmm_target_obj **rmm_mgr);
+                                      struct rmm_target_obj **rmm_mgr);
 
 extern bool nldr_init(void);
 extern int nldr_load(struct nldr_nodeobject *nldr_node_obj,
 
                                       void *priv_ref,
                                       const struct dcd_nodeprops
                                       * node_props,
-                                      OUT struct nldr_nodeobject
+                                      struct nldr_nodeobject
                                       **nldr_nodeobj,
-                                      OUT bool *pf_phase_split);
+                                      bool *pf_phase_split);
 
 /*
  *  ======== nldr_create ========
  *      0:        Valid *nldr.
  *      error:          *nldr == NULL.
  */
-typedef int(*nldr_createfxn) (OUT struct nldr_object **nldr,
+typedef int(*nldr_createfxn) (struct nldr_object **nldr,
                                     struct dev_object *hdev_obj,
                                     const struct nldr_attrs *pattrs);
 
 
                                const struct dsp_cbdata
                                *pargs, const struct dsp_nodeattrin
                                *attr_in,
-                               OUT struct node_object **ph_node,
+                               struct node_object **ph_node,
                                struct process_context *pr_ctxt);
 
 /*
  */
 extern int node_alloc_msg_buf(struct node_object *hnode,
                                     u32 usize, struct dsp_bufferattr
-                                    *pattr, OUT u8 **pbuffer);
+                                    *pattr, u8 **pbuffer);
 
 /*
  *  ======== node_change_priority ========
  *      0:        Valide *node_man.
  *      error:          *node_man == NULL.
  */
-extern int node_create_mgr(OUT struct node_mgr **node_man,
+extern int node_create_mgr(struct node_mgr **node_man,
                                  struct dev_object *hdev_obj);
 
 /*
 extern int node_enum_nodes(struct node_mgr *hnode_mgr,
                                  void **node_tab,
                                  u32 node_tab_size,
-                                 OUT u32 *pu_num_nodes,
-                                 OUT u32 *pu_allocated);
+                                 u32 *pu_num_nodes,
+                                 u32 *pu_allocated);
 
 /*
  *  ======== node_exit ========
  *      0:        *pattrs contains the node's current attributes.
  */
 extern int node_get_attr(struct node_object *hnode,
-                               OUT struct dsp_nodeattr *pattr, u32 attr_size);
+                               struct dsp_nodeattr *pattr, u32 attr_size);
 
 /*
  *  ======== node_get_message ========
  *  Ensures:
  */
 extern int node_get_message(struct node_object *hnode,
-                                  OUT struct dsp_msg *message, u32 utimeout);
+                                  struct dsp_msg *message, u32 utimeout);
 
 /*
  *  ======== node_get_nldr_obj ========
  *  Ensures:
  */
 extern int node_get_nldr_obj(struct node_mgr *hnode_mgr,
-                                   OUT struct nldr_object **nldr_ovlyobj);
+                                   struct nldr_object **nldr_ovlyobj);
 
 /*
  *  ======== node_init ========
  *  Ensures:
  */
 extern int node_terminate(struct node_object *hnode,
-                                OUT int *pstatus);
+                                int *pstatus);
 
 /*
  *  ======== node_get_uuid_props ========
  */
 extern int node_get_uuid_props(void *hprocessor,
                                      const struct dsp_uuid *node_uuid,
-                                     OUT struct dsp_ndbprops
+                                     struct dsp_ndbprops
                                      *node_props);
 
 #ifdef CONFIG_TIDSPBRIDGE_BACKTRACE
 
  *  Ensures:
  */
 extern int node_get_channel_id(struct node_object *hnode,
-                                     u32 dir, u32 index, OUT u32 *chan_id);
+                                     u32 dir, u32 index, u32 *chan_id);
 
 /*
  *  ======== node_get_strm_mgr ========
 
 extern int proc_enum_nodes(void *hprocessor,
                                  void **node_tab,
                                  u32 node_tab_size,
-                                 OUT u32 *pu_num_nodes,
-                                 OUT u32 *pu_allocated);
+                                 u32 *pu_num_nodes,
+                                 u32 *pu_allocated);
 
 /*
  *  ======== proc_get_resource_info ========
  */
 extern int proc_get_resource_info(void *hprocessor,
                                         u32 resource_type,
-                                        OUT struct dsp_resourceinfo
+                                        struct dsp_resourceinfo
                                         *resource_info,
                                         u32 resource_info_size);
 
  *  Ensures:
  *  Details:
  */
-extern int proc_get_state(void *hprocessor, OUT struct dsp_processorstate
+extern int proc_get_state(void *hprocessor, struct dsp_processorstate
                                 *proc_state_obj, u32 state_info_size);
 
 /*
 
  */
 extern int strm_allocate_buffer(struct strm_object *stream_obj,
                                       u32 usize,
-                                      OUT u8 **ap_buffer,
+                                      u8 **ap_buffer,
                                       u32 num_bufs,
                                       struct process_context *pr_ctxt);
 
  *      0:        Valid *strm_man.
  *      error:          *strm_man == NULL.
  */
-extern int strm_create(OUT struct strm_mgr **strm_man,
+extern int strm_create(struct strm_mgr **strm_man,
                              struct dev_object *dev_obj);
 
 /*
  *  Ensures:
  */
 extern int strm_get_event_handle(struct strm_object *stream_obj,
-                                       OUT void **ph_event);
+                                       void **ph_event);
 
 /*
  *  ======== strm_get_info ========
  *  Ensures:
  */
 extern int strm_get_info(struct strm_object *stream_obj,
-                               OUT struct stream_info *stream_info,
+                               struct stream_info *stream_info,
                                u32 stream_info_size);
 
 /*
  */
 extern int strm_open(struct node_object *hnode, u32 dir,
                            u32 index, struct strm_attr *pattr,
-                           OUT struct strm_object **strm_objct,
+                           struct strm_object **strm_objct,
                            struct process_context *pr_ctxt);
 
 /*
  *  Ensures:
  */
 extern int strm_reclaim(struct strm_object *stream_obj,
-                              OUT u8 **buf_ptr, u32 * nbytes,
+                              u8 **buf_ptr, u32 * nbytes,
                               u32 *buff_size, u32 *pdw_arg);
 
 /*
  *      Error:          *pmask == 0.
  */
 extern int strm_select(struct strm_object **strm_tab,
-                             u32 strms, OUT u32 *pmask, u32 utimeout);
+                             u32 strms, u32 *pmask, u32 utimeout);
 
 /*
  *  ======== strm_unprepare_buffer ========
 
  *  Details:
  *      UUID string limit currently set at MAXUUIDLEN.
  */
-void uuid_uuid_to_string(struct dsp_uuid *uuid_obj, OUT char *sz_uuid,
+void uuid_uuid_to_string(struct dsp_uuid *uuid_obj, char *sz_uuid,
                         s32 size);
 
 /*
  *      "12345678_1234_1234_1234_123456789abc".
  */
 extern void uuid_uuid_from_string(char *sz_uuid,
-                                 OUT struct dsp_uuid *uuid_obj);
+                                 struct dsp_uuid *uuid_obj);
 
 #endif /* UUIDUTIL_ */
 
  *      Create a channel manager object, responsible for opening new channels
  *      and closing old ones for a given 'Bridge board.
  */
-int chnl_create(OUT struct chnl_mgr **channel_mgr,
+int chnl_create(struct chnl_mgr **channel_mgr,
                       struct dev_object *hdev_obj,
                       const struct chnl_mgrattrs *mgr_attrts)
 {
 
  *      inUseList.
  */
 void *cmm_calloc_buf(struct cmm_object *hcmm_mgr, u32 usize,
-                    struct cmm_attrs *pattrs, OUT void **pp_buf_va)
+                    struct cmm_attrs *pattrs, void **pp_buf_va)
 {
        struct cmm_object *cmm_mgr_obj = (struct cmm_object *)hcmm_mgr;
        void *buf_pa = NULL;
  *  Purpose:
  *      Create a communication memory manager object.
  */
-int cmm_create(OUT struct cmm_object **ph_cmm_mgr,
+int cmm_create(struct cmm_object **ph_cmm_mgr,
                      struct dev_object *hdev_obj,
                      const struct cmm_mgrattrs *mgr_attrts)
 {
  *      Return the communication memory manager object for this device.
  *      This is typically called from the client process.
  */
-int cmm_get_handle(void *hprocessor, OUT struct cmm_object ** ph_cmm_mgr)
+int cmm_get_handle(void *hprocessor, struct cmm_object ** ph_cmm_mgr)
 {
        int status = 0;
        struct dev_object *hdev_obj;
  *      Return the current memory utilization information.
  */
 int cmm_get_info(struct cmm_object *hcmm_mgr,
-                       OUT struct cmm_info *cmm_info_obj)
+                       struct cmm_info *cmm_info_obj)
 {
        struct cmm_object *cmm_mgr_obj = (struct cmm_object *)hcmm_mgr;
        u32 ul_seg;
  *  Purpose:
  *      Create an address translator object.
  */
-int cmm_xlator_create(OUT struct cmm_xlatorobject **xlator,
+int cmm_xlator_create(struct cmm_xlatorobject **xlator,
                             struct cmm_object *hcmm_mgr,
                             struct cmm_xlatorattrs *xlator_attrs)
 {
  *  Purpose:
  *      Set/Get translator info.
  */
-int cmm_xlator_info(struct cmm_xlatorobject *xlator, OUT u8 ** paddr,
+int cmm_xlator_info(struct cmm_xlatorobject *xlator, u8 ** paddr,
                           u32 ul_size, u32 segm_id, bool set_info)
 {
        struct cmm_xlator *xlator_obj = (struct cmm_xlator *)xlator;
 
  *      dynamically loaded object files.
  *
  */
-int cod_create(OUT struct cod_manager **mgr, char *str_zl_file,
+int cod_create(struct cod_manager **mgr, char *str_zl_file,
                      const struct cod_attrs *attrs)
 {
        struct cod_manager *mgr_new;
  *      given the section name.
  */
 int cod_get_section(struct cod_libraryobj *lib, char *str_sect,
-                          OUT u32 *addr, OUT u32 *len)
+                          u32 *addr, u32 *len)
 {
        struct cod_manager *cod_mgr_obj;
        int status = 0;
  *      Retrieve the content of a code section given the section name.
  */
 int cod_read_section(struct cod_libraryobj *lib, char *str_sect,
-                           OUT char *str_content, u32 content_size)
+                           char *str_content, u32 content_size)
 {
        int status = 0;
 
 
 static int fxn_not_implemented(int arg, ...);
 static int init_cod_mgr(struct dev_object *dev_obj);
 static void store_interface_fxns(struct bridge_drv_interface *drv_fxns,
-                                OUT struct bridge_drv_interface *intf_fxns);
+                                struct bridge_drv_interface *intf_fxns);
 /*
  *  ======== dev_brd_write_fxn ========
  *  Purpose:
  *      Called by the operating system to load the PM Bridge Driver for a
  *      PM board (device).
  */
-int dev_create_device(OUT struct dev_object **device_obj,
+int dev_create_device(struct dev_object **device_obj,
                             const char *driver_file_name,
                             struct cfg_devnode *dev_node_obj)
 {
        }
 leave:
        /*  If all went well, return a handle to the dev object;
-        *  else, cleanup and return NULL in the OUT parameter. */
+        *  else, cleanup and return NULL in the parameter. */
        if (DSP_SUCCEEDED(status)) {
                *device_obj = dev_obj;
        } else {
  *      device.
  */
 int dev_get_chnl_mgr(struct dev_object *hdev_obj,
-                           OUT struct chnl_mgr **mgr)
+                           struct chnl_mgr **mgr)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *      device.
  */
 int dev_get_cmm_mgr(struct dev_object *hdev_obj,
-                          OUT struct cmm_object **mgr)
+                          struct cmm_object **mgr)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *      device.
  */
 int dev_get_dmm_mgr(struct dev_object *hdev_obj,
-                          OUT struct dmm_object **mgr)
+                          struct dmm_object **mgr)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *      Retrieve the COD manager create for this device.
  */
 int dev_get_cod_mgr(struct dev_object *hdev_obj,
-                          OUT struct cod_manager **cod_mgr)
+                          struct cod_manager **cod_mgr)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *  ========= dev_get_deh_mgr ========
  */
 int dev_get_deh_mgr(struct dev_object *hdev_obj,
-                          OUT struct deh_mgr **deh_manager)
+                          struct deh_mgr **deh_manager)
 {
        int status = 0;
 
  *      Retrieve the platform specific device ID for this device.
  */
 int dev_get_dev_node(struct dev_object *hdev_obj,
-                           OUT struct cfg_devnode **dev_nde)
+                           struct cfg_devnode **dev_nde)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *      if_fxns != NULL.
  */
 int dev_get_intf_fxns(struct dev_object *hdev_obj,
-                            OUT struct bridge_drv_interface **if_fxns)
+                            struct bridge_drv_interface **if_fxns)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *  ========= dev_get_io_mgr ========
  */
 int dev_get_io_mgr(struct dev_object *hdev_obj,
-                         OUT struct io_mgr **io_man)
+                         struct io_mgr **io_man)
 {
        int status = 0;
 
 /*
  *  ========= dev_get_msg_mgr ========
  */
-void dev_get_msg_mgr(struct dev_object *hdev_obj, OUT struct msg_mgr **msg_man)
+void dev_get_msg_mgr(struct dev_object *hdev_obj, struct msg_mgr **msg_man)
 {
        DBC_REQUIRE(refs > 0);
        DBC_REQUIRE(msg_man != NULL);
  *      Retrieve the Node Manager Handle
  */
 int dev_get_node_manager(struct dev_object *hdev_obj,
-                               OUT struct node_mgr **node_man)
+                               struct node_mgr **node_man)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *  ======== dev_get_symbol ========
  */
 int dev_get_symbol(struct dev_object *hdev_obj,
-                         const char *str_sym, OUT u32 * pul_value)
+                         const char *str_sym, u32 * pul_value)
 {
        int status = 0;
        struct cod_manager *cod_mgr;
  *      bridge_dev_create fxn.
  */
 int dev_get_bridge_context(struct dev_object *hdev_obj,
-                              OUT struct bridge_dev_context **phbridge_context)
+                              struct bridge_dev_context **phbridge_context)
 {
        int status = 0;
        struct dev_object *dev_obj = hdev_obj;
  *      0 and List is not Empty.
  */
 int dev_insert_proc_object(struct dev_object *hdev_obj,
-                                 u32 proc_obj, OUT bool *already_attached)
+                                 u32 proc_obj, bool *already_attached)
 {
        int status = 0;
        struct dev_object *dev_obj = (struct dev_object *)hdev_obj;
  *      All function pointers in the dev object's fxn interface are not NULL.
  */
 static void store_interface_fxns(struct bridge_drv_interface *drv_fxns,
-                                OUT struct bridge_drv_interface *intf_fxns)
+                                struct bridge_drv_interface *intf_fxns)
 {
        u32 bridge_version;
 
 
  *  Purpose:
  *      Create a dynamic memory manager object.
  */
-int dmm_create(OUT struct dmm_object **dmm_manager,
+int dmm_create(struct dmm_object **dmm_manager,
                      struct dev_object *hdev_obj,
                      const struct dmm_mgrattrs *mgr_attrts)
 {
  *      Return the dynamic memory manager object for this device.
  *      This is typically called from the client process.
  */
-int dmm_get_handle(void *hprocessor, OUT struct dmm_object **dmm_manager)
+int dmm_get_handle(void *hprocessor, struct dmm_object **dmm_manager)
 {
        int status = 0;
        struct dev_object *hdev_obj;
 
                        pattr = &attr;
 
        }
-       /* OUT argument */
+       /* argument */
        CP_FM_USR(&pbuffer, args->args_node_allocmsgbuf.pbuffer, status, 1);
        if (DSP_SUCCEEDED(status)) {
                status = node_alloc_msg_buf(args->args_node_allocmsgbuf.hnode,
 
  *      Create an IO manager object, responsible for managing IO between
  *      CHNL and msg_ctrl
  */
-int io_create(OUT struct io_mgr **io_man, struct dev_object *hdev_obj,
+int io_create(struct io_mgr **io_man, struct dev_object *hdev_obj,
                     const struct io_attrs *mgr_attrts)
 {
        struct bridge_drv_interface *intf_fxns;
 
  *      Create an object to manage message queues. Only one of these objects
  *      can exist per device object.
  */
-int msg_create(OUT struct msg_mgr **msg_man,
+int msg_create(struct msg_mgr **msg_man,
                      struct dev_object *hdev_obj, msg_onexit msg_callback)
 {
        struct bridge_drv_interface *intf_fxns;
 
 static char dsp_char2_gpp_char(char *word, s32 dsp_char_size);
 static int get_dep_lib_info(struct dcd_manager *hdcd_mgr,
                                   struct dsp_uuid *uuid_obj,
-                                  OUT u16 *num_libs,
-                                  OUT u16 *num_pers_libs,
-                                  OUT struct dsp_uuid *dep_lib_uuids,
-                                  OUT bool *prstnt_dep_libs,
+                                  u16 *num_libs,
+                                  u16 *num_pers_libs,
+                                  struct dsp_uuid *dep_lib_uuids,
+                                  bool *prstnt_dep_libs,
                                   enum nldr_phase phase);
 
 /*
  *      Creates DCD manager.
  */
 int dcd_create_manager(char *sz_zl_dll_name,
-                             OUT struct dcd_manager **dcd_mgr)
+                             struct dcd_manager **dcd_mgr)
 {
        struct cod_manager *cod_mgr;    /* COD manager handle */
        struct dcd_manager *dcd_mgr_obj = NULL; /* DCD Manager pointer */
  *      Enumerates objects in the DCD.
  */
 int dcd_enumerate_object(s32 index, enum dsp_dcdobjtype obj_type,
-                               OUT struct dsp_uuid *uuid_obj)
+                               struct dsp_uuid *uuid_obj)
 {
        int status = 0;
        char sz_reg_key[DCD_MAXPATHLENGTH];
  */
 int dcd_get_dep_libs(struct dcd_manager *hdcd_mgr,
                            struct dsp_uuid *uuid_obj,
-                           u16 num_libs, OUT struct dsp_uuid *dep_lib_uuids,
-                           OUT bool *prstnt_dep_libs,
+                           u16 num_libs, struct dsp_uuid *dep_lib_uuids,
+                           bool *prstnt_dep_libs,
                            enum nldr_phase phase)
 {
        int status = 0;
  */
 int dcd_get_num_dep_libs(struct dcd_manager *hdcd_mgr,
                                struct dsp_uuid *uuid_obj,
-                               OUT u16 *num_libs, OUT u16 *num_pers_libs,
+                               u16 *num_libs, u16 *num_pers_libs,
                                enum nldr_phase phase)
 {
        int status = 0;
 int dcd_get_object_def(struct dcd_manager *hdcd_mgr,
                              struct dsp_uuid *obj_uuid,
                              enum dsp_dcdobjtype obj_type,
-                             OUT struct dcd_genericobj *obj_def)
+                             struct dcd_genericobj *obj_def)
 {
        struct dcd_manager *dcd_mgr_obj = hdcd_mgr;     /* ptr to DCD mgr */
        struct cod_libraryobj *lib = NULL;
  */
 int dcd_get_library_name(struct dcd_manager *hdcd_mgr,
                                struct dsp_uuid *uuid_obj,
-                               OUT char *str_lib_name,
-                               OUT u32 *buff_size,
-                               enum nldr_phase phase, OUT bool *phase_split)
+                               char *str_lib_name,
+                               u32 *buff_size,
+                               enum nldr_phase phase, bool *phase_split)
 {
        char sz_reg_key[DCD_MAXPATHLENGTH];
        char sz_uuid[MAXUUIDLEN];
  */
 static int get_dep_lib_info(struct dcd_manager *hdcd_mgr,
                                   struct dsp_uuid *uuid_obj,
-                                  OUT u16 *num_libs,
-                                  OUT u16 *num_pers_libs,
-                                  OUT struct dsp_uuid *dep_lib_uuids,
-                                  OUT bool *prstnt_dep_libs,
+                                  u16 *num_libs,
+                                  u16 *num_pers_libs,
+                                  struct dsp_uuid *dep_lib_uuids,
+                                  bool *prstnt_dep_libs,
                                   enum nldr_phase phase)
 {
        struct dcd_manager *dcd_mgr_obj = hdcd_mgr;
 
                                  struct node_strmdef strm_def, u32 max,
                                  u32 chars_in_rms_word);
 static int send_message(struct disp_object *disp_obj, u32 timeout,
-                              u32 ul_bytes, OUT u32 *pdw_arg);
+                              u32 ul_bytes, u32 *pdw_arg);
 
 /*
  *  ======== disp_create ========
  *  Create a NODE Dispatcher object.
  */
-int disp_create(OUT struct disp_object **dispatch_obj,
+int disp_create(struct disp_object **dispatch_obj,
                       struct dev_object *hdev_obj,
                       const struct disp_attr *disp_attrs)
 {
                            struct node_object *hnode, u32 rms_fxn,
                            u32 ul_create_fxn,
                            const struct node_createargs *pargs,
-                           OUT nodeenv *node_env)
+                           nodeenv *node_env)
 {
        struct node_msgargs node_msg_args;
        struct node_taskargs task_arg_obj;
 
  *  Purpose:
  *      DRV Object gets created only once during Driver Loading.
  */
-int drv_create(OUT struct drv_object **drv_obj)
+int drv_create(struct drv_object **drv_obj)
 {
        int status = 0;
        struct drv_object *pdrv_object = NULL;
  *     Allocate physically contiguous, uncached memory from external memory pool
  */
 
-static void *mem_ext_phys_mem_alloc(u32 bytes, u32 align, OUT u32 * phys_addr)
+static void *mem_ext_phys_mem_alloc(u32 bytes, u32 align, u32 * phys_addr)
 {
        u32 new_alloc_ptr;
        u32 offset;
  *      Allocate physically contiguous, uncached memory
  */
 void *mem_alloc_phys_mem(u32 byte_size, u32 align_mask,
-                               OUT u32 *physical_address)
+                               u32 *physical_address)
 {
        void *va_mem = NULL;
        dma_addr_t pa_mem;
 
  *  ======== dsp_init ========
  *     Allocates bridge resources. Loads a base image onto DSP, if specified.
  */
-u32 dsp_init(OUT u32 *init_status)
+u32 dsp_init(u32 *init_status)
 {
        char dev_node[MAXREGPATHLENGTH] = "TIOMAP1510";
        int status = -EPERM;
 
  *  Purpose:
  *      MGR Object gets created only once during driver Loading.
  */
-int mgr_create(OUT struct mgr_object **mgr_obj,
+int mgr_create(struct mgr_object **mgr_obj,
                      struct cfg_devnode *dev_node_obj)
 {
        int status = 0;
  *      Enumerate and get configuration information about nodes configured
  *      in the node database.
  */
-int mgr_enum_node_info(u32 node_id, OUT struct dsp_ndbprops *pndb_props,
-                             u32 undb_props_size, OUT u32 *pu_num_nodes)
+int mgr_enum_node_info(u32 node_id, struct dsp_ndbprops *pndb_props,
+                             u32 undb_props_size, u32 *pu_num_nodes)
 {
        int status = 0;
        struct dsp_uuid node_uuid, temp_uuid;
  *      DSP processors.
  */
 int mgr_enum_processor_info(u32 processor_id,
-                                  OUT struct dsp_processorinfo *
+                                  struct dsp_processorinfo *
                                   processor_info, u32 processor_info_size,
-                                  OUT u8 *pu_num_procs)
+                                  u8 *pu_num_procs)
 {
        int status = 0;
        int status1 = 0;
  *      Retrieves the MGR handle. Accessor Function.
  */
 int mgr_get_dcd_handle(struct mgr_object *mgr_handle,
-                             OUT u32 *dcd_handle)
+                             u32 *dcd_handle)
 {
        int status = -EPERM;
        struct mgr_object *pmgr_obj = (struct mgr_object *)mgr_handle;
  *      Block on any Bridge event(s)
  */
 int mgr_wait_for_bridge_events(struct dsp_notification **anotifications,
-                                     u32 count, OUT u32 *pu_index,
+                                     u32 count, u32 *pu_index,
                                      u32 utimeout)
 {
        int status;
 
  */
 int nldr_allocate(struct nldr_object *nldr_obj, void *priv_ref,
                         const struct dcd_nodeprops *node_props,
-                        OUT struct nldr_nodeobject **nldr_nodeobj,
+                        struct nldr_nodeobject **nldr_nodeobj,
                         bool *pf_phase_split)
 {
        struct nldr_nodeobject *nldr_node_obj = NULL;
 /*
  *  ======== nldr_create ========
  */
-int nldr_create(OUT struct nldr_object **nldr,
+int nldr_create(struct nldr_object **nldr,
                       struct dev_object *hdev_obj,
                       const struct nldr_attrs *pattrs)
 {
  *  Given a NLDR object, retrieve RMM Manager Handle
  */
 int nldr_get_rmm_manager(struct nldr_object *nldr,
-                               OUT struct rmm_target_obj **rmm_mgr)
+                               struct rmm_target_obj **rmm_mgr)
 {
        int status = 0;
        struct nldr_object *nldr_obj = nldr;
 
                         const struct dsp_uuid *node_uuid,
                         const struct dsp_cbdata *pargs,
                         const struct dsp_nodeattrin *attr_in,
-                        OUT struct node_object **ph_node,
+                        struct node_object **ph_node,
                         struct process_context *pr_ctxt)
 {
        struct node_mgr *hnode_mgr;
  *      Allocates buffer for zero copy messaging.
  */
 DBAPI node_alloc_msg_buf(struct node_object *hnode, u32 usize,
-                        OUT struct dsp_bufferattr *pattr,
-                        OUT u8 **pbuffer)
+                        struct dsp_bufferattr *pattr,
+                        u8 **pbuffer)
 {
        struct node_object *pnode = (struct node_object *)hnode;
        int status = 0;
  *  Purpose:
  *      Create a NODE Manager object.
  */
-int node_create_mgr(OUT struct node_mgr **node_man,
+int node_create_mgr(struct node_mgr **node_man,
                           struct dev_object *hdev_obj)
 {
        u32 i;
  *      Enumerate currently allocated nodes.
  */
 int node_enum_nodes(struct node_mgr *hnode_mgr, void **node_tab,
-                          u32 node_tab_size, OUT u32 *pu_num_nodes,
-                          OUT u32 *pu_allocated)
+                          u32 node_tab_size, u32 *pu_num_nodes,
+                          u32 *pu_allocated)
 {
        struct node_object *hnode;
        u32 i;
  *      structure.
  */
 int node_get_attr(struct node_object *hnode,
-                        OUT struct dsp_nodeattr *pattr, u32 attr_size)
+                        struct dsp_nodeattr *pattr, u32 attr_size)
 {
        struct node_mgr *hnode_mgr;
        int status = 0;
  *      host and a node.
  */
 int node_get_channel_id(struct node_object *hnode, u32 dir, u32 index,
-                              OUT u32 *chan_id)
+                              u32 *chan_id)
 {
        enum node_type node_type;
        int status = -EINVAL;
  *      Retrieve a message from a node on the DSP.
  */
 int node_get_message(struct node_object *hnode,
-                           OUT struct dsp_msg *message, u32 utimeout)
+                           struct dsp_msg *message, u32 utimeout)
 {
        struct node_mgr *hnode_mgr;
        enum node_type node_type;
  *      Signal a node running on the DSP that it should exit its execute phase
  *      function.
  */
-int node_terminate(struct node_object *hnode, OUT int *pstatus)
+int node_terminate(struct node_object *hnode, int *pstatus)
 {
        struct node_object *pnode = (struct node_object *)hnode;
        struct node_mgr *hnode_mgr = NULL;
  */
 int node_get_uuid_props(void *hprocessor,
                               const struct dsp_uuid *node_uuid,
-                              OUT struct dsp_ndbprops *node_props)
+                              struct dsp_ndbprops *node_props)
 {
        struct node_mgr *hnode_mgr = NULL;
        struct dev_object *hdev_obj;
 
  *      on a DSP processor.
  */
 int proc_enum_nodes(void *hprocessor, void **node_tab,
-                          u32 node_tab_size, OUT u32 *pu_num_nodes,
-                          OUT u32 *pu_allocated)
+                          u32 node_tab_size, u32 *pu_num_nodes,
+                          u32 *pu_allocated)
 {
        int status = -EPERM;
        struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
  *      Enumerate the resources currently available on a processor.
  */
 int proc_get_resource_info(void *hprocessor, u32 resource_type,
-                                 OUT struct dsp_resourceinfo *resource_info,
+                                 struct dsp_resourceinfo *resource_info,
                                  u32 resource_info_size)
 {
        int status = -EPERM;
  *      Report the state of the specified DSP processor.
  */
 int proc_get_state(void *hprocessor,
-                         OUT struct dsp_processorstate *proc_state_obj,
+                         struct dsp_processorstate *proc_state_obj,
                          u32 state_info_size)
 {
        int status = 0;
 
  *      Allocates buffers for a stream.
  */
 int strm_allocate_buffer(struct strm_object *stream_obj, u32 usize,
-                               OUT u8 **ap_buffer, u32 num_bufs,
+                               u8 **ap_buffer, u32 num_bufs,
                                struct process_context *pr_ctxt)
 {
        int status = 0;
  *  Purpose:
  *      Create a STRM manager object.
  */
-int strm_create(OUT struct strm_mgr **strm_man,
+int strm_create(struct strm_mgr **strm_man,
                       struct dev_object *dev_obj)
 {
        struct strm_mgr *strm_mgr_obj;
  *      Retrieves information about a stream.
  */
 int strm_get_info(struct strm_object *stream_obj,
-                        OUT struct stream_info *stream_info,
+                        struct stream_info *stream_info,
                         u32 stream_info_size)
 {
        struct bridge_drv_interface *intf_fxns;
  */
 int strm_open(struct node_object *hnode, u32 dir, u32 index,
                     struct strm_attr *pattr,
-                    OUT struct strm_object **strm_objct,
+                    struct strm_object **strm_objct,
                     struct process_context *pr_ctxt)
 {
        struct strm_mgr *strm_mgr_obj;
  *  Purpose:
  *      Relcaims a buffer from a stream.
  */
-int strm_reclaim(struct strm_object *stream_obj, OUT u8 ** buf_ptr,
+int strm_reclaim(struct strm_object *stream_obj, u8 ** buf_ptr,
                        u32 *nbytes, u32 *buff_size, u32 *pdw_arg)
 {
        struct bridge_drv_interface *intf_fxns;
  *      Selects a ready stream.
  */
 int strm_select(struct strm_object **strm_tab, u32 strms,
-                      OUT u32 *pmask, u32 utimeout)
+                      u32 *pmask, u32 utimeout)
 {
        u32 index;
        struct chnl_info chnl_info_obj;
 
  *      Retreive the autostart mask, if any, for this board.
  */
 int cfg_get_auto_start(struct cfg_devnode *dev_node_obj,
-                             OUT u32 *auto_start)
+                             u32 *auto_start)
 {
        int status = 0;
        u32 dw_buf_size;
  *      Retrieve the Device Object handle for a given devnode.
  */
 int cfg_get_dev_object(struct cfg_devnode *dev_node_obj,
-                             OUT u32 *value)
+                             u32 *value)
 {
        int status = 0;
        u32 dw_buf_size;
  *      Retreive the default executable, if any, for this board.
  */
 int cfg_get_exec_file(struct cfg_devnode *dev_node_obj, u32 buf_size,
-                            OUT char *str_exec_file)
+                            char *str_exec_file)
 {
        int status = 0;
        struct drv_data *drv_datap = dev_get_drvdata(bridge);
  *  Purpose:
  *      Retrieve the Object handle from the Registry
  */
-int cfg_get_object(OUT u32 *value, u8 dw_type)
+int cfg_get_object(u32 *value, u8 dw_type)
 {
        int status = -EINVAL;
        struct drv_data *drv_datap = dev_get_drvdata(bridge);