drivers/staging/intel_sst/intel_sst_common.h

   1 #ifndef __INTEL_SST_COMMON_H__
   2 #define __INTEL_SST_COMMON_H__
   3 /*
   4  *  intel_sst_common.h - Intel SST Driver for audio engine
   5  *
   6  *  Copyright (C) 2008-10 Intel Corporation
   7  *  Authors:    Vinod Koul <vinod.koul@intel.com>
   8  *              Harsha Priya <priya.harsha@intel.com>
   9  *              Dharageswari R <dharageswari.r@intel.com>
  10  *              KP Jeeja <jeeja.kp@intel.com>
  11  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; version 2 of the License.
  16  *
  17  *  This program is distributed in the hope that it will be useful, but
  18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  *  General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License along
  23  *  with this program; if not, write to the Free Software Foundation, Inc.,
  24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25  *
  26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  27  *
  28  *  Common private declarations for SST
  29  */
  30
  31 #define SST_DRIVER_VERSION "1.2.09"
  32 #define SST_VERSION_NUM 0x1209
  33
  34 /* driver names */
  35 #define SST_DRV_NAME "intel_sst_driver"
  36 #define SST_MRST_PCI_ID 0x080A
  37 #define SST_MFLD_PCI_ID 0x082F
  38 #define PCI_ID_LENGTH 4
  39 #define SST_SUSPEND_DELAY 2000
  40
  41 enum sst_states {
  42         SST_FW_LOADED = 1,
  43         SST_FW_RUNNING,
  44         SST_UN_INIT,
  45         SST_ERROR,
  46         SST_SUSPENDED
  47 };
  48
  49 #define MAX_ACTIVE_STREAM       3
  50 #define MAX_ENC_STREAM          1
  51 #define MAX_AM_HANDLES          1
  52 #define ALLOC_TIMEOUT           5000
  53 /* SST numbers */
  54 #define SST_BLOCK_TIMEOUT       5000
  55 #define TARGET_DEV_BLOCK_TIMEOUT        5000
  56
  57 #define BLOCK_UNINIT            -1
  58 #define RX_TIMESLOT_UNINIT      -1
  59
  60 /* SST register map */
  61 #define SST_CSR                 0x00
  62 #define SST_PISR                0x08
  63 #define SST_PIMR                0x10
  64 #define SST_ISRX                0x18
  65 #define SST_IMRX                0x28
  66 #define SST_IPCX                0x38 /* IPC IA-SST */
  67 #define SST_IPCD                0x40 /* IPC SST-IA */
  68 #define SST_ISRD                0x20 /* dummy register for shim workaround */
  69 #define SST_SHIM_SIZE           0X44
  70
  71 #define SPI_MODE_ENABLE_BASE_ADDR 0xffae4000
  72 #define FW_SIGNATURE_SIZE       4
  73
  74 /* PMIC and SST hardware states */
  75 enum sst_mad_states {
  76         SND_MAD_UN_INIT = 0,
  77         SND_MAD_INIT_DONE,
  78 };
  79
  80 /* stream states */
  81 enum sst_stream_states {
  82         STREAM_UN_INIT  = 0,    /* Freed/Not used stream */
  83         STREAM_RUNNING  = 1,    /* Running */
  84         STREAM_PAUSED   = 2,    /* Paused stream */
  85         STREAM_DECODE   = 3,    /* stream is in decoding only state */
  86         STREAM_INIT     = 4,    /* stream init, waiting for data */
  87 };
  88
  89
  90 enum sst_ram_type {
  91         SST_IRAM        = 1,
  92         SST_DRAM        = 2,
  93 };
  94 /* SST shim registers to structure mapping  */
  95 union config_status_reg {
  96         struct {
  97                 u32 rsvd0:1;
  98                 u32 sst_reset:1;
  99                 u32 hw_rsvd:3;
 100                 u32 sst_clk:2;
 101                 u32 bypass:3;
 102                 u32 run_stall:1;
 103                 u32 rsvd1:2;
 104                 u32 strb_cntr_rst:1;
 105                 u32 rsvd:18;
 106         } part;
 107         u32 full;
 108 };
 109
 110 union interrupt_reg {
 111         struct {
 112                 u32 done_interrupt:1;
 113                 u32 busy_interrupt:1;
 114                 u32 rsvd:30;
 115         } part;
 116         u32 full;
 117 };
 118
 119 union sst_pisr_reg {
 120         struct {
 121                 u32 pssp0:1;
 122                 u32 pssp1:1;
 123                 u32 rsvd0:3;
 124                 u32 dmac:1;
 125                 u32 rsvd1:26;
 126         } part;
 127         u32 full;
 128 };
 129
 130 union sst_pimr_reg {
 131         struct {
 132                 u32 ssp0:1;
 133                 u32 ssp1:1;
 134                 u32 rsvd0:3;
 135                 u32 dmac:1;
 136                 u32 rsvd1:10;
 137                 u32 ssp0_sc:1;
 138                 u32 ssp1_sc:1;
 139                 u32 rsvd2:3;
 140                 u32 dmac_sc:1;
 141                 u32 rsvd3:10;
 142         } part;
 143         u32 full;
 144 };
 145
 146
 147 struct sst_stream_bufs {
 148         struct list_head        node;
 149         u32                     size;
 150         const char              *addr;
 151         u32                     data_copied;
 152         bool                    in_use;
 153         u32                     offset;
 154 };
 155
 156 struct snd_sst_user_cap_list {
 157         unsigned int iov_index; /* index of iov */
 158         unsigned long iov_offset; /* offset in iov */
 159         unsigned long offset; /* offset in kmem */
 160         unsigned long size; /* size copied */
 161         struct list_head node;
 162 };
 163 /*
 164 This structure is used to block a user/fw data call to another
 165 fw/user call
 166 */
 167 struct sst_block {
 168         bool    condition; /* condition for blocking check */
 169         int     ret_code; /* ret code when block is released */
 170         void    *data; /* data to be appsed for block if any */
 171         bool    on;
 172 };
 173
 174 enum snd_sst_buf_type {
 175         SST_BUF_USER_STATIC = 1,
 176         SST_BUF_USER_DYNAMIC,
 177         SST_BUF_MMAP_STATIC,
 178         SST_BUF_MMAP_DYNAMIC,
 179 };
 180
 181 enum snd_src {
 182         SST_DRV = 1,
 183         MAD_DRV = 2
 184 };
 185
 186 /**
 187  * struct stream_info - structure that holds the stream information
 188  *
 189  * @status : stream current state
 190  * @prev : stream prev state
 191  * @codec : stream codec
 192  * @sst_id : stream id
 193  * @ops : stream operation pb/cp/drm...
 194  * @bufs: stream buffer list
 195  * @lock : stream mutex for protecting state
 196  * @pcm_lock : spinlock for pcm path only
 197  * @mmapped : is stream mmapped
 198  * @sg_index : current stream user buffer index
 199  * @cur_ptr : stream user buffer pointer
 200  * @buf_entry : current user buffer
 201  * @data_blk : stream block for data operations
 202  * @ctrl_blk : stream block for ctrl operations
 203  * @buf_type : stream user buffer type
 204  * @pcm_substream : PCM substream
 205  * @period_elapsed : PCM period elapsed callback
 206  * @sfreq : stream sampling freq
 207  * @decode_ibuf : Decoded i/p buffers pointer
 208  * @decode_obuf : Decoded o/p buffers pointer
 209  * @decode_isize : Decoded i/p buffers size
 210  * @decode_osize : Decoded o/p buffers size
 211  * @decode_ibuf_type : Decoded i/p buffer type
 212  * @decode_obuf_type : Decoded o/p buffer type
 213  * @idecode_alloc : Decode alloc index
 214  * @need_draining : stream set for drain
 215  * @str_type : stream type
 216  * @curr_bytes : current bytes decoded
 217  * @cumm_bytes : cummulative bytes decoded
 218  * @str_type : stream type
 219  * @src : stream source
 220  * @device : output device type (medfield only)
 221  * @pcm_slot : pcm slot value
 222  */
 223 struct stream_info {
 224         unsigned int            status;
 225         unsigned int            prev;
 226         u8                      codec;
 227         unsigned int            sst_id;
 228         unsigned int            ops;
 229         struct list_head        bufs;
 230         struct mutex            lock; /* mutex */
 231         spinlock_t          pcm_lock;
 232         bool                    mmapped;
 233         unsigned int            sg_index; /*  current buf Index  */
 234         unsigned char __user    *cur_ptr; /*  Current static bufs  */
 235         struct snd_sst_buf_entry __user *buf_entry;
 236         struct sst_block        data_blk; /* stream ops block */
 237         struct sst_block        ctrl_blk; /* stream control cmd block */
 238         enum snd_sst_buf_type   buf_type;
 239         void                    *pcm_substream;
 240         void (*period_elapsed) (void *pcm_substream);
 241         unsigned int            sfreq;
 242         void                    *decode_ibuf, *decode_obuf;
 243         unsigned int            decode_isize, decode_osize;
 244         u8 decode_ibuf_type, decode_obuf_type;
 245         unsigned int            idecode_alloc;
 246         unsigned int            need_draining;
 247         unsigned int            str_type;
 248         u32                     curr_bytes;
 249         u32                     cumm_bytes;
 250         u32                     src;
 251         enum snd_sst_audio_device_type device;
 252         u8                      pcm_slot;
 253 };
 254
 255 /*
 256  * struct stream_alloc_bloc - this structure is used for blocking the user's
 257  * alloc calls to fw's response to alloc calls
 258  *
 259  * @sst_id : session id of blocked stream
 260  * @ops_block : ops block struture
 261  */
 262 struct stream_alloc_block {
 263         int                     sst_id; /* session id of blocked stream */
 264         struct sst_block        ops_block; /* ops block struture */
 265 };
 266
 267 #define SST_FW_SIGN "$SST"
 268 #define SST_FW_LIB_SIGN "$LIB"
 269
 270 /*
 271  * struct fw_header - FW file headers
 272  *
 273  * @signature : FW signature
 274  * @modules : # of modules
 275  * @file_format : version of header format
 276  * @reserved : reserved fields
 277  */
 278 struct fw_header {
 279         unsigned char signature[FW_SIGNATURE_SIZE]; /* FW signature */
 280         u32 file_size; /* size of fw minus this header */
 281         u32 modules; /*  # of modules */
 282         u32 file_format; /* version of header format */
 283         u32 reserved[4];
 284 };
 285
 286 struct fw_module_header {
 287         unsigned char signature[FW_SIGNATURE_SIZE]; /* module signature */
 288         u32 mod_size; /* size of module */
 289         u32 blocks; /* # of blocks */
 290         u32 type; /* codec type, pp lib */
 291         u32 entry_point;
 292 };
 293
 294 struct dma_block_info {
 295         enum sst_ram_type       type;   /* IRAM/DRAM */
 296         u32                     size;   /* Bytes */
 297         u32                     ram_offset; /* Offset in I/DRAM */
 298         u32                     rsvd;   /* Reserved field */
 299 };
 300
 301 struct ioctl_pvt_data {
 302         int                     str_id;
 303         int                     pvt_id;
 304 };
 305
 306 struct sst_ipc_msg_wq {
 307         union ipc_header        header;
 308         char mailbox[SST_MAILBOX_SIZE];
 309         struct work_struct      wq;
 310 };
 311
 312 struct mad_ops_wq {
 313         int stream_id;
 314         enum sst_controls control_op;
 315         struct work_struct      wq;
 316
 317 };
 318
 319 #define SST_MMAP_PAGES  (640*1024 / PAGE_SIZE)
 320 #define SST_MMAP_STEP   (40*1024 / PAGE_SIZE)
 321
 322 /***
 323  * struct intel_sst_drv - driver ops
 324  *
 325  * @pmic_state : pmic state
 326  * @pmic_vendor : pmic vendor detected
 327  * @sst_state : current sst device state
 328  * @pci_id : PCI device id loaded
 329  * @shim : SST shim pointer
 330  * @mailbox : SST mailbox pointer
 331  * @iram : SST IRAM pointer
 332  * @dram : SST DRAM pointer
 333  * @shim_phy_add : SST shim phy addr
 334  * @ipc_dispatch_list : ipc messages dispatched
 335  * @ipc_post_msg_wq : wq to post IPC messages context
 336  * @ipc_process_msg : wq to process msgs from FW context
 337  * @ipc_process_reply : wq to process reply from FW context
 338  * @ipc_post_msg : wq to post reply from FW context
 339  * @mad_ops : MAD driver operations registered
 340  * @mad_wq : MAD driver wq
 341  * @post_msg_wq : wq to post IPC messages
 342  * @process_msg_wq : wq to process msgs from FW
 343  * @process_reply_wq : wq to process reply from FW
 344  * @streams : sst stream contexts
 345  * @alloc_block : block structure for alloc
 346  * @tgt_dev_blk : block structure for target device
 347  * @fw_info_blk : block structure for fw info block
 348  * @vol_info_blk : block structure for vol info block
 349  * @mute_info_blk : block structure for mute info block
 350  * @hs_info_blk : block structure for hs info block
 351  * @list_lock : sst driver list lock (deprecated)
 352  * @list_spin_lock : sst driver spin lock block
 353  * @scard_ops : sst card ops
 354  * @pci : sst pci device struture
 355  * @active_streams : sst active streams
 356  * @sst_lock : sst device lock
 357  * @stream_lock : sst stream lock
 358  * @unique_id : sst unique id
 359  * @stream_cnt : total sst active stream count
 360  * @pb_streams : total active pb streams
 361  * @cp_streams : total active cp streams
 362  * @lpe_stalled : lpe stall status
 363  * @pmic_port_instance : active pmic port instance
 364  * @rx_time_slot_status : active rx slot
 365  * @lpaudio_start : lpaudio status
 366  * @audio_start : audio status
 367  * @devt_d : pointer to /dev/lpe node
 368  * @devt_c : pointer to /dev/lpe_ctrl node
 369  * @max_streams : max streams allowed
 370  */
 371 struct intel_sst_drv {
 372         bool                    pmic_state;
 373         int                     pmic_vendor;
 374         int                     sst_state;
 375         unsigned int            pci_id;
 376         void __iomem            *shim;
 377         void __iomem            *mailbox;
 378         void __iomem            *iram;
 379         void __iomem            *dram;
 380         unsigned int            shim_phy_add;
 381         struct list_head        ipc_dispatch_list;
 382         struct work_struct      ipc_post_msg_wq;
 383         struct sst_ipc_msg_wq   ipc_process_msg;
 384         struct sst_ipc_msg_wq   ipc_process_reply;
 385         struct sst_ipc_msg_wq   ipc_post_msg;
 386         struct mad_ops_wq       mad_ops;
 387         wait_queue_head_t       wait_queue;
 388         struct workqueue_struct *mad_wq;
 389         struct workqueue_struct *post_msg_wq;
 390         struct workqueue_struct *process_msg_wq;
 391         struct workqueue_struct *process_reply_wq;
 392
 393         struct stream_info      streams[MAX_NUM_STREAMS];
 394         struct stream_alloc_block alloc_block[MAX_ACTIVE_STREAM];
 395         struct sst_block        tgt_dev_blk, fw_info_blk,
 396                                 vol_info_blk, mute_info_blk, hs_info_blk;
 397         struct mutex            list_lock;/* mutex for IPC list locking */
 398         spinlock_t      list_spin_lock; /* mutex for IPC list locking */
 399         struct snd_pmic_ops     *scard_ops;
 400         struct pci_dev          *pci;
 401         int active_streams[MAX_NUM_STREAMS];
 402         void                    *mmap_mem;
 403         struct mutex            sst_lock;
 404         struct mutex            stream_lock;
 405         unsigned int            mmap_len;
 406         unsigned int            unique_id;
 407         unsigned int            stream_cnt;     /* total streams */
 408         unsigned int            encoded_cnt;    /* enocded streams only */
 409         unsigned int            am_cnt;
 410         unsigned int            pb_streams;     /* pb streams active */
 411         unsigned int            cp_streams;     /* cp streams active */
 412         unsigned int            lpe_stalled; /* LPE is stalled or not */
 413         unsigned int            pmic_port_instance; /*pmic port instance*/
 414         int                     rx_time_slot_status;
 415         unsigned int            lpaudio_start;
 416                 /* 1 - LPA stream(MP3 pb) in progress*/
 417         unsigned int            audio_start;
 418         dev_t                   devt_d, devt_c;
 419         unsigned int            max_streams;
 420 };
 421
 422 extern struct intel_sst_drv *sst_drv_ctx;
 423
 424 #define CHIP_REV_REG 0xff108000
 425 #define CHIP_REV_ADDR 0x78
 426
 427 /* misc definitions */
 428 #define FW_DWNL_ID 0xFF
 429 #define LOOP1 0x11111111
 430 #define LOOP2 0x22222222
 431 #define LOOP3 0x33333333
 432 #define LOOP4 0x44444444
 433
 434 #define SST_DEFAULT_PMIC_PORT 1 /*audio port*/
 435 /* NOTE: status will have +ve for good cases and -ve for error ones */
 436 #define MAX_STREAM_FIELD 255
 437
 438 int sst_alloc_stream(char *params, unsigned int stream_ops, u8 codec,
 439                                                 unsigned int session_id);
 440 int sst_alloc_stream_response(unsigned int str_id,
 441                                 struct snd_sst_alloc_response *response);
 442 int sst_stalled(void);
 443 int sst_pause_stream(int id);
 444 int sst_resume_stream(int id);
 445 int sst_enable_rx_timeslot(int status);
 446 int sst_drop_stream(int id);
 447 int sst_free_stream(int id);
 448 int sst_start_stream(int streamID);
 449 int sst_play_frame(int streamID);
 450 int sst_pcm_play_frame(int str_id, struct sst_stream_bufs *sst_buf);
 451 int sst_capture_frame(int streamID);
 452 int sst_set_stream_param(int streamID, struct snd_sst_params *str_param);
 453 int sst_target_device_select(struct snd_sst_target_device *target_device);
 454 int sst_decode(int str_id, struct snd_sst_dbufs *dbufs);
 455 int sst_get_decoded_bytes(int str_id, unsigned long long *bytes);
 456 int sst_get_fw_info(struct snd_sst_fw_info *info);
 457 int sst_get_stream_params(int str_id,
 458                 struct snd_sst_get_stream_params *get_params);
 459 int sst_get_stream(struct snd_sst_params *str_param);
 460 int sst_get_stream_allocated(struct snd_sst_params *str_param,
 461                                 struct snd_sst_lib_download **lib_dnld);
 462 int sst_drain_stream(int str_id);
 463 int sst_get_vol(struct snd_sst_vol *set_vol);
 464 int sst_set_vol(struct snd_sst_vol *set_vol);
 465 int sst_set_mute(struct snd_sst_mute *set_mute);
 466
 467
 468 void sst_post_message(struct work_struct *work);
 469 void sst_process_message(struct work_struct *work);
 470 void sst_process_reply(struct work_struct *work);
 471 void sst_process_mad_ops(struct work_struct *work);
 472 void sst_process_mad_jack_detection(struct work_struct *work);
 473
 474 long intel_sst_ioctl(struct file *file_ptr, unsigned int cmd,
 475                         unsigned long arg);
 476 int intel_sst_open(struct inode *i_node, struct file *file_ptr);
 477 int intel_sst_open_cntrl(struct inode *i_node, struct file *file_ptr);
 478 int intel_sst_release(struct inode *i_node, struct file *file_ptr);
 479 int intel_sst_release_cntrl(struct inode *i_node, struct file *file_ptr);
 480 int intel_sst_read(struct file *file_ptr, char __user *buf,
 481                         size_t count, loff_t *ppos);
 482 int intel_sst_write(struct file *file_ptr, const char __user *buf,
 483                         size_t count, loff_t *ppos);
 484 int intel_sst_mmap(struct file *fp, struct vm_area_struct *vma);
 485 ssize_t intel_sst_aio_write(struct kiocb *kiocb, const struct iovec *iov,
 486                         unsigned long nr_segs, loff_t  offset);
 487 ssize_t intel_sst_aio_read(struct kiocb *kiocb, const struct iovec *iov,
 488                         unsigned long nr_segs, loff_t offset);
 489
 490 int sst_load_fw(const struct firmware *fw, void *context);
 491 int sst_load_library(struct snd_sst_lib_download *lib, u8 ops);
 492 int sst_spi_mode_enable(void);
 493 int sst_get_block_stream(struct intel_sst_drv *sst_drv_ctx);
 494
 495 int sst_wait_interruptible(struct intel_sst_drv *sst_drv_ctx,
 496                                 struct sst_block *block);
 497 int sst_wait_interruptible_timeout(struct intel_sst_drv *sst_drv_ctx,
 498                 struct sst_block *block, int timeout);
 499 int sst_wait_timeout(struct intel_sst_drv *sst_drv_ctx,
 500                 struct stream_alloc_block *block);
 501 int sst_create_large_msg(struct ipc_post **arg);
 502 int sst_create_short_msg(struct ipc_post **arg);
 503 void sst_wake_up_alloc_block(struct intel_sst_drv *sst_drv_ctx,
 504                 u8 sst_id, int status, void *data);
 505 void sst_clear_interrupt(void);
 506 int intel_sst_resume(struct pci_dev *pci);
 507 int sst_download_fw(void);
 508 void free_stream_context(unsigned int str_id);
 509 void sst_clean_stream(struct stream_info *stream);
 510
 511 /*
 512  * sst_fill_header - inline to fill sst header
 513  *
 514  * @header : ipc header
 515  * @msg : IPC message to be sent
 516  * @large : is ipc large msg
 517  * @str_id : stream id
 518  *
 519  * this function is an inline function that sets the headers before
 520  * sending a message
 521  */
 522 static inline void sst_fill_header(union ipc_header *header,
 523                                 int msg, int large, int str_id)
 524 {
 525         header->part.msg_id = msg;
 526         header->part.str_id = str_id;
 527         header->part.large = large;
 528         header->part.done = 0;
 529         header->part.busy = 1;
 530         header->part.data = 0;
 531 }
 532
 533 /*
 534  * sst_assign_pvt_id - assign a pvt id for stream
 535  *
 536  * @sst_drv_ctx : driver context
 537  *
 538  * this inline function assigns a private id for calls that dont have stream
 539  * context yet, should be called with lock held
 540  */
 541 static inline unsigned int sst_assign_pvt_id(struct intel_sst_drv *sst_drv_ctx)
 542 {
 543         sst_drv_ctx->unique_id++;
 544         if (sst_drv_ctx->unique_id >= MAX_NUM_STREAMS)
 545                 sst_drv_ctx->unique_id = 1;
 546         return sst_drv_ctx->unique_id;
 547 }
 548
 549 /*
 550  * sst_init_stream - this function initialzes stream context
 551  *
 552  * @stream : stream struture
 553  * @codec : codec for stream
 554  * @sst_id : stream id
 555  * @ops : stream operation
 556  * @slot : stream pcm slot
 557  * @device : device type
 558  *
 559  * this inline function initialzes stream context for allocated stream
 560  */
 561 static inline void sst_init_stream(struct stream_info *stream,
 562                 int codec, int sst_id, int ops, u8 slot,
 563                 enum snd_sst_audio_device_type device)
 564 {
 565         stream->status = STREAM_INIT;
 566         stream->prev = STREAM_UN_INIT;
 567         stream->codec = codec;
 568         stream->sst_id = sst_id;
 569         stream->str_type = 0;
 570         stream->ops = ops;
 571         stream->data_blk.on = false;
 572         stream->data_blk.condition = false;
 573         stream->data_blk.ret_code = 0;
 574         stream->data_blk.data = NULL;
 575         stream->ctrl_blk.on = false;
 576         stream->ctrl_blk.condition = false;
 577         stream->ctrl_blk.ret_code = 0;
 578         stream->ctrl_blk.data = NULL;
 579         stream->need_draining = false;
 580         stream->decode_ibuf = NULL;
 581         stream->decode_isize = 0;
 582         stream->mmapped = false;
 583         stream->pcm_slot = slot;
 584         stream->device = device;
 585 }
 586
 587
 588 /*
 589  * sst_validate_strid - this function validates the stream id
 590  *
 591  * @str_id : stream id to be validated
 592  *
 593  * returns 0 if valid stream
 594  */
 595 static inline int sst_validate_strid(int str_id)
 596 {
 597         if (str_id <= 0 || str_id > sst_drv_ctx->max_streams) {
 598                 pr_err("SST ERR: invalid stream id : %d MAX_STREAMS:%d\n",
 599                                         str_id, sst_drv_ctx->max_streams);
 600                 return -EINVAL;
 601         } else
 602                 return 0;
 603 }
 604
 605 static inline int sst_shim_write(void __iomem *addr, int offset, int value)
 606 {
 607
 608         if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
 609                 writel(value, addr + SST_ISRD); /*dummy*/
 610         writel(value, addr + offset);
 611         return 0;
 612 }
 613
 614 static inline int sst_shim_read(void __iomem *addr, int offset)
 615 {
 616         return readl(addr + offset);
 617 }
 618 #endif /* __INTEL_SST_COMMON_H__ */