staging: tidspbridge: remove strm_init() and strm_exit()
[linux-3.10.git] / drivers / staging / tidspbridge / rmgr / strm.c
1 /*
2  * strm.c
3  *
4  * DSP-BIOS Bridge driver support functions for TI OMAP processors.
5  *
6  * DSP/BIOS Bridge Stream Manager.
7  *
8  * Copyright (C) 2005-2006 Texas Instruments, Inc.
9  *
10  * This package is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  *
14  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
16  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17  */
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/sync.h>
29
30 /*  ----------------------------------- Bridge Driver */
31 #include <dspbridge/dspdefs.h>
32
33 /*  ----------------------------------- Resource Manager */
34 #include <dspbridge/nodepriv.h>
35
36 /*  ----------------------------------- Others */
37 #include <dspbridge/cmm.h>
38
39 /*  ----------------------------------- This */
40 #include <dspbridge/strm.h>
41
42 #include <dspbridge/resourcecleanup.h>
43
44 /*  ----------------------------------- Defines, Data Structures, Typedefs */
45 #define DEFAULTTIMEOUT      10000
46 #define DEFAULTNUMBUFS      2
47
48 /*
49  *  ======== strm_mgr ========
50  *  The strm_mgr contains device information needed to open the underlying
51  *  channels of a stream.
52  */
53 struct strm_mgr {
54         struct dev_object *dev_obj;     /* Device for this processor */
55         struct chnl_mgr *chnl_mgr;      /* Channel manager */
56         /* Function interface to Bridge driver */
57         struct bridge_drv_interface *intf_fxns;
58 };
59
60 /*
61  *  ======== strm_object ========
62  *  This object is allocated in strm_open().
63  */
64 struct strm_object {
65         struct strm_mgr *strm_mgr_obj;
66         struct chnl_object *chnl_obj;
67         u32 dir;                /* DSP_TONODE or DSP_FROMNODE */
68         u32 timeout;
69         u32 num_bufs;           /* Max # of bufs allowed in stream */
70         u32 bufs_in_strm;       /* Current # of bufs in stream */
71         u32 bytes;              /* bytes transferred since idled */
72         /* STREAM_IDLE, STREAM_READY, ... */
73         enum dsp_streamstate strm_state;
74         void *user_event;       /* Saved for strm_get_info() */
75         enum dsp_strmmode strm_mode;    /* STRMMODE_[PROCCOPY][ZEROCOPY]... */
76         u32 dma_chnl_id;        /* DMA chnl id */
77         u32 dma_priority;       /* DMA priority:DMAPRI_[LOW][HIGH] */
78         u32 segment_id;         /* >0 is SM segment.=0 is local heap */
79         u32 buf_alignment;      /* Alignment for stream bufs */
80         /* Stream's SM address translator */
81         struct cmm_xlatorobject *xlator;
82 };
83
84 /*  ----------------------------------- Function Prototypes */
85 static int delete_strm(struct strm_object *stream_obj);
86
87 /*
88  *  ======== strm_allocate_buffer ========
89  *  Purpose:
90  *      Allocates buffers for a stream.
91  */
92 int strm_allocate_buffer(struct strm_res_object *strmres, u32 usize,
93                                 u8 **ap_buffer, u32 num_bufs,
94                                 struct process_context *pr_ctxt)
95 {
96         int status = 0;
97         u32 alloc_cnt = 0;
98         u32 i;
99         struct strm_object *stream_obj = strmres->stream;
100
101         if (stream_obj) {
102                 /*
103                  * Allocate from segment specified at time of stream open.
104                  */
105                 if (usize == 0)
106                         status = -EINVAL;
107
108         } else {
109                 status = -EFAULT;
110         }
111
112         if (status)
113                 goto func_end;
114
115         for (i = 0; i < num_bufs; i++) {
116                 (void)cmm_xlator_alloc_buf(stream_obj->xlator, &ap_buffer[i],
117                                            usize);
118                 if (ap_buffer[i] == NULL) {
119                         status = -ENOMEM;
120                         alloc_cnt = i;
121                         break;
122                 }
123         }
124         if (status)
125                 strm_free_buffer(strmres, ap_buffer, alloc_cnt, pr_ctxt);
126
127         if (status)
128                 goto func_end;
129
130         drv_proc_update_strm_res(num_bufs, strmres);
131
132 func_end:
133         return status;
134 }
135
136 /*
137  *  ======== strm_close ========
138  *  Purpose:
139  *      Close a stream opened with strm_open().
140  */
141 int strm_close(struct strm_res_object *strmres,
142                       struct process_context *pr_ctxt)
143 {
144         struct bridge_drv_interface *intf_fxns;
145         struct chnl_info chnl_info_obj;
146         int status = 0;
147         struct strm_object *stream_obj = strmres->stream;
148
149         if (!stream_obj) {
150                 status = -EFAULT;
151         } else {
152                 /* Have all buffers been reclaimed? If not, return
153                  * -EPIPE */
154                 intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
155                 status =
156                     (*intf_fxns->chnl_get_info) (stream_obj->chnl_obj,
157                                                      &chnl_info_obj);
158
159                 if (chnl_info_obj.cio_cs > 0 || chnl_info_obj.cio_reqs > 0)
160                         status = -EPIPE;
161                 else
162                         status = delete_strm(stream_obj);
163         }
164
165         if (status)
166                 goto func_end;
167
168         idr_remove(pr_ctxt->stream_id, strmres->id);
169 func_end:
170         dev_dbg(bridge, "%s: stream_obj: %p, status 0x%x\n", __func__,
171                 stream_obj, status);
172         return status;
173 }
174
175 /*
176  *  ======== strm_create ========
177  *  Purpose:
178  *      Create a STRM manager object.
179  */
180 int strm_create(struct strm_mgr **strm_man,
181                        struct dev_object *dev_obj)
182 {
183         struct strm_mgr *strm_mgr_obj;
184         int status = 0;
185
186         *strm_man = NULL;
187         /* Allocate STRM manager object */
188         strm_mgr_obj = kzalloc(sizeof(struct strm_mgr), GFP_KERNEL);
189         if (strm_mgr_obj == NULL)
190                 status = -ENOMEM;
191         else
192                 strm_mgr_obj->dev_obj = dev_obj;
193
194         /* Get Channel manager and Bridge function interface */
195         if (!status) {
196                 status = dev_get_chnl_mgr(dev_obj, &(strm_mgr_obj->chnl_mgr));
197                 if (!status) {
198                         (void)dev_get_intf_fxns(dev_obj,
199                                                 &(strm_mgr_obj->intf_fxns));
200                 }
201         }
202
203         if (!status)
204                 *strm_man = strm_mgr_obj;
205         else
206                 kfree(strm_mgr_obj);
207
208         return status;
209 }
210
211 /*
212  *  ======== strm_delete ========
213  *  Purpose:
214  *      Delete the STRM Manager Object.
215  */
216 void strm_delete(struct strm_mgr *strm_mgr_obj)
217 {
218         kfree(strm_mgr_obj);
219 }
220
221 /*
222  *  ======== strm_free_buffer ========
223  *  Purpose:
224  *      Frees the buffers allocated for a stream.
225  */
226 int strm_free_buffer(struct strm_res_object *strmres, u8 ** ap_buffer,
227                             u32 num_bufs, struct process_context *pr_ctxt)
228 {
229         int status = 0;
230         u32 i = 0;
231         struct strm_object *stream_obj = strmres->stream;
232
233         if (!stream_obj)
234                 status = -EFAULT;
235
236         if (!status) {
237                 for (i = 0; i < num_bufs; i++) {
238                         status =
239                             cmm_xlator_free_buf(stream_obj->xlator,
240                                                 ap_buffer[i]);
241                         if (status)
242                                 break;
243                         ap_buffer[i] = NULL;
244                 }
245         }
246         drv_proc_update_strm_res(num_bufs - i, strmres);
247
248         return status;
249 }
250
251 /*
252  *  ======== strm_get_info ========
253  *  Purpose:
254  *      Retrieves information about a stream.
255  */
256 int strm_get_info(struct strm_object *stream_obj,
257                          struct stream_info *stream_info,
258                          u32 stream_info_size)
259 {
260         struct bridge_drv_interface *intf_fxns;
261         struct chnl_info chnl_info_obj;
262         int status = 0;
263         void *virt_base = NULL; /* NULL if no SM used */
264
265         if (!stream_obj) {
266                 status = -EFAULT;
267         } else {
268                 if (stream_info_size < sizeof(struct stream_info)) {
269                         /* size of users info */
270                         status = -EINVAL;
271                 }
272         }
273         if (status)
274                 goto func_end;
275
276         intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
277         status =
278             (*intf_fxns->chnl_get_info) (stream_obj->chnl_obj,
279                                                   &chnl_info_obj);
280         if (status)
281                 goto func_end;
282
283         if (stream_obj->xlator) {
284                 /* We have a translator */
285                 cmm_xlator_info(stream_obj->xlator, (u8 **) &virt_base, 0,
286                                 stream_obj->segment_id, false);
287         }
288         stream_info->segment_id = stream_obj->segment_id;
289         stream_info->strm_mode = stream_obj->strm_mode;
290         stream_info->virt_base = virt_base;
291         stream_info->user_strm->number_bufs_allowed = stream_obj->num_bufs;
292         stream_info->user_strm->number_bufs_in_stream = chnl_info_obj.cio_cs +
293             chnl_info_obj.cio_reqs;
294         /* # of bytes transferred since last call to DSPStream_Idle() */
295         stream_info->user_strm->number_bytes = chnl_info_obj.bytes_tx;
296         stream_info->user_strm->sync_object_handle = chnl_info_obj.event_obj;
297         /* Determine stream state based on channel state and info */
298         if (chnl_info_obj.state & CHNL_STATEEOS) {
299                 stream_info->user_strm->ss_stream_state = STREAM_DONE;
300         } else {
301                 if (chnl_info_obj.cio_cs > 0)
302                         stream_info->user_strm->ss_stream_state = STREAM_READY;
303                 else if (chnl_info_obj.cio_reqs > 0)
304                         stream_info->user_strm->ss_stream_state =
305                             STREAM_PENDING;
306                 else
307                         stream_info->user_strm->ss_stream_state = STREAM_IDLE;
308
309         }
310 func_end:
311         return status;
312 }
313
314 /*
315  *  ======== strm_idle ========
316  *  Purpose:
317  *      Idles a particular stream.
318  */
319 int strm_idle(struct strm_object *stream_obj, bool flush_data)
320 {
321         struct bridge_drv_interface *intf_fxns;
322         int status = 0;
323
324         if (!stream_obj) {
325                 status = -EFAULT;
326         } else {
327                 intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
328
329                 status = (*intf_fxns->chnl_idle) (stream_obj->chnl_obj,
330                                                       stream_obj->timeout,
331                                                       flush_data);
332         }
333
334         dev_dbg(bridge, "%s: stream_obj: %p flush_data: 0x%x status: 0x%x\n",
335                 __func__, stream_obj, flush_data, status);
336         return status;
337 }
338
339 /*
340  *  ======== strm_issue ========
341  *  Purpose:
342  *      Issues a buffer on a stream
343  */
344 int strm_issue(struct strm_object *stream_obj, u8 *pbuf, u32 ul_bytes,
345                       u32 ul_buf_size, u32 dw_arg)
346 {
347         struct bridge_drv_interface *intf_fxns;
348         int status = 0;
349         void *tmp_buf = NULL;
350
351         if (!stream_obj) {
352                 status = -EFAULT;
353         } else {
354                 intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
355
356                 if (stream_obj->segment_id != 0) {
357                         tmp_buf = cmm_xlator_translate(stream_obj->xlator,
358                                                        (void *)pbuf,
359                                                        CMM_VA2DSPPA);
360                         if (tmp_buf == NULL)
361                                 status = -ESRCH;
362
363                 }
364                 if (!status) {
365                         status = (*intf_fxns->chnl_add_io_req)
366                             (stream_obj->chnl_obj, pbuf, ul_bytes, ul_buf_size,
367                              (u32) tmp_buf, dw_arg);
368                 }
369                 if (status == -EIO)
370                         status = -ENOSR;
371         }
372
373         dev_dbg(bridge, "%s: stream_obj: %p pbuf: %p ul_bytes: 0x%x dw_arg:"
374                 " 0x%x status: 0x%x\n", __func__, stream_obj, pbuf,
375                 ul_bytes, dw_arg, status);
376         return status;
377 }
378
379 /*
380  *  ======== strm_open ========
381  *  Purpose:
382  *      Open a stream for sending/receiving data buffers to/from a task or
383  *      XDAIS socket node on the DSP.
384  */
385 int strm_open(struct node_object *hnode, u32 dir, u32 index,
386                      struct strm_attr *pattr,
387                      struct strm_res_object **strmres,
388                      struct process_context *pr_ctxt)
389 {
390         struct strm_mgr *strm_mgr_obj;
391         struct bridge_drv_interface *intf_fxns;
392         u32 ul_chnl_id;
393         struct strm_object *strm_obj = NULL;
394         s8 chnl_mode;
395         struct chnl_attr chnl_attr_obj;
396         int status = 0;
397         struct cmm_object *hcmm_mgr = NULL;     /* Shared memory manager hndl */
398
399         void *stream_res;
400
401         *strmres = NULL;
402         if (dir != DSP_TONODE && dir != DSP_FROMNODE) {
403                 status = -EPERM;
404         } else {
405                 /* Get the channel id from the node (set in node_connect()) */
406                 status = node_get_channel_id(hnode, dir, index, &ul_chnl_id);
407         }
408         if (!status)
409                 status = node_get_strm_mgr(hnode, &strm_mgr_obj);
410
411         if (!status) {
412                 strm_obj = kzalloc(sizeof(struct strm_object), GFP_KERNEL);
413                 if (strm_obj == NULL) {
414                         status = -ENOMEM;
415                 } else {
416                         strm_obj->strm_mgr_obj = strm_mgr_obj;
417                         strm_obj->dir = dir;
418                         strm_obj->strm_state = STREAM_IDLE;
419                         strm_obj->user_event = pattr->user_event;
420                         if (pattr->stream_attr_in != NULL) {
421                                 strm_obj->timeout =
422                                     pattr->stream_attr_in->timeout;
423                                 strm_obj->num_bufs =
424                                     pattr->stream_attr_in->num_bufs;
425                                 strm_obj->strm_mode =
426                                     pattr->stream_attr_in->strm_mode;
427                                 strm_obj->segment_id =
428                                     pattr->stream_attr_in->segment_id;
429                                 strm_obj->buf_alignment =
430                                     pattr->stream_attr_in->buf_alignment;
431                                 strm_obj->dma_chnl_id =
432                                     pattr->stream_attr_in->dma_chnl_id;
433                                 strm_obj->dma_priority =
434                                     pattr->stream_attr_in->dma_priority;
435                                 chnl_attr_obj.uio_reqs =
436                                     pattr->stream_attr_in->num_bufs;
437                         } else {
438                                 strm_obj->timeout = DEFAULTTIMEOUT;
439                                 strm_obj->num_bufs = DEFAULTNUMBUFS;
440                                 strm_obj->strm_mode = STRMMODE_PROCCOPY;
441                                 strm_obj->segment_id = 0;       /* local mem */
442                                 strm_obj->buf_alignment = 0;
443                                 strm_obj->dma_chnl_id = 0;
444                                 strm_obj->dma_priority = 0;
445                                 chnl_attr_obj.uio_reqs = DEFAULTNUMBUFS;
446                         }
447                         chnl_attr_obj.reserved1 = NULL;
448                         /* DMA chnl flush timeout */
449                         chnl_attr_obj.reserved2 = strm_obj->timeout;
450                         chnl_attr_obj.event_obj = NULL;
451                         if (pattr->user_event != NULL)
452                                 chnl_attr_obj.event_obj = pattr->user_event;
453
454                 }
455         }
456         if (status)
457                 goto func_cont;
458
459         if ((pattr->virt_base == NULL) || !(pattr->virt_size > 0))
460                 goto func_cont;
461
462         /* No System DMA */
463         /* Get the shared mem mgr for this streams dev object */
464         status = dev_get_cmm_mgr(strm_mgr_obj->dev_obj, &hcmm_mgr);
465         if (!status) {
466                 /*Allocate a SM addr translator for this strm. */
467                 status = cmm_xlator_create(&strm_obj->xlator, hcmm_mgr, NULL);
468                 if (!status) {
469                         /*  Set translators Virt Addr attributes */
470                         status = cmm_xlator_info(strm_obj->xlator,
471                                                  (u8 **) &pattr->virt_base,
472                                                  pattr->virt_size,
473                                                  strm_obj->segment_id, true);
474                 }
475         }
476 func_cont:
477         if (!status) {
478                 /* Open channel */
479                 chnl_mode = (dir == DSP_TONODE) ?
480                     CHNL_MODETODSP : CHNL_MODEFROMDSP;
481                 intf_fxns = strm_mgr_obj->intf_fxns;
482                 status = (*intf_fxns->chnl_open) (&(strm_obj->chnl_obj),
483                                                       strm_mgr_obj->chnl_mgr,
484                                                       chnl_mode, ul_chnl_id,
485                                                       &chnl_attr_obj);
486                 if (status) {
487                         /*
488                          * over-ride non-returnable status codes so we return
489                          * something documented
490                          */
491                         if (status != -ENOMEM && status !=
492                             -EINVAL && status != -EPERM) {
493                                 /*
494                                  * We got a status that's not return-able.
495                                  * Assert that we got something we were
496                                  * expecting (-EFAULT isn't acceptable,
497                                  * strm_mgr_obj->chnl_mgr better be valid or we
498                                  * assert here), and then return -EPERM.
499                                  */
500                                 status = -EPERM;
501                         }
502                 }
503         }
504         if (!status) {
505                 status = drv_proc_insert_strm_res_element(strm_obj,
506                                                         &stream_res, pr_ctxt);
507                 if (status)
508                         delete_strm(strm_obj);
509                 else
510                         *strmres = (struct strm_res_object *)stream_res;
511         } else {
512                 (void)delete_strm(strm_obj);
513         }
514
515         dev_dbg(bridge, "%s: hnode: %p dir: 0x%x index: 0x%x pattr: %p "
516                 "strmres: %p status: 0x%x\n", __func__,
517                 hnode, dir, index, pattr, strmres, status);
518         return status;
519 }
520
521 /*
522  *  ======== strm_reclaim ========
523  *  Purpose:
524  *      Relcaims a buffer from a stream.
525  */
526 int strm_reclaim(struct strm_object *stream_obj, u8 ** buf_ptr,
527                         u32 *nbytes, u32 *buff_size, u32 *pdw_arg)
528 {
529         struct bridge_drv_interface *intf_fxns;
530         struct chnl_ioc chnl_ioc_obj;
531         int status = 0;
532         void *tmp_buf = NULL;
533
534         if (!stream_obj) {
535                 status = -EFAULT;
536                 goto func_end;
537         }
538         intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
539
540         status =
541             (*intf_fxns->chnl_get_ioc) (stream_obj->chnl_obj,
542                                             stream_obj->timeout,
543                                             &chnl_ioc_obj);
544         if (!status) {
545                 *nbytes = chnl_ioc_obj.byte_size;
546                 if (buff_size)
547                         *buff_size = chnl_ioc_obj.buf_size;
548
549                 *pdw_arg = chnl_ioc_obj.arg;
550                 if (!CHNL_IS_IO_COMPLETE(chnl_ioc_obj)) {
551                         if (CHNL_IS_TIMED_OUT(chnl_ioc_obj)) {
552                                 status = -ETIME;
553                         } else {
554                                 /* Allow reclaims after idle to succeed */
555                                 if (!CHNL_IS_IO_CANCELLED(chnl_ioc_obj))
556                                         status = -EPERM;
557
558                         }
559                 }
560                 /* Translate zerocopy buffer if channel not canceled. */
561                 if (!status
562                     && (!CHNL_IS_IO_CANCELLED(chnl_ioc_obj))
563                     && (stream_obj->strm_mode == STRMMODE_ZEROCOPY)) {
564                         /*
565                          *  This is a zero-copy channel so chnl_ioc_obj.buf
566                          *  contains the DSP address of SM. We need to
567                          *  translate it to a virtual address for the user
568                          *  thread to access.
569                          *  Note: Could add CMM_DSPPA2VA to CMM in the future.
570                          */
571                         tmp_buf = cmm_xlator_translate(stream_obj->xlator,
572                                                        chnl_ioc_obj.buf,
573                                                        CMM_DSPPA2PA);
574                         if (tmp_buf != NULL) {
575                                 /* now convert this GPP Pa to Va */
576                                 tmp_buf = cmm_xlator_translate(stream_obj->
577                                                                xlator,
578                                                                tmp_buf,
579                                                                CMM_PA2VA);
580                         }
581                         if (tmp_buf == NULL)
582                                 status = -ESRCH;
583
584                         chnl_ioc_obj.buf = tmp_buf;
585                 }
586                 *buf_ptr = chnl_ioc_obj.buf;
587         }
588 func_end:
589         dev_dbg(bridge, "%s: stream_obj: %p buf_ptr: %p nbytes: %p "
590                 "pdw_arg: %p status 0x%x\n", __func__, stream_obj,
591                 buf_ptr, nbytes, pdw_arg, status);
592         return status;
593 }
594
595 /*
596  *  ======== strm_register_notify ========
597  *  Purpose:
598  *      Register to be notified on specific events for this stream.
599  */
600 int strm_register_notify(struct strm_object *stream_obj, u32 event_mask,
601                                 u32 notify_type, struct dsp_notification
602                                 * hnotification)
603 {
604         struct bridge_drv_interface *intf_fxns;
605         int status = 0;
606
607         if (!stream_obj) {
608                 status = -EFAULT;
609         } else if ((event_mask & ~((DSP_STREAMIOCOMPLETION) |
610                                    DSP_STREAMDONE)) != 0) {
611                 status = -EINVAL;
612         } else {
613                 if (notify_type != DSP_SIGNALEVENT)
614                         status = -ENOSYS;
615
616         }
617         if (!status) {
618                 intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
619
620                 status =
621                     (*intf_fxns->chnl_register_notify) (stream_obj->
622                                                             chnl_obj,
623                                                             event_mask,
624                                                             notify_type,
625                                                             hnotification);
626         }
627
628         return status;
629 }
630
631 /*
632  *  ======== strm_select ========
633  *  Purpose:
634  *      Selects a ready stream.
635  */
636 int strm_select(struct strm_object **strm_tab, u32 strms,
637                        u32 *pmask, u32 utimeout)
638 {
639         u32 index;
640         struct chnl_info chnl_info_obj;
641         struct bridge_drv_interface *intf_fxns;
642         struct sync_object **sync_events = NULL;
643         u32 i;
644         int status = 0;
645
646         *pmask = 0;
647         for (i = 0; i < strms; i++) {
648                 if (!strm_tab[i]) {
649                         status = -EFAULT;
650                         break;
651                 }
652         }
653         if (status)
654                 goto func_end;
655
656         /* Determine which channels have IO ready */
657         for (i = 0; i < strms; i++) {
658                 intf_fxns = strm_tab[i]->strm_mgr_obj->intf_fxns;
659                 status = (*intf_fxns->chnl_get_info) (strm_tab[i]->chnl_obj,
660                                                           &chnl_info_obj);
661                 if (status) {
662                         break;
663                 } else {
664                         if (chnl_info_obj.cio_cs > 0)
665                                 *pmask |= (1 << i);
666
667                 }
668         }
669         if (!status && utimeout > 0 && *pmask == 0) {
670                 /* Non-zero timeout */
671                 sync_events = kmalloc(strms * sizeof(struct sync_object *),
672                                                                 GFP_KERNEL);
673
674                 if (sync_events == NULL) {
675                         status = -ENOMEM;
676                 } else {
677                         for (i = 0; i < strms; i++) {
678                                 intf_fxns =
679                                     strm_tab[i]->strm_mgr_obj->intf_fxns;
680                                 status = (*intf_fxns->chnl_get_info)
681                                     (strm_tab[i]->chnl_obj, &chnl_info_obj);
682                                 if (status)
683                                         break;
684                                 else
685                                         sync_events[i] =
686                                             chnl_info_obj.sync_event;
687
688                         }
689                 }
690                 if (!status) {
691                         status =
692                             sync_wait_on_multiple_events(sync_events, strms,
693                                                          utimeout, &index);
694                         if (!status) {
695                                 /* Since we waited on the event, we have to
696                                  * reset it */
697                                 sync_set_event(sync_events[index]);
698                                 *pmask = 1 << index;
699                         }
700                 }
701         }
702 func_end:
703         kfree(sync_events);
704
705         return status;
706 }
707
708 /*
709  *  ======== delete_strm ========
710  *  Purpose:
711  *      Frees the resources allocated for a stream.
712  */
713 static int delete_strm(struct strm_object *stream_obj)
714 {
715         struct bridge_drv_interface *intf_fxns;
716         int status = 0;
717
718         if (stream_obj) {
719                 if (stream_obj->chnl_obj) {
720                         intf_fxns = stream_obj->strm_mgr_obj->intf_fxns;
721                         /* Channel close can fail only if the channel handle
722                          * is invalid. */
723                         status = (*intf_fxns->chnl_close)
724                                         (stream_obj->chnl_obj);
725                 }
726                 /* Free all SM address translator resources */
727                 kfree(stream_obj->xlator);
728                 kfree(stream_obj);
729         } else {
730                 status = -EFAULT;
731         }
732         return status;
733 }