/* * strm.c * * DSP-BIOS Bridge driver support functions for TI OMAP processors. * * DSP/BIOS Bridge Stream Manager. * * Copyright (C) 2005-2006 Texas Instruments, Inc. * * This package is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ #include <linux/types.h> /* ----------------------------------- Host OS */ #include <dspbridge/host_os.h> /* ----------------------------------- DSP/BIOS Bridge */ #include <dspbridge/dbdefs.h> /* ----------------------------------- OS Adaptation Layer */ #include <dspbridge/sync.h> /* ----------------------------------- Bridge Driver */ #include <dspbridge/dspdefs.h> /* ----------------------------------- Resource Manager */ #include <dspbridge/nodepriv.h> /* ----------------------------------- Others */ #include <dspbridge/cmm.h> /* ----------------------------------- This */ #include <dspbridge/strm.h> #include <dspbridge/resourcecleanup.h> /* ----------------------------------- Defines, Data Structures, Typedefs */ #define DEFAULTTIMEOUT 10000 #define DEFAULTNUMBUFS 2 /* * ======== strm_mgr ======== * The strm_mgr contains device information needed to open the underlying * channels of a stream. */ struct strm_mgr { struct dev_object *dev_obj; /* Device for this processor */ struct chnl_mgr *chnl_mgr; /* Channel manager */ /* Function interface to Bridge driver */ struct bridge_drv_interface *intf_fxns; }; /* * ======== strm_object ======== * This object is allocated in strm_open(). */ struct strm_object { struct strm_mgr *strm_mgr_obj; struct chnl_object *chnl_obj; u32 dir; /* DSP_TONODE or DSP_FROMNODE */ u32 timeout; u32 num_bufs; /* Max # of bufs allowed in stream */ u32 bufs_in_strm; /* Current # of bufs in stream */ u32 bytes; /* bytes transferred since idled */ /* STREAM_IDLE, STREAM_READY, ... */ enum dsp_streamstate strm_state; void *user_event; /* Saved for strm_get_info() */ enum dsp_strmmode strm_mode; /* STRMMODE_[PROCCOPY][ZEROCOPY]... */ u32 dma_chnl_id; /* DMA chnl id */ u32 dma_priority; /* DMA priority:DMAPRI_[LOW][HIGH] */ u32 segment_id; /* >0 is SM segment.=0 is local heap */ u32 buf_alignment; /* Alignment for stream bufs */ /* Stream's SM address translator */ struct cmm_xlatorobject *xlator; }; /* ----------------------------------- Function Prototypes */ static int delete_strm(struct strm_object *stream_obj); /* * ======== strm_allocate_buffer ======== * Purpose: * Allocates buffers for a stream. */ int strm_allocate_buffer(struct strm_res_object *strmres, u32 usize, u8 **ap_buffer, u32 num_bufs, struct process_context *pr_ctxt) { int status = 0; u32 alloc_cnt = 0; u32 i; struct strm_object *stream_obj = strmres->stream; if (stream_obj) { /* * Allocate from segment specified at time of stream open. */ if (usize == 0) status = -EINVAL; } else { status = -EFAULT; } if (status) goto func_end; for (i = 0; i < num_bufs; i++) { (void)cmm_xlator_alloc_buf(stream_obj->xlator, &ap_buffer[i], usize); if (ap_buffer[i] == NULL) { status = -ENOMEM; alloc_cnt = i; break; } } if (status) strm_free_buffer(strmres, ap_buffer, alloc_cnt, pr_ctxt); if (status) goto func_end; drv_proc_update_strm_res(num_bufs, strmres); func_end: return status; } /* * ======== strm_close ======== * Purpose: * Close a stream opened with strm_open(). */ int strm_close(struct strm_res_object *strmres, struct process_context *pr_ctxt) { struct bridge_drv_interface *intf_fxns; struct chnl_info chnl_info_obj; int status = 0; struct strm_object *stream_obj = strmres->stream; if (!stream_obj) { status = -EFAULT; } else { /* Have all buffers been reclaimed? If not, return * -EPIPE */ intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_get_info) (stream_obj->chnl_obj, &chnl_info_obj); if (chnl_info_obj.cio_cs > 0 || chnl_info_obj.cio_reqs > 0) status = -EPIPE; else status = delete_strm(stream_obj); } if (status) goto func_end; idr_remove(pr_ctxt->stream_id, strmres->id); func_end: dev_dbg(bridge, "%s: stream_obj: %p, status 0x%x\n", __func__, stream_obj, status); return status; } /* * ======== strm_create ======== * Purpose: * Create a STRM manager object. */ int strm_create(struct strm_mgr **strm_man, struct dev_object *dev_obj) { struct strm_mgr *strm_mgr_obj; int status = 0; *strm_man = NULL; /* Allocate STRM manager object */ strm_mgr_obj = kzalloc(sizeof(struct strm_mgr), GFP_KERNEL); if (strm_mgr_obj == NULL) status = -ENOMEM; else strm_mgr_obj->dev_obj = dev_obj; /* Get Channel manager and Bridge function interface */ if (!status) { status = dev_get_chnl_mgr(dev_obj, &(strm_mgr_obj->chnl_mgr)); if (!status) { (void)dev_get_intf_fxns(dev_obj, &(strm_mgr_obj->intf_fxns)); } } if (!status) *strm_man = strm_mgr_obj; else kfree(strm_mgr_obj); return status; } /* * ======== strm_delete ======== * Purpose: * Delete the STRM Manager Object. */ void strm_delete(struct strm_mgr *strm_mgr_obj) { kfree(strm_mgr_obj); } /* * ======== strm_free_buffer ======== * Purpose: * Frees the buffers allocated for a stream. */ int strm_free_buffer(struct strm_res_object *strmres, u8 ** ap_buffer, u32 num_bufs, struct process_context *pr_ctxt) { int status = 0; u32 i = 0; struct strm_object *stream_obj = strmres->stream; if (!stream_obj) status = -EFAULT; if (!status) { for (i = 0; i < num_bufs; i++) { status = cmm_xlator_free_buf(stream_obj->xlator, ap_buffer[i]); if (status) break; ap_buffer[i] = NULL; } } drv_proc_update_strm_res(num_bufs - i, strmres); return status; } /* * ======== strm_get_info ======== * Purpose: * Retrieves information about a stream. */ int strm_get_info(struct strm_object *stream_obj, struct stream_info *stream_info, u32 stream_info_size) { struct bridge_drv_interface *intf_fxns; struct chnl_info chnl_info_obj; int status = 0; void *virt_base = NULL; /* NULL if no SM used */ if (!stream_obj) { status = -EFAULT; } else { if (stream_info_size < sizeof(struct stream_info)) { /* size of users info */ status = -EINVAL; } } if (status) goto func_end; intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_get_info) (stream_obj->chnl_obj, &chnl_info_obj); if (status) goto func_end; if (stream_obj->xlator) { /* We have a translator */ cmm_xlator_info(stream_obj->xlator, (u8 **) &virt_base, 0, stream_obj->segment_id, false); } stream_info->segment_id = stream_obj->segment_id; stream_info->strm_mode = stream_obj->strm_mode; stream_info->virt_base = virt_base; stream_info->user_strm->number_bufs_allowed = stream_obj->num_bufs; stream_info->user_strm->number_bufs_in_stream = chnl_info_obj.cio_cs + chnl_info_obj.cio_reqs; /* # of bytes transferred since last call to DSPStream_Idle() */ stream_info->user_strm->number_bytes = chnl_info_obj.bytes_tx; stream_info->user_strm->sync_object_handle = chnl_info_obj.event_obj; /* Determine stream state based on channel state and info */ if (chnl_info_obj.state & CHNL_STATEEOS) { stream_info->user_strm->ss_stream_state = STREAM_DONE; } else { if (chnl_info_obj.cio_cs > 0) stream_info->user_strm->ss_stream_state = STREAM_READY; else if (chnl_info_obj.cio_reqs > 0) stream_info->user_strm->ss_stream_state = STREAM_PENDING; else stream_info->user_strm->ss_stream_state = STREAM_IDLE; } func_end: return status; } /* * ======== strm_idle ======== * Purpose: * Idles a particular stream. */ int strm_idle(struct strm_object *stream_obj, bool flush_data) { struct bridge_drv_interface *intf_fxns; int status = 0; if (!stream_obj) { status = -EFAULT; } else { intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_idle) (stream_obj->chnl_obj, stream_obj->timeout, flush_data); } dev_dbg(bridge, "%s: stream_obj: %p flush_data: 0x%x status: 0x%x\n", __func__, stream_obj, flush_data, status); return status; } /* * ======== strm_issue ======== * Purpose: * Issues a buffer on a stream */ int strm_issue(struct strm_object *stream_obj, u8 *pbuf, u32 ul_bytes, u32 ul_buf_size, u32 dw_arg) { struct bridge_drv_interface *intf_fxns; int status = 0; void *tmp_buf = NULL; if (!stream_obj) { status = -EFAULT; } else { intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; if (stream_obj->segment_id != 0) { tmp_buf = cmm_xlator_translate(stream_obj->xlator, (void *)pbuf, CMM_VA2DSPPA); if (tmp_buf == NULL) status = -ESRCH; } if (!status) { status = (*intf_fxns->chnl_add_io_req) (stream_obj->chnl_obj, pbuf, ul_bytes, ul_buf_size, (u32) tmp_buf, dw_arg); } if (status == -EIO) status = -ENOSR; } dev_dbg(bridge, "%s: stream_obj: %p pbuf: %p ul_bytes: 0x%x dw_arg:" " 0x%x status: 0x%x\n", __func__, stream_obj, pbuf, ul_bytes, dw_arg, status); return status; } /* * ======== strm_open ======== * Purpose: * Open a stream for sending/receiving data buffers to/from a task or * XDAIS socket node on the DSP. */ int strm_open(struct node_object *hnode, u32 dir, u32 index, struct strm_attr *pattr, struct strm_res_object **strmres, struct process_context *pr_ctxt) { struct strm_mgr *strm_mgr_obj; struct bridge_drv_interface *intf_fxns; u32 ul_chnl_id; struct strm_object *strm_obj = NULL; s8 chnl_mode; struct chnl_attr chnl_attr_obj; int status = 0; struct cmm_object *hcmm_mgr = NULL; /* Shared memory manager hndl */ void *stream_res; *strmres = NULL; if (dir != DSP_TONODE && dir != DSP_FROMNODE) { status = -EPERM; } else { /* Get the channel id from the node (set in node_connect()) */ status = node_get_channel_id(hnode, dir, index, &ul_chnl_id); } if (!status) status = node_get_strm_mgr(hnode, &strm_mgr_obj); if (!status) { strm_obj = kzalloc(sizeof(struct strm_object), GFP_KERNEL); if (strm_obj == NULL) { status = -ENOMEM; } else { strm_obj->strm_mgr_obj = strm_mgr_obj; strm_obj->dir = dir; strm_obj->strm_state = STREAM_IDLE; strm_obj->user_event = pattr->user_event; if (pattr->stream_attr_in != NULL) { strm_obj->timeout = pattr->stream_attr_in->timeout; strm_obj->num_bufs = pattr->stream_attr_in->num_bufs; strm_obj->strm_mode = pattr->stream_attr_in->strm_mode; strm_obj->segment_id = pattr->stream_attr_in->segment_id; strm_obj->buf_alignment = pattr->stream_attr_in->buf_alignment; strm_obj->dma_chnl_id = pattr->stream_attr_in->dma_chnl_id; strm_obj->dma_priority = pattr->stream_attr_in->dma_priority; chnl_attr_obj.uio_reqs = pattr->stream_attr_in->num_bufs; } else { strm_obj->timeout = DEFAULTTIMEOUT; strm_obj->num_bufs = DEFAULTNUMBUFS; strm_obj->strm_mode = STRMMODE_PROCCOPY; strm_obj->segment_id = 0; /* local mem */ strm_obj->buf_alignment = 0; strm_obj->dma_chnl_id = 0; strm_obj->dma_priority = 0; chnl_attr_obj.uio_reqs = DEFAULTNUMBUFS; } chnl_attr_obj.reserved1 = NULL; /* DMA chnl flush timeout */ chnl_attr_obj.reserved2 = strm_obj->timeout; chnl_attr_obj.event_obj = NULL; if (pattr->user_event != NULL) chnl_attr_obj.event_obj = pattr->user_event; } } if (status) goto func_cont; if ((pattr->virt_base == NULL) || !(pattr->virt_size > 0)) goto func_cont; /* No System DMA */ /* Get the shared mem mgr for this streams dev object */ status = dev_get_cmm_mgr(strm_mgr_obj->dev_obj, &hcmm_mgr); if (!status) { /*Allocate a SM addr translator for this strm. */ status = cmm_xlator_create(&strm_obj->xlator, hcmm_mgr, NULL); if (!status) { /* Set translators Virt Addr attributes */ status = cmm_xlator_info(strm_obj->xlator, (u8 **) &pattr->virt_base, pattr->virt_size, strm_obj->segment_id, true); } } func_cont: if (!status) { /* Open channel */ chnl_mode = (dir == DSP_TONODE) ? CHNL_MODETODSP : CHNL_MODEFROMDSP; intf_fxns = strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_open) (&(strm_obj->chnl_obj), strm_mgr_obj->chnl_mgr, chnl_mode, ul_chnl_id, &chnl_attr_obj); if (status) { /* * over-ride non-returnable status codes so we return * something documented */ if (status != -ENOMEM && status != -EINVAL && status != -EPERM) { /* * We got a status that's not return-able. * Assert that we got something we were * expecting (-EFAULT isn't acceptable, * strm_mgr_obj->chnl_mgr better be valid or we * assert here), and then return -EPERM. */ status = -EPERM; } } } if (!status) { status = drv_proc_insert_strm_res_element(strm_obj, &stream_res, pr_ctxt); if (status) delete_strm(strm_obj); else *strmres = (struct strm_res_object *)stream_res; } else { (void)delete_strm(strm_obj); } dev_dbg(bridge, "%s: hnode: %p dir: 0x%x index: 0x%x pattr: %p " "strmres: %p status: 0x%x\n", __func__, hnode, dir, index, pattr, strmres, status); return status; } /* * ======== strm_reclaim ======== * Purpose: * Relcaims a buffer from a stream. */ 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; struct chnl_ioc chnl_ioc_obj; int status = 0; void *tmp_buf = NULL; if (!stream_obj) { status = -EFAULT; goto func_end; } intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_get_ioc) (stream_obj->chnl_obj, stream_obj->timeout, &chnl_ioc_obj); if (!status) { *nbytes = chnl_ioc_obj.byte_size; if (buff_size) *buff_size = chnl_ioc_obj.buf_size; *pdw_arg = chnl_ioc_obj.arg; if (!CHNL_IS_IO_COMPLETE(chnl_ioc_obj)) { if (CHNL_IS_TIMED_OUT(chnl_ioc_obj)) { status = -ETIME; } else { /* Allow reclaims after idle to succeed */ if (!CHNL_IS_IO_CANCELLED(chnl_ioc_obj)) status = -EPERM; } } /* Translate zerocopy buffer if channel not canceled. */ if (!status && (!CHNL_IS_IO_CANCELLED(chnl_ioc_obj)) && (stream_obj->strm_mode == STRMMODE_ZEROCOPY)) { /* * This is a zero-copy channel so chnl_ioc_obj.buf * contains the DSP address of SM. We need to * translate it to a virtual address for the user * thread to access. * Note: Could add CMM_DSPPA2VA to CMM in the future. */ tmp_buf = cmm_xlator_translate(stream_obj->xlator, chnl_ioc_obj.buf, CMM_DSPPA2PA); if (tmp_buf != NULL) { /* now convert this GPP Pa to Va */ tmp_buf = cmm_xlator_translate(stream_obj-> xlator, tmp_buf, CMM_PA2VA); } if (tmp_buf == NULL) status = -ESRCH; chnl_ioc_obj.buf = tmp_buf; } *buf_ptr = chnl_ioc_obj.buf; } func_end: dev_dbg(bridge, "%s: stream_obj: %p buf_ptr: %p nbytes: %p " "pdw_arg: %p status 0x%x\n", __func__, stream_obj, buf_ptr, nbytes, pdw_arg, status); return status; } /* * ======== strm_register_notify ======== * Purpose: * Register to be notified on specific events for this stream. */ int strm_register_notify(struct strm_object *stream_obj, u32 event_mask, u32 notify_type, struct dsp_notification * hnotification) { struct bridge_drv_interface *intf_fxns; int status = 0; if (!stream_obj) { status = -EFAULT; } else if ((event_mask & ~((DSP_STREAMIOCOMPLETION) | DSP_STREAMDONE)) != 0) { status = -EINVAL; } else { if (notify_type != DSP_SIGNALEVENT) status = -ENOSYS; } if (!status) { intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_register_notify) (stream_obj-> chnl_obj, event_mask, notify_type, hnotification); } return status; } /* * ======== strm_select ======== * Purpose: * Selects a ready stream. */ int strm_select(struct strm_object **strm_tab, u32 strms, u32 *pmask, u32 utimeout) { u32 index; struct chnl_info chnl_info_obj; struct bridge_drv_interface *intf_fxns; struct sync_object **sync_events = NULL; u32 i; int status = 0; *pmask = 0; for (i = 0; i < strms; i++) { if (!strm_tab[i]) { status = -EFAULT; break; } } if (status) goto func_end; /* Determine which channels have IO ready */ for (i = 0; i < strms; i++) { intf_fxns = strm_tab[i]->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_get_info) (strm_tab[i]->chnl_obj, &chnl_info_obj); if (status) { break; } else { if (chnl_info_obj.cio_cs > 0) *pmask |= (1 << i); } } if (!status && utimeout > 0 && *pmask == 0) { /* Non-zero timeout */ sync_events = kmalloc(strms * sizeof(struct sync_object *), GFP_KERNEL); if (sync_events == NULL) { status = -ENOMEM; } else { for (i = 0; i < strms; i++) { intf_fxns = strm_tab[i]->strm_mgr_obj->intf_fxns; status = (*intf_fxns->chnl_get_info) (strm_tab[i]->chnl_obj, &chnl_info_obj); if (status) break; else sync_events[i] = chnl_info_obj.sync_event; } } if (!status) { status = sync_wait_on_multiple_events(sync_events, strms, utimeout, &index); if (!status) { /* Since we waited on the event, we have to * reset it */ sync_set_event(sync_events[index]); *pmask = 1 << index; } } } func_end: kfree(sync_events); return status; } /* * ======== delete_strm ======== * Purpose: * Frees the resources allocated for a stream. */ static int delete_strm(struct strm_object *stream_obj) { struct bridge_drv_interface *intf_fxns; int status = 0; if (stream_obj) { if (stream_obj->chnl_obj) { intf_fxns = stream_obj->strm_mgr_obj->intf_fxns; /* Channel close can fail only if the channel handle * is invalid. */ status = (*intf_fxns->chnl_close) (stream_obj->chnl_obj); } /* Free all SM address translator resources */ kfree(stream_obj->xlator); kfree(stream_obj); } else { status = -EFAULT; } return status; }