624 lines
18 KiB
C
624 lines
18 KiB
C
#ifndef __INTEL_SST_COMMON_H__
|
|
#define __INTEL_SST_COMMON_H__
|
|
/*
|
|
* intel_sst_common.h - Intel SST Driver for audio engine
|
|
*
|
|
* Copyright (C) 2008-10 Intel Corporation
|
|
* Authors: Vinod Koul <vinod.koul@intel.com>
|
|
* Harsha Priya <priya.harsha@intel.com>
|
|
* Dharageswari R <dharageswari.r@intel.com>
|
|
* KP Jeeja <jeeja.kp@intel.com>
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* Common private declarations for SST
|
|
*/
|
|
|
|
#define SST_DRIVER_VERSION "1.2.17"
|
|
#define SST_VERSION_NUM 0x1217
|
|
|
|
/* driver names */
|
|
#define SST_DRV_NAME "intel_sst_driver"
|
|
#define SST_MRST_PCI_ID 0x080A
|
|
#define SST_MFLD_PCI_ID 0x082F
|
|
#define PCI_ID_LENGTH 4
|
|
#define SST_SUSPEND_DELAY 2000
|
|
#define FW_CONTEXT_MEM (64*1024)
|
|
|
|
enum sst_states {
|
|
SST_FW_LOADED = 1,
|
|
SST_FW_RUNNING,
|
|
SST_UN_INIT,
|
|
SST_ERROR,
|
|
SST_SUSPENDED
|
|
};
|
|
|
|
#define MAX_ACTIVE_STREAM 3
|
|
#define MAX_ENC_STREAM 1
|
|
#define MAX_AM_HANDLES 1
|
|
#define ALLOC_TIMEOUT 5000
|
|
/* SST numbers */
|
|
#define SST_BLOCK_TIMEOUT 5000
|
|
#define TARGET_DEV_BLOCK_TIMEOUT 5000
|
|
|
|
#define BLOCK_UNINIT -1
|
|
#define RX_TIMESLOT_UNINIT -1
|
|
|
|
/* SST register map */
|
|
#define SST_CSR 0x00
|
|
#define SST_PISR 0x08
|
|
#define SST_PIMR 0x10
|
|
#define SST_ISRX 0x18
|
|
#define SST_IMRX 0x28
|
|
#define SST_IPCX 0x38 /* IPC IA-SST */
|
|
#define SST_IPCD 0x40 /* IPC SST-IA */
|
|
#define SST_ISRD 0x20 /* dummy register for shim workaround */
|
|
#define SST_SHIM_SIZE 0X44
|
|
|
|
#define SPI_MODE_ENABLE_BASE_ADDR 0xffae4000
|
|
#define FW_SIGNATURE_SIZE 4
|
|
|
|
/* PMIC and SST hardware states */
|
|
enum sst_mad_states {
|
|
SND_MAD_UN_INIT = 0,
|
|
SND_MAD_INIT_DONE,
|
|
};
|
|
|
|
/* stream states */
|
|
enum sst_stream_states {
|
|
STREAM_UN_INIT = 0, /* Freed/Not used stream */
|
|
STREAM_RUNNING = 1, /* Running */
|
|
STREAM_PAUSED = 2, /* Paused stream */
|
|
STREAM_DECODE = 3, /* stream is in decoding only state */
|
|
STREAM_INIT = 4, /* stream init, waiting for data */
|
|
};
|
|
|
|
|
|
enum sst_ram_type {
|
|
SST_IRAM = 1,
|
|
SST_DRAM = 2,
|
|
};
|
|
/* SST shim registers to structure mapping */
|
|
union config_status_reg {
|
|
struct {
|
|
u32 mfld_strb:1;
|
|
u32 sst_reset:1;
|
|
u32 hw_rsvd:3;
|
|
u32 sst_clk:2;
|
|
u32 bypass:3;
|
|
u32 run_stall:1;
|
|
u32 rsvd1:2;
|
|
u32 strb_cntr_rst:1;
|
|
u32 rsvd:18;
|
|
} part;
|
|
u32 full;
|
|
};
|
|
|
|
union interrupt_reg {
|
|
struct {
|
|
u32 done_interrupt:1;
|
|
u32 busy_interrupt:1;
|
|
u32 rsvd:30;
|
|
} part;
|
|
u32 full;
|
|
};
|
|
|
|
union sst_pisr_reg {
|
|
struct {
|
|
u32 pssp0:1;
|
|
u32 pssp1:1;
|
|
u32 rsvd0:3;
|
|
u32 dmac:1;
|
|
u32 rsvd1:26;
|
|
} part;
|
|
u32 full;
|
|
};
|
|
|
|
union sst_pimr_reg {
|
|
struct {
|
|
u32 ssp0:1;
|
|
u32 ssp1:1;
|
|
u32 rsvd0:3;
|
|
u32 dmac:1;
|
|
u32 rsvd1:10;
|
|
u32 ssp0_sc:1;
|
|
u32 ssp1_sc:1;
|
|
u32 rsvd2:3;
|
|
u32 dmac_sc:1;
|
|
u32 rsvd3:10;
|
|
} part;
|
|
u32 full;
|
|
};
|
|
|
|
|
|
struct sst_stream_bufs {
|
|
struct list_head node;
|
|
u32 size;
|
|
const char *addr;
|
|
u32 data_copied;
|
|
bool in_use;
|
|
u32 offset;
|
|
};
|
|
|
|
struct snd_sst_user_cap_list {
|
|
unsigned int iov_index; /* index of iov */
|
|
unsigned long iov_offset; /* offset in iov */
|
|
unsigned long offset; /* offset in kmem */
|
|
unsigned long size; /* size copied */
|
|
struct list_head node;
|
|
};
|
|
/*
|
|
This structure is used to block a user/fw data call to another
|
|
fw/user call
|
|
*/
|
|
struct sst_block {
|
|
bool condition; /* condition for blocking check */
|
|
int ret_code; /* ret code when block is released */
|
|
void *data; /* data to be appsed for block if any */
|
|
bool on;
|
|
};
|
|
|
|
enum snd_sst_buf_type {
|
|
SST_BUF_USER_STATIC = 1,
|
|
SST_BUF_USER_DYNAMIC,
|
|
SST_BUF_MMAP_STATIC,
|
|
SST_BUF_MMAP_DYNAMIC,
|
|
};
|
|
|
|
enum snd_src {
|
|
SST_DRV = 1,
|
|
MAD_DRV = 2
|
|
};
|
|
|
|
/**
|
|
* struct stream_info - structure that holds the stream information
|
|
*
|
|
* @status : stream current state
|
|
* @prev : stream prev state
|
|
* @codec : stream codec
|
|
* @sst_id : stream id
|
|
* @ops : stream operation pb/cp/drm...
|
|
* @bufs: stream buffer list
|
|
* @lock : stream mutex for protecting state
|
|
* @pcm_lock : spinlock for pcm path only
|
|
* @mmapped : is stream mmapped
|
|
* @sg_index : current stream user buffer index
|
|
* @cur_ptr : stream user buffer pointer
|
|
* @buf_entry : current user buffer
|
|
* @data_blk : stream block for data operations
|
|
* @ctrl_blk : stream block for ctrl operations
|
|
* @buf_type : stream user buffer type
|
|
* @pcm_substream : PCM substream
|
|
* @period_elapsed : PCM period elapsed callback
|
|
* @sfreq : stream sampling freq
|
|
* @decode_ibuf : Decoded i/p buffers pointer
|
|
* @decode_obuf : Decoded o/p buffers pointer
|
|
* @decode_isize : Decoded i/p buffers size
|
|
* @decode_osize : Decoded o/p buffers size
|
|
* @decode_ibuf_type : Decoded i/p buffer type
|
|
* @decode_obuf_type : Decoded o/p buffer type
|
|
* @idecode_alloc : Decode alloc index
|
|
* @need_draining : stream set for drain
|
|
* @str_type : stream type
|
|
* @curr_bytes : current bytes decoded
|
|
* @cumm_bytes : cummulative bytes decoded
|
|
* @str_type : stream type
|
|
* @src : stream source
|
|
* @device : output device type (medfield only)
|
|
* @pcm_slot : pcm slot value
|
|
*/
|
|
struct stream_info {
|
|
unsigned int status;
|
|
unsigned int prev;
|
|
u8 codec;
|
|
unsigned int sst_id;
|
|
unsigned int ops;
|
|
struct list_head bufs;
|
|
struct mutex lock; /* mutex */
|
|
spinlock_t pcm_lock;
|
|
bool mmapped;
|
|
unsigned int sg_index; /* current buf Index */
|
|
unsigned char __user *cur_ptr; /* Current static bufs */
|
|
struct snd_sst_buf_entry __user *buf_entry;
|
|
struct sst_block data_blk; /* stream ops block */
|
|
struct sst_block ctrl_blk; /* stream control cmd block */
|
|
enum snd_sst_buf_type buf_type;
|
|
void *pcm_substream;
|
|
void (*period_elapsed) (void *pcm_substream);
|
|
unsigned int sfreq;
|
|
void *decode_ibuf, *decode_obuf;
|
|
unsigned int decode_isize, decode_osize;
|
|
u8 decode_ibuf_type, decode_obuf_type;
|
|
unsigned int idecode_alloc;
|
|
unsigned int need_draining;
|
|
unsigned int str_type;
|
|
u32 curr_bytes;
|
|
u32 cumm_bytes;
|
|
u32 src;
|
|
enum snd_sst_audio_device_type device;
|
|
u8 pcm_slot;
|
|
};
|
|
|
|
/*
|
|
* struct stream_alloc_bloc - this structure is used for blocking the user's
|
|
* alloc calls to fw's response to alloc calls
|
|
*
|
|
* @sst_id : session id of blocked stream
|
|
* @ops_block : ops block struture
|
|
*/
|
|
struct stream_alloc_block {
|
|
int sst_id; /* session id of blocked stream */
|
|
struct sst_block ops_block; /* ops block struture */
|
|
};
|
|
|
|
#define SST_FW_SIGN "$SST"
|
|
#define SST_FW_LIB_SIGN "$LIB"
|
|
|
|
/*
|
|
* struct fw_header - FW file headers
|
|
*
|
|
* @signature : FW signature
|
|
* @modules : # of modules
|
|
* @file_format : version of header format
|
|
* @reserved : reserved fields
|
|
*/
|
|
struct fw_header {
|
|
unsigned char signature[FW_SIGNATURE_SIZE]; /* FW signature */
|
|
u32 file_size; /* size of fw minus this header */
|
|
u32 modules; /* # of modules */
|
|
u32 file_format; /* version of header format */
|
|
u32 reserved[4];
|
|
};
|
|
|
|
struct fw_module_header {
|
|
unsigned char signature[FW_SIGNATURE_SIZE]; /* module signature */
|
|
u32 mod_size; /* size of module */
|
|
u32 blocks; /* # of blocks */
|
|
u32 type; /* codec type, pp lib */
|
|
u32 entry_point;
|
|
};
|
|
|
|
struct dma_block_info {
|
|
enum sst_ram_type type; /* IRAM/DRAM */
|
|
u32 size; /* Bytes */
|
|
u32 ram_offset; /* Offset in I/DRAM */
|
|
u32 rsvd; /* Reserved field */
|
|
};
|
|
|
|
struct ioctl_pvt_data {
|
|
int str_id;
|
|
int pvt_id;
|
|
};
|
|
|
|
struct sst_ipc_msg_wq {
|
|
union ipc_header header;
|
|
char mailbox[SST_MAILBOX_SIZE];
|
|
struct work_struct wq;
|
|
};
|
|
|
|
struct mad_ops_wq {
|
|
int stream_id;
|
|
enum sst_controls control_op;
|
|
struct work_struct wq;
|
|
|
|
};
|
|
|
|
#define SST_MMAP_PAGES (640*1024 / PAGE_SIZE)
|
|
#define SST_MMAP_STEP (40*1024 / PAGE_SIZE)
|
|
|
|
/***
|
|
* struct intel_sst_drv - driver ops
|
|
*
|
|
* @pmic_state : pmic state
|
|
* @pmic_vendor : pmic vendor detected
|
|
* @sst_state : current sst device state
|
|
* @pci_id : PCI device id loaded
|
|
* @shim : SST shim pointer
|
|
* @mailbox : SST mailbox pointer
|
|
* @iram : SST IRAM pointer
|
|
* @dram : SST DRAM pointer
|
|
* @shim_phy_add : SST shim phy addr
|
|
* @ipc_dispatch_list : ipc messages dispatched
|
|
* @ipc_post_msg_wq : wq to post IPC messages context
|
|
* @ipc_process_msg : wq to process msgs from FW context
|
|
* @ipc_process_reply : wq to process reply from FW context
|
|
* @ipc_post_msg : wq to post reply from FW context
|
|
* @mad_ops : MAD driver operations registered
|
|
* @mad_wq : MAD driver wq
|
|
* @post_msg_wq : wq to post IPC messages
|
|
* @process_msg_wq : wq to process msgs from FW
|
|
* @process_reply_wq : wq to process reply from FW
|
|
* @streams : sst stream contexts
|
|
* @alloc_block : block structure for alloc
|
|
* @tgt_dev_blk : block structure for target device
|
|
* @fw_info_blk : block structure for fw info block
|
|
* @vol_info_blk : block structure for vol info block
|
|
* @mute_info_blk : block structure for mute info block
|
|
* @hs_info_blk : block structure for hs info block
|
|
* @list_lock : sst driver list lock (deprecated)
|
|
* @list_spin_lock : sst driver spin lock block
|
|
* @scard_ops : sst card ops
|
|
* @pci : sst pci device struture
|
|
* @active_streams : sst active streams
|
|
* @sst_lock : sst device lock
|
|
* @stream_lock : sst stream lock
|
|
* @unique_id : sst unique id
|
|
* @stream_cnt : total sst active stream count
|
|
* @pb_streams : total active pb streams
|
|
* @cp_streams : total active cp streams
|
|
* @lpe_stalled : lpe stall status
|
|
* @pmic_port_instance : active pmic port instance
|
|
* @rx_time_slot_status : active rx slot
|
|
* @lpaudio_start : lpaudio status
|
|
* @audio_start : audio status
|
|
* @devt_d : pointer to /dev/lpe node
|
|
* @devt_c : pointer to /dev/lpe_ctrl node
|
|
* @max_streams : max streams allowed
|
|
*/
|
|
struct intel_sst_drv {
|
|
bool pmic_state;
|
|
int pmic_vendor;
|
|
int sst_state;
|
|
unsigned int pci_id;
|
|
void __iomem *shim;
|
|
void __iomem *mailbox;
|
|
void __iomem *iram;
|
|
void __iomem *dram;
|
|
unsigned int shim_phy_add;
|
|
struct list_head ipc_dispatch_list;
|
|
struct work_struct ipc_post_msg_wq;
|
|
struct sst_ipc_msg_wq ipc_process_msg;
|
|
struct sst_ipc_msg_wq ipc_process_reply;
|
|
struct sst_ipc_msg_wq ipc_post_msg;
|
|
struct mad_ops_wq mad_ops;
|
|
wait_queue_head_t wait_queue;
|
|
struct workqueue_struct *mad_wq;
|
|
struct workqueue_struct *post_msg_wq;
|
|
struct workqueue_struct *process_msg_wq;
|
|
struct workqueue_struct *process_reply_wq;
|
|
|
|
struct stream_info streams[MAX_NUM_STREAMS];
|
|
struct stream_alloc_block alloc_block[MAX_ACTIVE_STREAM];
|
|
struct sst_block tgt_dev_blk, fw_info_blk, ppp_params_blk,
|
|
vol_info_blk, mute_info_blk, hs_info_blk;
|
|
struct mutex list_lock;/* mutex for IPC list locking */
|
|
spinlock_t list_spin_lock; /* mutex for IPC list locking */
|
|
struct snd_pmic_ops *scard_ops;
|
|
struct pci_dev *pci;
|
|
int active_streams[MAX_NUM_STREAMS];
|
|
void *mmap_mem;
|
|
struct mutex sst_lock;
|
|
struct mutex stream_lock;
|
|
unsigned int mmap_len;
|
|
unsigned int unique_id;
|
|
unsigned int stream_cnt; /* total streams */
|
|
unsigned int encoded_cnt; /* enocded streams only */
|
|
unsigned int am_cnt;
|
|
unsigned int pb_streams; /* pb streams active */
|
|
unsigned int cp_streams; /* cp streams active */
|
|
unsigned int lpe_stalled; /* LPE is stalled or not */
|
|
unsigned int pmic_port_instance; /*pmic port instance*/
|
|
int rx_time_slot_status;
|
|
unsigned int lpaudio_start;
|
|
/* 1 - LPA stream(MP3 pb) in progress*/
|
|
unsigned int audio_start;
|
|
dev_t devt_d, devt_c;
|
|
unsigned int max_streams;
|
|
unsigned int *fw_cntx;
|
|
unsigned int fw_cntx_size;
|
|
|
|
unsigned int fw_downloaded;
|
|
};
|
|
|
|
extern struct intel_sst_drv *sst_drv_ctx;
|
|
|
|
#define CHIP_REV_REG 0xff108000
|
|
#define CHIP_REV_ADDR 0x78
|
|
|
|
/* misc definitions */
|
|
#define FW_DWNL_ID 0xFF
|
|
#define LOOP1 0x11111111
|
|
#define LOOP2 0x22222222
|
|
#define LOOP3 0x33333333
|
|
#define LOOP4 0x44444444
|
|
|
|
#define SST_DEFAULT_PMIC_PORT 1 /*audio port*/
|
|
/* NOTE: status will have +ve for good cases and -ve for error ones */
|
|
#define MAX_STREAM_FIELD 255
|
|
|
|
int sst_alloc_stream(char *params, unsigned int stream_ops, u8 codec,
|
|
unsigned int session_id);
|
|
int sst_alloc_stream_response(unsigned int str_id,
|
|
struct snd_sst_alloc_response *response);
|
|
int sst_stalled(void);
|
|
int sst_pause_stream(int id);
|
|
int sst_resume_stream(int id);
|
|
int sst_enable_rx_timeslot(int status);
|
|
int sst_drop_stream(int id);
|
|
int sst_free_stream(int id);
|
|
int sst_start_stream(int streamID);
|
|
int sst_play_frame(int streamID);
|
|
int sst_pcm_play_frame(int str_id, struct sst_stream_bufs *sst_buf);
|
|
int sst_capture_frame(int streamID);
|
|
int sst_set_stream_param(int streamID, struct snd_sst_params *str_param);
|
|
int sst_target_device_select(struct snd_sst_target_device *target_device);
|
|
int sst_decode(int str_id, struct snd_sst_dbufs *dbufs);
|
|
int sst_get_decoded_bytes(int str_id, unsigned long long *bytes);
|
|
int sst_get_fw_info(struct snd_sst_fw_info *info);
|
|
int sst_get_stream_params(int str_id,
|
|
struct snd_sst_get_stream_params *get_params);
|
|
int sst_get_stream(struct snd_sst_params *str_param);
|
|
int sst_get_stream_allocated(struct snd_sst_params *str_param,
|
|
struct snd_sst_lib_download **lib_dnld);
|
|
int sst_drain_stream(int str_id);
|
|
int sst_get_vol(struct snd_sst_vol *set_vol);
|
|
int sst_set_vol(struct snd_sst_vol *set_vol);
|
|
int sst_set_mute(struct snd_sst_mute *set_mute);
|
|
|
|
|
|
void sst_post_message(struct work_struct *work);
|
|
void sst_process_message(struct work_struct *work);
|
|
void sst_process_reply(struct work_struct *work);
|
|
void sst_process_mad_ops(struct work_struct *work);
|
|
void sst_process_mad_jack_detection(struct work_struct *work);
|
|
|
|
long intel_sst_ioctl(struct file *file_ptr, unsigned int cmd,
|
|
unsigned long arg);
|
|
int intel_sst_open(struct inode *i_node, struct file *file_ptr);
|
|
int intel_sst_open_cntrl(struct inode *i_node, struct file *file_ptr);
|
|
int intel_sst_release(struct inode *i_node, struct file *file_ptr);
|
|
int intel_sst_release_cntrl(struct inode *i_node, struct file *file_ptr);
|
|
int intel_sst_read(struct file *file_ptr, char __user *buf,
|
|
size_t count, loff_t *ppos);
|
|
int intel_sst_write(struct file *file_ptr, const char __user *buf,
|
|
size_t count, loff_t *ppos);
|
|
int intel_sst_mmap(struct file *fp, struct vm_area_struct *vma);
|
|
ssize_t intel_sst_aio_write(struct kiocb *kiocb, const struct iovec *iov,
|
|
unsigned long nr_segs, loff_t offset);
|
|
ssize_t intel_sst_aio_read(struct kiocb *kiocb, const struct iovec *iov,
|
|
unsigned long nr_segs, loff_t offset);
|
|
|
|
int sst_load_fw(const struct firmware *fw, void *context);
|
|
int sst_load_library(struct snd_sst_lib_download *lib, u8 ops);
|
|
int sst_spi_mode_enable(void);
|
|
int sst_get_block_stream(struct intel_sst_drv *sst_drv_ctx);
|
|
|
|
int sst_wait_interruptible(struct intel_sst_drv *sst_drv_ctx,
|
|
struct sst_block *block);
|
|
int sst_wait_interruptible_timeout(struct intel_sst_drv *sst_drv_ctx,
|
|
struct sst_block *block, int timeout);
|
|
int sst_wait_timeout(struct intel_sst_drv *sst_drv_ctx,
|
|
struct stream_alloc_block *block);
|
|
int sst_create_large_msg(struct ipc_post **arg);
|
|
int sst_create_short_msg(struct ipc_post **arg);
|
|
void sst_wake_up_alloc_block(struct intel_sst_drv *sst_drv_ctx,
|
|
u8 sst_id, int status, void *data);
|
|
void sst_clear_interrupt(void);
|
|
int intel_sst_resume(struct pci_dev *pci);
|
|
int sst_download_fw(void);
|
|
void free_stream_context(unsigned int str_id);
|
|
void sst_clean_stream(struct stream_info *stream);
|
|
|
|
/*
|
|
* sst_fill_header - inline to fill sst header
|
|
*
|
|
* @header : ipc header
|
|
* @msg : IPC message to be sent
|
|
* @large : is ipc large msg
|
|
* @str_id : stream id
|
|
*
|
|
* this function is an inline function that sets the headers before
|
|
* sending a message
|
|
*/
|
|
static inline void sst_fill_header(union ipc_header *header,
|
|
int msg, int large, int str_id)
|
|
{
|
|
header->part.msg_id = msg;
|
|
header->part.str_id = str_id;
|
|
header->part.large = large;
|
|
header->part.done = 0;
|
|
header->part.busy = 1;
|
|
header->part.data = 0;
|
|
}
|
|
|
|
/*
|
|
* sst_assign_pvt_id - assign a pvt id for stream
|
|
*
|
|
* @sst_drv_ctx : driver context
|
|
*
|
|
* this inline function assigns a private id for calls that dont have stream
|
|
* context yet, should be called with lock held
|
|
*/
|
|
static inline unsigned int sst_assign_pvt_id(struct intel_sst_drv *sst_drv_ctx)
|
|
{
|
|
sst_drv_ctx->unique_id++;
|
|
if (sst_drv_ctx->unique_id >= MAX_NUM_STREAMS)
|
|
sst_drv_ctx->unique_id = 1;
|
|
return sst_drv_ctx->unique_id;
|
|
}
|
|
|
|
/*
|
|
* sst_init_stream - this function initialzes stream context
|
|
*
|
|
* @stream : stream struture
|
|
* @codec : codec for stream
|
|
* @sst_id : stream id
|
|
* @ops : stream operation
|
|
* @slot : stream pcm slot
|
|
* @device : device type
|
|
*
|
|
* this inline function initialzes stream context for allocated stream
|
|
*/
|
|
static inline void sst_init_stream(struct stream_info *stream,
|
|
int codec, int sst_id, int ops, u8 slot,
|
|
enum snd_sst_audio_device_type device)
|
|
{
|
|
stream->status = STREAM_INIT;
|
|
stream->prev = STREAM_UN_INIT;
|
|
stream->codec = codec;
|
|
stream->sst_id = sst_id;
|
|
stream->str_type = 0;
|
|
stream->ops = ops;
|
|
stream->data_blk.on = false;
|
|
stream->data_blk.condition = false;
|
|
stream->data_blk.ret_code = 0;
|
|
stream->data_blk.data = NULL;
|
|
stream->ctrl_blk.on = false;
|
|
stream->ctrl_blk.condition = false;
|
|
stream->ctrl_blk.ret_code = 0;
|
|
stream->ctrl_blk.data = NULL;
|
|
stream->need_draining = false;
|
|
stream->decode_ibuf = NULL;
|
|
stream->decode_isize = 0;
|
|
stream->mmapped = false;
|
|
stream->pcm_slot = slot;
|
|
stream->device = device;
|
|
}
|
|
|
|
|
|
/*
|
|
* sst_validate_strid - this function validates the stream id
|
|
*
|
|
* @str_id : stream id to be validated
|
|
*
|
|
* returns 0 if valid stream
|
|
*/
|
|
static inline int sst_validate_strid(int str_id)
|
|
{
|
|
if (str_id <= 0 || str_id > sst_drv_ctx->max_streams) {
|
|
pr_err("SST ERR: invalid stream id : %d MAX_STREAMS:%d\n",
|
|
str_id, sst_drv_ctx->max_streams);
|
|
return -EINVAL;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
static inline int sst_shim_write(void __iomem *addr, int offset, int value)
|
|
{
|
|
|
|
if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
|
|
writel(value, addr + SST_ISRD); /*dummy*/
|
|
writel(value, addr + offset);
|
|
return 0;
|
|
}
|
|
|
|
static inline int sst_shim_read(void __iomem *addr, int offset)
|
|
{
|
|
return readl(addr + offset);
|
|
}
|
|
#endif /* __INTEL_SST_COMMON_H__ */
|