| /* |
| * dspdefs.h |
| * |
| * DSP-BIOS Bridge driver support functions for TI OMAP processors. |
| * |
| * Bridge driver entry point and interface function declarations. |
| * |
| * Notes: |
| * The DSP API obtains it's function interface to |
| * the Bridge driver via a call to bridge_drv_entry(). |
| * |
| * Bridge services exported to Bridge drivers are initialized by the |
| * DSP API on behalf of the Bridge driver. |
| * |
| * Bridge function DBC Requires and Ensures are also made by the DSP API on |
| * behalf of the Bridge driver, to simplify the Bridge driver code. |
| * |
| * 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. |
| */ |
| |
| #ifndef DSPDEFS_ |
| #define DSPDEFS_ |
| |
| #include <dspbridge/brddefs.h> |
| #include <dspbridge/cfgdefs.h> |
| #include <dspbridge/chnlpriv.h> |
| #include <dspbridge/dspdeh.h> |
| #include <dspbridge/devdefs.h> |
| #include <dspbridge/io.h> |
| #include <dspbridge/msgdefs.h> |
| |
| /* Handle to Bridge driver's private device context. */ |
| struct bridge_dev_context; |
| |
| /*--------------------------------------------------------------------------- */ |
| /* BRIDGE DRIVER FUNCTION TYPES */ |
| /*--------------------------------------------------------------------------- */ |
| |
| /* |
| * ======== bridge_brd_monitor ======== |
| * Purpose: |
| * Bring the board to the BRD_IDLE (monitor) state. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device context. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL |
| * Ensures: |
| * 0: Board is in BRD_IDLE state; |
| * else: Board state is indeterminate. |
| */ |
| typedef int(*fxn_brd_monitor) (struct bridge_dev_context *dev_ctxt); |
| |
| /* |
| * ======== fxn_brd_setstate ======== |
| * Purpose: |
| * Sets the Bridge driver state |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * brd_state: Board state |
| * Returns: |
| * 0: Success. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * brd_state <= BRD_LASTSTATE. |
| * Ensures: |
| * brd_state <= BRD_LASTSTATE. |
| * Update the Board state to the specified state. |
| */ |
| typedef int(*fxn_brd_setstate) (struct bridge_dev_context |
| * dev_ctxt, u32 brd_state); |
| |
| /* |
| * ======== bridge_brd_start ======== |
| * Purpose: |
| * Bring board to the BRD_RUNNING (start) state. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device context. |
| * dsp_addr: DSP address at which to start execution. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL |
| * Board is in monitor (BRD_IDLE) state. |
| * Ensures: |
| * 0: Board is in BRD_RUNNING state. |
| * Interrupts to the PC are enabled. |
| * else: Board state is indeterminate. |
| */ |
| typedef int(*fxn_brd_start) (struct bridge_dev_context |
| * dev_ctxt, u32 dsp_addr); |
| |
| /* |
| * ======== bridge_brd_mem_copy ======== |
| * Purpose: |
| * Copy memory from one DSP address to another |
| * Parameters: |
| * dev_context: Pointer to context handle |
| * dsp_dest_addr: DSP address to copy to |
| * dsp_src_addr: DSP address to copy from |
| * ul_num_bytes: Number of bytes to copy |
| * mem_type: What section of memory to copy to |
| * Returns: |
| * 0: Success. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_context != NULL |
| * Ensures: |
| * 0: Board is in BRD_RUNNING state. |
| * Interrupts to the PC are enabled. |
| * else: Board state is indeterminate. |
| */ |
| typedef int(*fxn_brd_memcopy) (struct bridge_dev_context |
| * dev_ctxt, |
| u32 dsp_dest_addr, |
| u32 dsp_src_addr, |
| u32 ul_num_bytes, u32 mem_type); |
| /* |
| * ======== bridge_brd_mem_write ======== |
| * Purpose: |
| * Write a block of host memory into a DSP address, into a given memory |
| * space. Unlike bridge_brd_write, this API does reset the DSP |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * dsp_addr: Address on DSP board (Destination). |
| * host_buf: Pointer to host buffer (Source). |
| * ul_num_bytes: Number of bytes to transfer. |
| * mem_type: Memory space on DSP to which to transfer. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * host_buf != NULL. |
| * Ensures: |
| */ |
| typedef int(*fxn_brd_memwrite) (struct bridge_dev_context |
| * dev_ctxt, |
| u8 *host_buf, |
| u32 dsp_addr, u32 ul_num_bytes, |
| u32 mem_type); |
| |
| /* |
| * ======== bridge_brd_mem_map ======== |
| * Purpose: |
| * Map a MPU memory region to a DSP/IVA memory space |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * ul_mpu_addr: MPU memory region start address. |
| * virt_addr: DSP/IVA memory region u8 address. |
| * ul_num_bytes: Number of bytes to map. |
| * map_attrs: Mapping attributes (e.g. endianness). |
| * Returns: |
| * 0: Success. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * Ensures: |
| */ |
| typedef int(*fxn_brd_memmap) (struct bridge_dev_context |
| * dev_ctxt, u32 ul_mpu_addr, |
| u32 virt_addr, u32 ul_num_bytes, |
| u32 map_attr, |
| struct page **mapped_pages); |
| |
| /* |
| * ======== bridge_brd_mem_un_map ======== |
| * Purpose: |
| * UnMap an MPU memory region from DSP/IVA memory space |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * virt_addr: DSP/IVA memory region u8 address. |
| * ul_num_bytes: Number of bytes to unmap. |
| * Returns: |
| * 0: Success. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * Ensures: |
| */ |
| typedef int(*fxn_brd_memunmap) (struct bridge_dev_context |
| * dev_ctxt, |
| u32 virt_addr, u32 ul_num_bytes); |
| |
| /* |
| * ======== bridge_brd_stop ======== |
| * Purpose: |
| * Bring board to the BRD_STOPPED state. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device context. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL |
| * Ensures: |
| * 0: Board is in BRD_STOPPED (stop) state; |
| * Interrupts to the PC are disabled. |
| * else: Board state is indeterminate. |
| */ |
| typedef int(*fxn_brd_stop) (struct bridge_dev_context *dev_ctxt); |
| |
| /* |
| * ======== bridge_brd_status ======== |
| * Purpose: |
| * Report the current state of the board. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device context. |
| * board_state: Ptr to BRD status variable. |
| * Returns: |
| * 0: |
| * Requires: |
| * board_state != NULL; |
| * dev_ctxt != NULL |
| * Ensures: |
| * *board_state is one of |
| * {BRD_STOPPED, BRD_IDLE, BRD_RUNNING, BRD_UNKNOWN}; |
| */ |
| typedef int(*fxn_brd_status) (struct bridge_dev_context *dev_ctxt, |
| int *board_state); |
| |
| /* |
| * ======== bridge_brd_read ======== |
| * Purpose: |
| * Read a block of DSP memory, from a given memory space, into a host |
| * buffer. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * host_buf: Pointer to host buffer (Destination). |
| * dsp_addr: Address on DSP board (Source). |
| * ul_num_bytes: Number of bytes to transfer. |
| * mem_type: Memory space on DSP from which to transfer. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * host_buf != NULL. |
| * Ensures: |
| * Will not write more than ul_num_bytes bytes into host_buf. |
| */ |
| typedef int(*fxn_brd_read) (struct bridge_dev_context *dev_ctxt, |
| u8 *host_buf, |
| u32 dsp_addr, |
| u32 ul_num_bytes, u32 mem_type); |
| |
| /* |
| * ======== bridge_brd_write ======== |
| * Purpose: |
| * Write a block of host memory into a DSP address, into a given memory |
| * space. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * dsp_addr: Address on DSP board (Destination). |
| * host_buf: Pointer to host buffer (Source). |
| * ul_num_bytes: Number of bytes to transfer. |
| * mem_type: Memory space on DSP to which to transfer. |
| * Returns: |
| * 0: Success. |
| * -ETIMEDOUT: Timeout occurred waiting for a response from hardware. |
| * -EPERM: Other, unspecified error. |
| * Requires: |
| * dev_ctxt != NULL; |
| * host_buf != NULL. |
| * Ensures: |
| */ |
| typedef int(*fxn_brd_write) (struct bridge_dev_context *dev_ctxt, |
| u8 *host_buf, |
| u32 dsp_addr, |
| u32 ul_num_bytes, u32 mem_type); |
| |
| /* |
| * ======== bridge_chnl_create ======== |
| * Purpose: |
| * Create a channel manager object, responsible for opening new channels |
| * and closing old ones for a given 'Bridge board. |
| * Parameters: |
| * channel_mgr: Location to store a channel manager object on output. |
| * hdev_obj: Handle to a device object. |
| * mgr_attrts: Channel manager attributes. |
| * mgr_attrts->max_channels: Max channels |
| * mgr_attrts->birq: Channel's I/O IRQ number. |
| * mgr_attrts->irq_shared: TRUE if the IRQ is shareable. |
| * mgr_attrts->word_size: DSP Word size in equivalent PC bytes.. |
| * mgr_attrts->shm_base: Base physical address of shared memory, if any. |
| * mgr_attrts->sm_length: Bytes of shared memory block. |
| * Returns: |
| * 0: Success; |
| * -ENOMEM: Insufficient memory for requested resources. |
| * -EIO: Unable to plug ISR for given IRQ. |
| * -EFAULT: Couldn't map physical address to a virtual one. |
| * Requires: |
| * channel_mgr != NULL. |
| * mgr_attrts != NULL |
| * mgr_attrts field are all valid: |
| * 0 < max_channels <= CHNL_MAXCHANNELS. |
| * birq <= 15. |
| * word_size > 0. |
| * hdev_obj != NULL |
| * No channel manager exists for this board. |
| * Ensures: |
| */ |
| typedef int(*fxn_chnl_create) (struct chnl_mgr |
| **channel_mgr, |
| struct dev_object |
| * hdev_obj, |
| const struct |
| chnl_mgrattrs * mgr_attrts); |
| |
| /* |
| * ======== bridge_chnl_destroy ======== |
| * Purpose: |
| * Close all open channels, and destroy the channel manager. |
| * Parameters: |
| * hchnl_mgr: Channel manager object. |
| * Returns: |
| * 0: Success. |
| * -EFAULT: hchnl_mgr was invalid. |
| * Requires: |
| * Ensures: |
| * 0: Cancels I/O on each open channel. Closes each open channel. |
| * chnl_create may subsequently be called for the same device. |
| */ |
| typedef int(*fxn_chnl_destroy) (struct chnl_mgr *hchnl_mgr); |
| /* |
| * ======== bridge_deh_notify ======== |
| * Purpose: |
| * When notified of DSP error, take appropriate action. |
| * Parameters: |
| * hdeh_mgr: Handle to DEH manager object. |
| * evnt_mask: Indicate the type of exception |
| * error_info: Error information |
| * Returns: |
| * |
| * Requires: |
| * hdeh_mgr != NULL; |
| * evnt_mask with a valid exception |
| * Ensures: |
| */ |
| typedef void (*fxn_deh_notify) (struct deh_mgr *hdeh_mgr, |
| u32 evnt_mask, u32 error_info); |
| |
| /* |
| * ======== bridge_chnl_open ======== |
| * Purpose: |
| * Open a new half-duplex channel to the DSP board. |
| * Parameters: |
| * chnl: Location to store a channel object handle. |
| * hchnl_mgr: Handle to channel manager, as returned by |
| * CHNL_GetMgr(). |
| * chnl_mode: One of {CHNL_MODETODSP, CHNL_MODEFROMDSP} specifies |
| * direction of data transfer. |
| * ch_id: If CHNL_PICKFREE is specified, the channel manager will |
| * select a free channel id (default); |
| * otherwise this field specifies the id of the channel. |
| * pattrs: Channel attributes. Attribute fields are as follows: |
| * pattrs->uio_reqs: Specifies the maximum number of I/O requests which can |
| * be pending at any given time. All request packets are |
| * preallocated when the channel is opened. |
| * pattrs->event_obj: This field allows the user to supply an auto reset |
| * event object for channel I/O completion notifications. |
| * It is the responsibility of the user to destroy this |
| * object AFTER closing the channel. |
| * This channel event object can be retrieved using |
| * CHNL_GetEventHandle(). |
| * pattrs->hReserved: The kernel mode handle of this event object. |
| * |
| * Returns: |
| * 0: Success. |
| * -EFAULT: hchnl_mgr is invalid. |
| * -ENOMEM: Insufficient memory for requested resources. |
| * -EINVAL: Invalid number of IOReqs. |
| * -ENOSR: No free channels available. |
| * -ECHRNG: Channel ID is out of range. |
| * -EALREADY: Channel is in use. |
| * -EIO: No free IO request packets available for |
| * queuing. |
| * Requires: |
| * chnl != NULL. |
| * pattrs != NULL. |
| * pattrs->event_obj is a valid event handle. |
| * pattrs->hReserved is the kernel mode handle for pattrs->event_obj. |
| * Ensures: |
| * 0: *chnl is a valid channel. |
| * else: *chnl is set to NULL if (chnl != NULL); |
| */ |
| typedef int(*fxn_chnl_open) (struct chnl_object |
| **chnl, |
| struct chnl_mgr *hchnl_mgr, |
| s8 chnl_mode, |
| u32 ch_id, |
| const struct |
| chnl_attr * pattrs); |
| |
| /* |
| * ======== bridge_chnl_close ======== |
| * Purpose: |
| * Ensures all pending I/O on this channel is cancelled, discards all |
| * queued I/O completion notifications, then frees the resources allocated |
| * for this channel, and makes the corresponding logical channel id |
| * available for subsequent use. |
| * Parameters: |
| * chnl_obj: Handle to a channel object. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid chnl_obj. |
| * Requires: |
| * No thread must be blocked on this channel's I/O completion event. |
| * Ensures: |
| * 0: chnl_obj is no longer valid. |
| */ |
| typedef int(*fxn_chnl_close) (struct chnl_object *chnl_obj); |
| |
| /* |
| * ======== bridge_chnl_add_io_req ======== |
| * Purpose: |
| * Enqueue an I/O request for data transfer on a channel to the DSP. |
| * The direction (mode) is specified in the channel object. Note the DSP |
| * address is specified for channels opened in direct I/O mode. |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * host_buf: Host buffer address source. |
| * byte_size: Number of PC bytes to transfer. A zero value indicates |
| * that this buffer is the last in the output channel. |
| * A zero value is invalid for an input channel. |
| *! buf_size: Actual buffer size in host bytes. |
| * dw_dsp_addr: DSP address for transfer. (Currently ignored). |
| * dw_arg: A user argument that travels with the buffer. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid chnl_obj or host_buf. |
| * -EPERM: User cannot mark EOS on an input channel. |
| * -ECANCELED: I/O has been cancelled on this channel. No further |
| * I/O is allowed. |
| * -EPIPE: End of stream was already marked on a previous |
| * IORequest on this channel. No further I/O is expected. |
| * -EINVAL: Buffer submitted to this output channel is larger than |
| * the size of the physical shared memory output window. |
| * Requires: |
| * Ensures: |
| * 0: The buffer will be transferred if the channel is ready; |
| * otherwise, will be queued for transfer when the channel becomes |
| * ready. In any case, notifications of I/O completion are |
| * asynchronous. |
| * If byte_size is 0 for an output channel, subsequent CHNL_AddIOReq's |
| * on this channel will fail with error code -EPIPE. The |
| * corresponding IOC for this I/O request will have its status flag |
| * set to CHNL_IOCSTATEOS. |
| */ |
| typedef int(*fxn_chnl_addioreq) (struct chnl_object |
| * chnl_obj, |
| void *host_buf, |
| u32 byte_size, |
| u32 buf_size, |
| u32 dw_dsp_addr, u32 dw_arg); |
| |
| /* |
| * ======== bridge_chnl_get_ioc ======== |
| * Purpose: |
| * Dequeue an I/O completion record, which contains information about the |
| * completed I/O request. |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * timeout: A value of CHNL_IOCNOWAIT will simply dequeue the |
| * first available IOC. |
| * chan_ioc: On output, contains host buffer address, bytes |
| * transferred, and status of I/O completion. |
| * chan_ioc->status: See chnldefs.h. |
| * Returns: |
| * 0: Success. |
| * -EFAULT: Invalid chnl_obj or chan_ioc. |
| * -EREMOTEIO: CHNL_IOCNOWAIT was specified as the timeout parameter |
| * yet no I/O completions were queued. |
| * Requires: |
| * timeout == CHNL_IOCNOWAIT. |
| * Ensures: |
| * 0: if there are any remaining IOC's queued before this call |
| * returns, the channel event object will be left in a signalled |
| * state. |
| */ |
| typedef int(*fxn_chnl_getioc) (struct chnl_object *chnl_obj, |
| u32 timeout, |
| struct chnl_ioc *chan_ioc); |
| |
| /* |
| * ======== bridge_chnl_cancel_io ======== |
| * Purpose: |
| * Return all I/O requests to the client which have not yet been |
| * transferred. The channel's I/O completion object is |
| * signalled, and all the I/O requests are queued as IOC's, with the |
| * status field set to CHNL_IOCSTATCANCEL. |
| * This call is typically used in abort situations, and is a prelude to |
| * chnl_close(); |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid chnl_obj. |
| * Requires: |
| * Ensures: |
| * Subsequent I/O requests to this channel will not be accepted. |
| */ |
| typedef int(*fxn_chnl_cancelio) (struct chnl_object *chnl_obj); |
| |
| /* |
| * ======== bridge_chnl_flush_io ======== |
| * Purpose: |
| * For an output stream (to the DSP), indicates if any IO requests are in |
| * the output request queue. For input streams (from the DSP), will |
| * cancel all pending IO requests. |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * timeout: Timeout value for flush operation. |
| * Returns: |
| * 0: Success; |
| * S_CHNLIOREQUEST: Returned if any IORequests are in the output queue. |
| * -EFAULT: Invalid chnl_obj. |
| * Requires: |
| * Ensures: |
| * 0: No I/O requests will be pending on this channel. |
| */ |
| typedef int(*fxn_chnl_flushio) (struct chnl_object *chnl_obj, |
| u32 timeout); |
| |
| /* |
| * ======== bridge_chnl_get_info ======== |
| * Purpose: |
| * Retrieve information related to a channel. |
| * Parameters: |
| * chnl_obj: Handle to a valid channel object, or NULL. |
| * channel_info: Location to store channel info. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid chnl_obj or channel_info. |
| * Requires: |
| * Ensures: |
| * 0: channel_info points to a filled in chnl_info struct, |
| * if (channel_info != NULL). |
| */ |
| typedef int(*fxn_chnl_getinfo) (struct chnl_object *chnl_obj, |
| struct chnl_info *channel_info); |
| |
| /* |
| * ======== bridge_chnl_get_mgr_info ======== |
| * Purpose: |
| * Retrieve information related to the channel manager. |
| * Parameters: |
| * hchnl_mgr: Handle to a valid channel manager, or NULL. |
| * ch_id: Channel ID. |
| * mgr_info: Location to store channel manager info. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid hchnl_mgr or mgr_info. |
| * -ECHRNG: Invalid channel ID. |
| * Requires: |
| * Ensures: |
| * 0: mgr_info points to a filled in chnl_mgrinfo |
| * struct, if (mgr_info != NULL). |
| */ |
| typedef int(*fxn_chnl_getmgrinfo) (struct chnl_mgr |
| * hchnl_mgr, |
| u32 ch_id, |
| struct chnl_mgrinfo *mgr_info); |
| |
| /* |
| * ======== bridge_chnl_idle ======== |
| * Purpose: |
| * Idle a channel. If this is an input channel, or if this is an output |
| * channel and flush_data is TRUE, all currently enqueued buffers will be |
| * dequeued (data discarded for output channel). |
| * If this is an output channel and flush_data is FALSE, this function |
| * will block until all currently buffered data is output, or the timeout |
| * specified has been reached. |
| * |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * timeout: If output channel and flush_data is FALSE, timeout value |
| * to wait for buffers to be output. (Not used for |
| * input channel). |
| * flush_data: If output channel and flush_data is TRUE, discard any |
| * currently buffered data. If FALSE, wait for currently |
| * buffered data to be output, or timeout, whichever |
| * occurs first. flush_data is ignored for input channel. |
| * Returns: |
| * 0: Success; |
| * -EFAULT: Invalid chnl_obj. |
| * -ETIMEDOUT: Timeout occurred before channel could be idled. |
| * Requires: |
| * Ensures: |
| */ |
| typedef int(*fxn_chnl_idle) (struct chnl_object *chnl_obj, |
| u32 timeout, bool flush_data); |
| |
| /* |
| * ======== bridge_chnl_register_notify ======== |
| * Purpose: |
| * Register for notification of events on a channel. |
| * Parameters: |
| * chnl_obj: Channel object handle. |
| * event_mask: Type of events to be notified about: IO completion |
| * (DSP_STREAMIOCOMPLETION) or end of stream |
| * (DSP_STREAMDONE). |
| * notify_type: DSP_SIGNALEVENT. |
| * hnotification: Handle of a dsp_notification object. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Insufficient memory. |
| * -EINVAL: event_mask is 0 and hnotification was not |
| * previously registered. |
| * -EFAULT: NULL hnotification, hnotification event name |
| * too long, or hnotification event name NULL. |
| * Requires: |
| * Valid chnl_obj. |
| * hnotification != NULL. |
| * (event_mask & ~(DSP_STREAMIOCOMPLETION | DSP_STREAMDONE)) == 0. |
| * notify_type == DSP_SIGNALEVENT. |
| * Ensures: |
| */ |
| typedef int(*fxn_chnl_registernotify) |
| (struct chnl_object *chnl_obj, |
| u32 event_mask, u32 notify_type, struct dsp_notification *hnotification); |
| |
| /* |
| * ======== bridge_dev_create ======== |
| * Purpose: |
| * Complete creation of the device object for this board. |
| * Parameters: |
| * device_ctx: Ptr to location to store a Bridge device context. |
| * hdev_obj: Handle to a Device Object, created and managed by DSP API. |
| * config_param: Ptr to configuration parameters provided by the |
| * Configuration Manager during device loading. |
| * pDspConfig: DSP resources, as specified in the registry key for this |
| * device. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Unable to allocate memory for device context. |
| * Requires: |
| * device_ctx != NULL; |
| * hdev_obj != NULL; |
| * config_param != NULL; |
| * pDspConfig != NULL; |
| * Fields in config_param and pDspConfig contain valid values. |
| * Ensures: |
| * 0: All Bridge driver specific DSP resource and other |
| * board context has been allocated. |
| * -ENOMEM: Bridge failed to allocate resources. |
| * Any acquired resources have been freed. The DSP API |
| * will not call bridge_dev_destroy() if |
| * bridge_dev_create() fails. |
| * Details: |
| * Called during the CONFIGMG's Device_Init phase. Based on host and |
| * DSP configuration information, create a board context, a handle to |
| * which is passed into other Bridge BRD and CHNL functions. The |
| * board context contains state information for the device. Since the |
| * addresses of all pointer parameters may be invalid when this |
| * function returns, they must not be stored into the device context |
| * structure. |
| */ |
| typedef int(*fxn_dev_create) (struct bridge_dev_context |
| **device_ctx, |
| struct dev_object |
| * hdev_obj, |
| struct cfg_hostres |
| * config_param); |
| |
| /* |
| * ======== bridge_dev_ctrl ======== |
| * Purpose: |
| * Bridge driver specific interface. |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device info. |
| * dw_cmd: Bridge driver defined command code. |
| * pargs: Pointer to an arbitrary argument structure. |
| * Returns: |
| * 0 or -EPERM. Actual command error codes should be passed back in |
| * the pargs structure, and are defined by the Bridge driver implementor. |
| * Requires: |
| * All calls are currently assumed to be synchronous. There are no |
| * IOCTL completion routines provided. |
| * Ensures: |
| */ |
| typedef int(*fxn_dev_ctrl) (struct bridge_dev_context *dev_ctxt, |
| u32 dw_cmd, void *pargs); |
| |
| /* |
| * ======== bridge_dev_destroy ======== |
| * Purpose: |
| * Deallocate Bridge device extension structures and all other resources |
| * acquired by the Bridge driver. |
| * No calls to other Bridge driver functions may subsequently |
| * occur, except for bridge_dev_create(). |
| * Parameters: |
| * dev_ctxt: Handle to Bridge driver defined device information. |
| * Returns: |
| * 0: Success. |
| * -EPERM: Failed to release a resource previously acquired. |
| * Requires: |
| * dev_ctxt != NULL; |
| * Ensures: |
| * 0: Device context is freed. |
| */ |
| typedef int(*fxn_dev_destroy) (struct bridge_dev_context *dev_ctxt); |
| |
| /* |
| * ======== bridge_io_create ======== |
| * Purpose: |
| * Create an object that manages I/O between CHNL and msg_ctrl. |
| * Parameters: |
| * io_man: Location to store IO manager on output. |
| * hchnl_mgr: Handle to channel manager. |
| * hmsg_mgr: Handle to message manager. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Memory allocation failure. |
| * -EPERM: Creation failed. |
| * Requires: |
| * hdev_obj != NULL; |
| * Channel manager already created; |
| * Message manager already created; |
| * mgr_attrts != NULL; |
| * io_man != NULL; |
| * Ensures: |
| */ |
| typedef int(*fxn_io_create) (struct io_mgr **io_man, |
| struct dev_object *hdev_obj, |
| const struct io_attrs *mgr_attrts); |
| |
| /* |
| * ======== bridge_io_destroy ======== |
| * Purpose: |
| * Destroy object created in bridge_io_create. |
| * Parameters: |
| * hio_mgr: IO Manager. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Memory allocation failure. |
| * -EPERM: Creation failed. |
| * Requires: |
| * Valid hio_mgr; |
| * Ensures: |
| */ |
| typedef int(*fxn_io_destroy) (struct io_mgr *hio_mgr); |
| |
| /* |
| * ======== bridge_io_on_loaded ======== |
| * Purpose: |
| * Called whenever a program is loaded to update internal data. For |
| * example, if shared memory is used, this function would update the |
| * shared memory location and address. |
| * Parameters: |
| * hio_mgr: IO Manager. |
| * Returns: |
| * 0: Success. |
| * -EPERM: Internal failure occurred. |
| * Requires: |
| * Valid hio_mgr; |
| * Ensures: |
| */ |
| typedef int(*fxn_io_onloaded) (struct io_mgr *hio_mgr); |
| |
| /* |
| * ======== fxn_io_getprocload ======== |
| * Purpose: |
| * Called to get the Processor's current and predicted load |
| * Parameters: |
| * hio_mgr: IO Manager. |
| * proc_load_stat Processor Load statistics |
| * Returns: |
| * 0: Success. |
| * -EPERM: Internal failure occurred. |
| * Requires: |
| * Valid hio_mgr; |
| * Ensures: |
| */ |
| typedef int(*fxn_io_getprocload) (struct io_mgr *hio_mgr, |
| struct dsp_procloadstat * |
| proc_load_stat); |
| |
| /* |
| * ======== bridge_msg_create ======== |
| * Purpose: |
| * Create an object to manage message queues. Only one of these objects |
| * can exist per device object. |
| * Parameters: |
| * msg_man: Location to store msg_ctrl manager on output. |
| * hdev_obj: Handle to a device object. |
| * msg_callback: Called whenever an RMS_EXIT message is received. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Insufficient memory. |
| * Requires: |
| * msg_man != NULL. |
| * msg_callback != NULL. |
| * hdev_obj != NULL. |
| * Ensures: |
| */ |
| typedef int(*fxn_msg_create) |
| (struct msg_mgr **msg_man, |
| struct dev_object *hdev_obj, msg_onexit msg_callback); |
| |
| /* |
| * ======== bridge_msg_create_queue ======== |
| * Purpose: |
| * Create a msg_ctrl queue for sending or receiving messages from a Message |
| * node on the DSP. |
| * Parameters: |
| * hmsg_mgr: msg_ctrl queue manager handle returned from |
| * bridge_msg_create. |
| * msgq: Location to store msg_ctrl queue on output. |
| * msgq_id: Identifier for messages (node environment pointer). |
| * max_msgs: Max number of simultaneous messages for the node. |
| * h: Handle passed to hmsg_mgr->msg_callback(). |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Insufficient memory. |
| * Requires: |
| * msgq != NULL. |
| * h != NULL. |
| * max_msgs > 0. |
| * Ensures: |
| * msgq !=NULL <==> 0. |
| */ |
| typedef int(*fxn_msg_createqueue) |
| (struct msg_mgr *hmsg_mgr, |
| struct msg_queue **msgq, u32 msgq_id, u32 max_msgs, void *h); |
| |
| /* |
| * ======== bridge_msg_delete ======== |
| * Purpose: |
| * Delete a msg_ctrl manager allocated in bridge_msg_create(). |
| * Parameters: |
| * hmsg_mgr: Handle returned from bridge_msg_create(). |
| * Returns: |
| * Requires: |
| * Valid hmsg_mgr. |
| * Ensures: |
| */ |
| typedef void (*fxn_msg_delete) (struct msg_mgr *hmsg_mgr); |
| |
| /* |
| * ======== bridge_msg_delete_queue ======== |
| * Purpose: |
| * Delete a msg_ctrl queue allocated in bridge_msg_create_queue. |
| * Parameters: |
| * msg_queue_obj: Handle to msg_ctrl queue returned from |
| * bridge_msg_create_queue. |
| * Returns: |
| * Requires: |
| * Valid msg_queue_obj. |
| * Ensures: |
| */ |
| typedef void (*fxn_msg_deletequeue) (struct msg_queue *msg_queue_obj); |
| |
| /* |
| * ======== bridge_msg_get ======== |
| * Purpose: |
| * Get a message from a msg_ctrl queue. |
| * Parameters: |
| * msg_queue_obj: Handle to msg_ctrl queue returned from |
| * bridge_msg_create_queue. |
| * pmsg: Location to copy message into. |
| * utimeout: Timeout to wait for a message. |
| * Returns: |
| * 0: Success. |
| * -ETIME: Timeout occurred. |
| * -EPERM: No frames available for message (max_msgs too |
| * small). |
| * Requires: |
| * Valid msg_queue_obj. |
| * pmsg != NULL. |
| * Ensures: |
| */ |
| typedef int(*fxn_msg_get) (struct msg_queue *msg_queue_obj, |
| struct dsp_msg *pmsg, u32 utimeout); |
| |
| /* |
| * ======== bridge_msg_put ======== |
| * Purpose: |
| * Put a message onto a msg_ctrl queue. |
| * Parameters: |
| * msg_queue_obj: Handle to msg_ctrl queue returned from |
| * bridge_msg_create_queue. |
| * pmsg: Pointer to message. |
| * utimeout: Timeout to wait for a message. |
| * Returns: |
| * 0: Success. |
| * -ETIME: Timeout occurred. |
| * -EPERM: No frames available for message (max_msgs too |
| * small). |
| * Requires: |
| * Valid msg_queue_obj. |
| * pmsg != NULL. |
| * Ensures: |
| */ |
| typedef int(*fxn_msg_put) (struct msg_queue *msg_queue_obj, |
| const struct dsp_msg *pmsg, u32 utimeout); |
| |
| /* |
| * ======== bridge_msg_register_notify ======== |
| * Purpose: |
| * Register notification for when a message is ready. |
| * Parameters: |
| * msg_queue_obj: Handle to msg_ctrl queue returned from |
| * bridge_msg_create_queue. |
| * event_mask: Type of events to be notified about: Must be |
| * DSP_NODEMESSAGEREADY, or 0 to unregister. |
| * notify_type: DSP_SIGNALEVENT. |
| * hnotification: Handle of notification object. |
| * Returns: |
| * 0: Success. |
| * -ENOMEM: Insufficient memory. |
| * Requires: |
| * Valid msg_queue_obj. |
| * hnotification != NULL. |
| * notify_type == DSP_SIGNALEVENT. |
| * event_mask == DSP_NODEMESSAGEREADY || event_mask == 0. |
| * Ensures: |
| */ |
| typedef int(*fxn_msg_registernotify) |
| (struct msg_queue *msg_queue_obj, |
| u32 event_mask, u32 notify_type, struct dsp_notification *hnotification); |
| |
| /* |
| * ======== bridge_msg_set_queue_id ======== |
| * Purpose: |
| * Set message queue id to node environment. Allows bridge_msg_create_queue |
| * to be called in node_allocate, before the node environment is known. |
| * Parameters: |
| * msg_queue_obj: Handle to msg_ctrl queue returned from |
| * bridge_msg_create_queue. |
| * msgq_id: Node environment pointer. |
| * Returns: |
| * Requires: |
| * Valid msg_queue_obj. |
| * msgq_id != 0. |
| * Ensures: |
| */ |
| typedef void (*fxn_msg_setqueueid) (struct msg_queue *msg_queue_obj, |
| u32 msgq_id); |
| |
| /* |
| * Bridge Driver interface function table. |
| * |
| * The information in this table is filled in by the specific Bridge driver, |
| * and copied into the DSP API's own space. If any interface |
| * function field is set to a value of NULL, then the DSP API will |
| * consider that function not implemented, and return the error code |
| * -ENOSYS when a Bridge driver client attempts to call that function. |
| * |
| * This function table contains DSP API version numbers, which are used by the |
| * Bridge driver loader to help ensure backwards compatility between older |
| * Bridge drivers and newer DSP API. These must be set to |
| * BRD_API_MAJOR_VERSION and BRD_API_MINOR_VERSION, respectively. |
| * |
| * A Bridge driver need not export a CHNL interface. In this case, *all* of |
| * the bridge_chnl_* entries must be set to NULL. |
| */ |
| struct bridge_drv_interface { |
| u32 brd_api_major_version; /* Set to BRD_API_MAJOR_VERSION. */ |
| u32 brd_api_minor_version; /* Set to BRD_API_MINOR_VERSION. */ |
| fxn_dev_create dev_create; /* Create device context */ |
| fxn_dev_destroy dev_destroy; /* Destroy device context */ |
| fxn_dev_ctrl dev_cntrl; /* Optional vendor interface */ |
| fxn_brd_monitor brd_monitor; /* Load and/or start monitor */ |
| fxn_brd_start brd_start; /* Start DSP program. */ |
| fxn_brd_stop brd_stop; /* Stop/reset board. */ |
| fxn_brd_status brd_status; /* Get current board status. */ |
| fxn_brd_read brd_read; /* Read board memory */ |
| fxn_brd_write brd_write; /* Write board memory. */ |
| fxn_brd_setstate brd_set_state; /* Sets the Board State */ |
| fxn_brd_memcopy brd_mem_copy; /* Copies DSP Memory */ |
| fxn_brd_memwrite brd_mem_write; /* Write DSP Memory w/o halt */ |
| fxn_brd_memmap brd_mem_map; /* Maps MPU mem to DSP mem */ |
| fxn_brd_memunmap brd_mem_un_map; /* Unmaps MPU mem to DSP mem */ |
| fxn_chnl_create chnl_create; /* Create channel manager. */ |
| fxn_chnl_destroy chnl_destroy; /* Destroy channel manager. */ |
| fxn_chnl_open chnl_open; /* Create a new channel. */ |
| fxn_chnl_close chnl_close; /* Close a channel. */ |
| fxn_chnl_addioreq chnl_add_io_req; /* Req I/O on a channel. */ |
| fxn_chnl_getioc chnl_get_ioc; /* Wait for I/O completion. */ |
| fxn_chnl_cancelio chnl_cancel_io; /* Cancl I/O on a channel. */ |
| fxn_chnl_flushio chnl_flush_io; /* Flush I/O. */ |
| fxn_chnl_getinfo chnl_get_info; /* Get channel specific info */ |
| /* Get channel manager info. */ |
| fxn_chnl_getmgrinfo chnl_get_mgr_info; |
| fxn_chnl_idle chnl_idle; /* Idle the channel */ |
| /* Register for notif. */ |
| fxn_chnl_registernotify chnl_register_notify; |
| fxn_io_create io_create; /* Create IO manager */ |
| fxn_io_destroy io_destroy; /* Destroy IO manager */ |
| fxn_io_onloaded io_on_loaded; /* Notify of program loaded */ |
| /* Get Processor's current and predicted load */ |
| fxn_io_getprocload io_get_proc_load; |
| fxn_msg_create msg_create; /* Create message manager */ |
| /* Create message queue */ |
| fxn_msg_createqueue msg_create_queue; |
| fxn_msg_delete msg_delete; /* Delete message manager */ |
| /* Delete message queue */ |
| fxn_msg_deletequeue msg_delete_queue; |
| fxn_msg_get msg_get; /* Get a message */ |
| fxn_msg_put msg_put; /* Send a message */ |
| /* Register for notif. */ |
| fxn_msg_registernotify msg_register_notify; |
| /* Set message queue id */ |
| fxn_msg_setqueueid msg_set_queue_id; |
| }; |
| |
| /* |
| * ======== bridge_drv_entry ======== |
| * Purpose: |
| * Registers Bridge driver functions with the DSP API. Called only once |
| * by the DSP API. The caller will first check DSP API version |
| * compatibility, and then copy the interface functions into its own |
| * memory space. |
| * Parameters: |
| * drv_intf Pointer to a location to receive a pointer to the |
| * Bridge driver interface. |
| * Returns: |
| * Requires: |
| * The code segment this function resides in must expect to be discarded |
| * after completion. |
| * Ensures: |
| * drv_intf pointer initialized to Bridge driver's function |
| * interface. No system resources are acquired by this function. |
| * Details: |
| * Called during the Device_Init phase. |
| */ |
| void bridge_drv_entry(struct bridge_drv_interface **drv_intf, |
| const char *driver_file_name); |
| |
| #endif /* DSPDEFS_ */ |
