1 /* 2 * sst.h - Intel SST Driver for audio engine 3 * 4 * Copyright (C) 2008-14 Intel Corporation 5 * Authors: Vinod Koul <vinod.koul@intel.com> 6 * Harsha Priya <priya.harsha@intel.com> 7 * Dharageswari R <dharageswari.r@intel.com> 8 * KP Jeeja <jeeja.kp@intel.com> 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; version 2 of the License. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 21 * 22 * Common private declarations for SST 23 */ 24 #ifndef __SST_H__ 25 #define __SST_H__ 26 27 #include <linux/firmware.h> 28 29 /* driver names */ 30 #define SST_DRV_NAME "intel_sst_driver" 31 #define SST_MRFLD_PCI_ID 0x119A 32 #define SST_BYT_ACPI_ID 0x80860F28 33 #define SST_CHV_ACPI_ID 0x808622A8 34 35 #define SST_SUSPEND_DELAY 2000 36 #define FW_CONTEXT_MEM (64*1024) 37 #define SST_ICCM_BOUNDARY 4 38 #define SST_CONFIG_SSP_SIGN 0x7ffe8001 39 40 #define MRFLD_FW_VIRTUAL_BASE 0xC0000000 41 #define MRFLD_FW_DDR_BASE_OFFSET 0x0 42 #define MRFLD_FW_FEATURE_BASE_OFFSET 0x4 43 #define MRFLD_FW_BSS_RESET_BIT 0 44 45 extern const struct dev_pm_ops intel_sst_pm; 46 enum sst_states { 47 SST_FW_LOADING = 1, 48 SST_FW_RUNNING, 49 SST_RESET, 50 SST_SHUTDOWN, 51 }; 52 53 enum sst_algo_ops { 54 SST_SET_ALGO = 0, 55 SST_GET_ALGO = 1, 56 }; 57 58 #define SST_BLOCK_TIMEOUT 1000 59 60 #define FW_SIGNATURE_SIZE 4 61 #define FW_NAME_SIZE 32 62 63 /* stream states */ 64 enum sst_stream_states { 65 STREAM_UN_INIT = 0, /* Freed/Not used stream */ 66 STREAM_RUNNING = 1, /* Running */ 67 STREAM_PAUSED = 2, /* Paused stream */ 68 STREAM_INIT = 3, /* stream init, waiting for data */ 69 }; 70 71 enum sst_ram_type { 72 SST_IRAM = 1, 73 SST_DRAM = 2, 74 SST_DDR = 5, 75 SST_CUSTOM_INFO = 7, /* consists of FW binary information */ 76 }; 77 78 /* SST shim registers to structure mapping */ 79 union interrupt_reg { 80 struct { 81 u64 done_interrupt:1; 82 u64 busy_interrupt:1; 83 u64 rsvd:62; 84 } part; 85 u64 full; 86 }; 87 88 union sst_pisr_reg { 89 struct { 90 u32 pssp0:1; 91 u32 pssp1:1; 92 u32 rsvd0:3; 93 u32 dmac:1; 94 u32 rsvd1:26; 95 } part; 96 u32 full; 97 }; 98 99 union sst_pimr_reg { 100 struct { 101 u32 ssp0:1; 102 u32 ssp1:1; 103 u32 rsvd0:3; 104 u32 dmac:1; 105 u32 rsvd1:10; 106 u32 ssp0_sc:1; 107 u32 ssp1_sc:1; 108 u32 rsvd2:3; 109 u32 dmac_sc:1; 110 u32 rsvd3:10; 111 } part; 112 u32 full; 113 }; 114 115 union config_status_reg_mrfld { 116 struct { 117 u64 lpe_reset:1; 118 u64 lpe_reset_vector:1; 119 u64 runstall:1; 120 u64 pwaitmode:1; 121 u64 clk_sel:3; 122 u64 rsvd2:1; 123 u64 sst_clk:3; 124 u64 xt_snoop:1; 125 u64 rsvd3:4; 126 u64 clk_sel1:6; 127 u64 clk_enable:3; 128 u64 rsvd4:6; 129 u64 slim0baseclk:1; 130 u64 rsvd:32; 131 } part; 132 u64 full; 133 }; 134 135 union interrupt_reg_mrfld { 136 struct { 137 u64 done_interrupt:1; 138 u64 busy_interrupt:1; 139 u64 rsvd:62; 140 } part; 141 u64 full; 142 }; 143 144 union sst_imr_reg_mrfld { 145 struct { 146 u64 done_interrupt:1; 147 u64 busy_interrupt:1; 148 u64 rsvd:62; 149 } part; 150 u64 full; 151 }; 152 153 /** 154 * struct sst_block - This structure is used to block a user/fw data call to another 155 * fw/user call 156 * 157 * @condition: condition for blocking check 158 * @ret_code: ret code when block is released 159 * @data: data ptr 160 * @size: size of data 161 * @on: block condition 162 * @msg_id: msg_id = msgid in mfld/ctp, mrfld = NULL 163 * @drv_id: str_id in mfld/ctp, = drv_id in mrfld 164 * @node: list head node 165 */ 166 struct sst_block { 167 bool condition; 168 int ret_code; 169 void *data; 170 u32 size; 171 bool on; 172 u32 msg_id; 173 u32 drv_id; 174 struct list_head node; 175 }; 176 177 /** 178 * struct stream_info - structure that holds the stream information 179 * 180 * @status : stream current state 181 * @prev : stream prev state 182 * @resume_status : stream current state to restore on resume 183 * @resume_prev : stream prev state to restore on resume 184 * @lock : stream mutex for protecting state 185 * @alloc_param : parameters used for stream (re-)allocation 186 * @pcm_substream : PCM substream 187 * @period_elapsed : PCM period elapsed callback 188 * @sfreq : stream sampling freq 189 * @cumm_bytes : cummulative bytes decoded 190 */ 191 struct stream_info { 192 unsigned int status; 193 unsigned int prev; 194 unsigned int resume_status; 195 unsigned int resume_prev; 196 struct mutex lock; 197 struct snd_sst_alloc_mrfld alloc_param; 198 199 void *pcm_substream; 200 void (*period_elapsed)(void *pcm_substream); 201 202 unsigned int sfreq; 203 u32 cumm_bytes; 204 205 void *compr_cb_param; 206 void (*compr_cb)(void *compr_cb_param); 207 208 void *drain_cb_param; 209 void (*drain_notify)(void *drain_cb_param); 210 211 unsigned int num_ch; 212 unsigned int pipe_id; 213 unsigned int task_id; 214 }; 215 216 #define SST_FW_SIGN "$SST" 217 #define SST_FW_LIB_SIGN "$LIB" 218 219 /** 220 * struct sst_fw_header - FW file headers 221 * 222 * @signature : FW signature 223 * @file_size: size of fw image 224 * @modules : # of modules 225 * @file_format : version of header format 226 * @reserved : reserved fields 227 */ 228 struct sst_fw_header { 229 unsigned char signature[FW_SIGNATURE_SIZE]; 230 u32 file_size; 231 u32 modules; 232 u32 file_format; 233 u32 reserved[4]; 234 }; 235 236 /** 237 * struct fw_module_header - module header in FW 238 * 239 * @signature: module signature 240 * @mod_size: size of module 241 * @blocks: block count 242 * @type: block type 243 * @entry_point: module netry point 244 */ 245 struct fw_module_header { 246 unsigned char signature[FW_SIGNATURE_SIZE]; 247 u32 mod_size; 248 u32 blocks; 249 u32 type; 250 u32 entry_point; 251 }; 252 253 /** 254 * struct fw_block_info - block header for FW 255 * 256 * @type: block ram type I/D 257 * @size: size of block 258 * @ram_offset: offset in ram 259 */ 260 struct fw_block_info { 261 enum sst_ram_type type; 262 u32 size; 263 u32 ram_offset; 264 u32 rsvd; 265 }; 266 267 struct sst_runtime_param { 268 struct snd_sst_runtime_params param; 269 }; 270 271 struct sst_sg_list { 272 struct scatterlist *src; 273 struct scatterlist *dst; 274 int list_len; 275 unsigned int sg_idx; 276 }; 277 278 struct sst_memcpy_list { 279 struct list_head memcpylist; 280 void *dstn; 281 const void *src; 282 u32 size; 283 bool is_io; 284 }; 285 286 /*Firmware Module Information*/ 287 enum sst_lib_dwnld_status { 288 SST_LIB_NOT_FOUND = 0, 289 SST_LIB_FOUND, 290 SST_LIB_DOWNLOADED, 291 }; 292 293 struct sst_module_info { 294 const char *name; /*Library name*/ 295 u32 id; /*Module ID*/ 296 u32 entry_pt; /*Module entry point*/ 297 u8 status; /*module status*/ 298 u8 rsvd1; 299 u16 rsvd2; 300 }; 301 302 /* 303 * Structure for managing the Library Region(1.5MB) 304 * in DDR in Merrifield 305 */ 306 struct sst_mem_mgr { 307 phys_addr_t current_base; 308 int avail; 309 unsigned int count; 310 }; 311 312 struct sst_ipc_reg { 313 int ipcx; 314 int ipcd; 315 }; 316 317 struct sst_fw_save { 318 void *iram; /* allocated via kvmalloc() */ 319 void *dram; /* allocated via kvmalloc() */ 320 void *sram; /* allocated via kvmalloc() */ 321 void *ddr; /* allocated via kvmalloc() */ 322 }; 323 324 /** 325 * struct intel_sst_drv - driver ops 326 * 327 * @sst_state : current sst device state 328 * @dev_id : device identifier, pci_id for pci devices and acpi_id for acpi 329 * devices 330 * @shim : SST shim pointer 331 * @mailbox : SST mailbox pointer 332 * @iram : SST IRAM pointer 333 * @dram : SST DRAM pointer 334 * @pdata : SST info passed as a part of pci platform data 335 * @shim_phy_add : SST shim phy addr 336 * @ipc_dispatch_list : ipc messages dispatched 337 * @rx_list : to copy the process_reply/process_msg from DSP 338 * @ipc_post_msg_wq : wq to post IPC messages context 339 * @mad_ops : MAD driver operations registered 340 * @mad_wq : MAD driver wq 341 * @post_msg_wq : wq to post IPC messages 342 * @streams : sst stream contexts 343 * @list_lock : sst driver list lock (deprecated) 344 * @ipc_spin_lock : spin lock to handle audio shim access and ipc queue 345 * @block_lock : spin lock to add block to block_list and assign pvt_id 346 * @rx_msg_lock : spin lock to handle the rx messages from the DSP 347 * @scard_ops : sst card ops 348 * @pci : sst pci device struture 349 * @dev : pointer to current device struct 350 * @sst_lock : sst device lock 351 * @pvt_id : sst private id 352 * @stream_cnt : total sst active stream count 353 * @pb_streams : total active pb streams 354 * @cp_streams : total active cp streams 355 * @audio_start : audio status 356 * @qos : PM Qos struct 357 * firmware_name : Firmware / Library name 358 */ 359 struct intel_sst_drv { 360 int sst_state; 361 int irq_num; 362 unsigned int dev_id; 363 void __iomem *ddr; 364 void __iomem *shim; 365 void __iomem *mailbox; 366 void __iomem *iram; 367 void __iomem *dram; 368 unsigned int mailbox_add; 369 unsigned int iram_base; 370 unsigned int dram_base; 371 unsigned int shim_phy_add; 372 unsigned int iram_end; 373 unsigned int dram_end; 374 unsigned int ddr_end; 375 unsigned int ddr_base; 376 unsigned int mailbox_recv_offset; 377 struct list_head block_list; 378 struct list_head ipc_dispatch_list; 379 struct sst_platform_info *pdata; 380 struct list_head rx_list; 381 struct work_struct ipc_post_msg_wq; 382 wait_queue_head_t wait_queue; 383 struct workqueue_struct *post_msg_wq; 384 unsigned int tstamp; 385 /* str_id 0 is not used */ 386 struct stream_info streams[MAX_NUM_STREAMS+1]; 387 spinlock_t ipc_spin_lock; 388 spinlock_t block_lock; 389 spinlock_t rx_msg_lock; 390 struct pci_dev *pci; 391 struct device *dev; 392 volatile long unsigned pvt_id; 393 struct mutex sst_lock; 394 unsigned int stream_cnt; 395 unsigned int csr_value; 396 void *fw_in_mem; 397 struct sst_sg_list fw_sg_list, library_list; 398 struct intel_sst_ops *ops; 399 struct sst_info info; 400 struct pm_qos_request *qos; 401 unsigned int use_dma; 402 unsigned int use_lli; 403 atomic_t fw_clear_context; 404 bool lib_dwnld_reqd; 405 struct list_head memcpy_list; 406 struct sst_ipc_reg ipc_reg; 407 struct sst_mem_mgr lib_mem_mgr; 408 /* 409 * Holder for firmware name. Due to async call it needs to be 410 * persistent till worker thread gets called 411 */ 412 char firmware_name[FW_NAME_SIZE]; 413 414 struct snd_sst_fw_version fw_version; 415 struct sst_fw_save *fw_save; 416 }; 417 418 /* misc definitions */ 419 #define FW_DWNL_ID 0x01 420 421 struct intel_sst_ops { 422 irqreturn_t (*interrupt)(int, void *); 423 irqreturn_t (*irq_thread)(int, void *); 424 void (*clear_interrupt)(struct intel_sst_drv *ctx); 425 int (*start)(struct intel_sst_drv *ctx); 426 int (*reset)(struct intel_sst_drv *ctx); 427 void (*process_reply)(struct intel_sst_drv *ctx, struct ipc_post *msg); 428 int (*post_message)(struct intel_sst_drv *ctx, 429 struct ipc_post *msg, bool sync); 430 void (*process_message)(struct ipc_post *msg); 431 void (*set_bypass)(bool set); 432 int (*save_dsp_context)(struct intel_sst_drv *sst); 433 void (*restore_dsp_context)(void); 434 int (*alloc_stream)(struct intel_sst_drv *ctx, void *params); 435 void (*post_download)(struct intel_sst_drv *sst); 436 }; 437 438 int sst_realloc_stream(struct intel_sst_drv *sst_drv_ctx, int str_id); 439 int sst_pause_stream(struct intel_sst_drv *sst_drv_ctx, int id); 440 int sst_resume_stream(struct intel_sst_drv *sst_drv_ctx, int id); 441 int sst_drop_stream(struct intel_sst_drv *sst_drv_ctx, int id); 442 int sst_free_stream(struct intel_sst_drv *sst_drv_ctx, int id); 443 int sst_start_stream(struct intel_sst_drv *sst_drv_ctx, int str_id); 444 int sst_send_byte_stream_mrfld(struct intel_sst_drv *ctx, 445 struct snd_sst_bytes_v2 *sbytes); 446 int sst_set_stream_param(int str_id, struct snd_sst_params *str_param); 447 int sst_set_metadata(int str_id, char *params); 448 int sst_get_stream(struct intel_sst_drv *sst_drv_ctx, 449 struct snd_sst_params *str_param); 450 int sst_get_stream_allocated(struct intel_sst_drv *ctx, 451 struct snd_sst_params *str_param, 452 struct snd_sst_lib_download **lib_dnld); 453 int sst_drain_stream(struct intel_sst_drv *sst_drv_ctx, 454 int str_id, bool partial_drain); 455 int sst_post_message_mrfld(struct intel_sst_drv *ctx, 456 struct ipc_post *msg, bool sync); 457 void sst_process_reply_mrfld(struct intel_sst_drv *ctx, struct ipc_post *msg); 458 int sst_start_mrfld(struct intel_sst_drv *ctx); 459 int intel_sst_reset_dsp_mrfld(struct intel_sst_drv *ctx); 460 void intel_sst_clear_intr_mrfld(struct intel_sst_drv *ctx); 461 462 int sst_load_fw(struct intel_sst_drv *ctx); 463 int sst_load_library(struct snd_sst_lib_download *lib, u8 ops); 464 void sst_post_download_mrfld(struct intel_sst_drv *ctx); 465 int sst_get_block_stream(struct intel_sst_drv *sst_drv_ctx); 466 void sst_memcpy_free_resources(struct intel_sst_drv *ctx); 467 468 int sst_wait_interruptible(struct intel_sst_drv *sst_drv_ctx, 469 struct sst_block *block); 470 int sst_wait_timeout(struct intel_sst_drv *sst_drv_ctx, 471 struct sst_block *block); 472 int sst_create_ipc_msg(struct ipc_post **arg, bool large); 473 int free_stream_context(struct intel_sst_drv *ctx, unsigned int str_id); 474 void sst_clean_stream(struct stream_info *stream); 475 int intel_sst_register_compress(struct intel_sst_drv *sst); 476 int intel_sst_remove_compress(struct intel_sst_drv *sst); 477 void sst_cdev_fragment_elapsed(struct intel_sst_drv *ctx, int str_id); 478 int sst_send_sync_msg(int ipc, int str_id); 479 int sst_get_num_channel(struct snd_sst_params *str_param); 480 int sst_get_sfreq(struct snd_sst_params *str_param); 481 int sst_alloc_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, void *params); 482 void sst_restore_fw_context(void); 483 struct sst_block *sst_create_block(struct intel_sst_drv *ctx, 484 u32 msg_id, u32 drv_id); 485 int sst_create_block_and_ipc_msg(struct ipc_post **arg, bool large, 486 struct intel_sst_drv *sst_drv_ctx, struct sst_block **block, 487 u32 msg_id, u32 drv_id); 488 int sst_free_block(struct intel_sst_drv *ctx, struct sst_block *freed); 489 int sst_wake_up_block(struct intel_sst_drv *ctx, int result, 490 u32 drv_id, u32 ipc, void *data, u32 size); 491 int sst_request_firmware_async(struct intel_sst_drv *ctx); 492 int sst_driver_ops(struct intel_sst_drv *sst); 493 struct sst_platform_info *sst_get_acpi_driver_data(const char *hid); 494 void sst_firmware_load_cb(const struct firmware *fw, void *context); 495 int sst_prepare_and_post_msg(struct intel_sst_drv *sst, 496 int task_id, int ipc_msg, int cmd_id, int pipe_id, 497 size_t mbox_data_len, const void *mbox_data, void **data, 498 bool large, bool fill_dsp, bool sync, bool response); 499 500 void sst_process_pending_msg(struct work_struct *work); 501 int sst_assign_pvt_id(struct intel_sst_drv *sst_drv_ctx); 502 int sst_validate_strid(struct intel_sst_drv *sst_drv_ctx, int str_id); 503 struct stream_info *get_stream_info(struct intel_sst_drv *sst_drv_ctx, 504 int str_id); 505 int get_stream_id_mrfld(struct intel_sst_drv *sst_drv_ctx, 506 u32 pipe_id); 507 u32 relocate_imr_addr_mrfld(u32 base_addr); 508 void sst_add_to_dispatch_list_and_post(struct intel_sst_drv *sst, 509 struct ipc_post *msg); 510 int sst_pm_runtime_put(struct intel_sst_drv *sst_drv); 511 int sst_shim_write(void __iomem *addr, int offset, int value); 512 u32 sst_shim_read(void __iomem *addr, int offset); 513 u64 sst_reg_read64(void __iomem *addr, int offset); 514 int sst_shim_write64(void __iomem *addr, int offset, u64 value); 515 u64 sst_shim_read64(void __iomem *addr, int offset); 516 void sst_set_fw_state_locked( 517 struct intel_sst_drv *sst_drv_ctx, int sst_state); 518 void sst_fill_header_mrfld(union ipc_header_mrfld *header, 519 int msg, int task_id, int large, int drv_id); 520 void sst_fill_header_dsp(struct ipc_dsp_hdr *dsp, int msg, 521 int pipe_id, int len); 522 523 int sst_register(struct device *); 524 int sst_unregister(struct device *); 525 526 int sst_alloc_drv_context(struct intel_sst_drv **ctx, 527 struct device *dev, unsigned int dev_id); 528 int sst_context_init(struct intel_sst_drv *ctx); 529 void sst_context_cleanup(struct intel_sst_drv *ctx); 530 void sst_configure_runtime_pm(struct intel_sst_drv *ctx); 531 void memcpy32_toio(void __iomem *dst, const void *src, int count); 532 void memcpy32_fromio(void *dst, const void __iomem *src, int count); 533 534 #endif 535