inline int had_read_modify(uint32_t reg_addr, uint32_t data, uint32_t mask) { int retval; struct snd_intelhad *intelhaddata = had_data; retval = had_get_hwstate(intelhaddata); if (!retval) retval = intelhaddata->reg_ops.hdmi_audio_read_modify( reg_addr, data, mask); return retval; }
inline int had_write_register(uint32_t reg_addr, uint32_t data) { int retval; struct snd_intelhad *intelhaddata = had_data; retval = had_get_hwstate(intelhaddata); if (!retval) retval = intelhaddata->reg_ops.hdmi_audio_write_register( reg_addr, data); return retval; }
inline int had_set_caps(enum had_caps_list set_element , void *caps) { int retval; struct snd_intelhad *intelhaddata = had_data; retval = had_get_hwstate(intelhaddata); if (!retval) retval = intelhaddata->query_ops.hdmi_audio_set_caps( set_element, caps); return retval; }
/** * hdmi_audio_resume - power management resume function * *@haddata: pointer to HAD private data * * This function is called by client driver to resume the * hdmi audio. */ int hdmi_audio_resume(void *haddata) { int caps, retval = 0; struct snd_intelhad *intelhaddata = (struct snd_intelhad *)haddata; unsigned long flag_irqs; pr_debug("Enter:%s", __func__); spin_lock_irqsave(&intelhaddata->had_spinlock, flag_irqs); if (intelhaddata->drv_status == HAD_DRV_DISCONNECTED) { spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); pr_debug("had not connected\n"); return 0; } if (HAD_DRV_SUSPENDED != intelhaddata->drv_status) { spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); pr_err("had is not in suspended state\n"); return 0; } if (had_get_hwstate(intelhaddata)) { spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); pr_err("Failed to resume. Device not accessible\n"); return -ENODEV; } intelhaddata->drv_status = HAD_DRV_CONNECTED; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); /* ToDo: Need to enable UNDERRUN interrupts as well caps = HDMI_AUDIO_UNDERRUN | HDMI_AUDIO_BUFFER_DONE; */ caps = HDMI_AUDIO_BUFFER_DONE; retval = had_set_caps(HAD_SET_ENABLE_AUDIO_INT, &caps); retval = had_set_caps(HAD_SET_ENABLE_AUDIO, NULL); pr_debug("Exit:%s", __func__); return retval; }
/** * snd_intelhad_pcm_prepare- internal preparation before starting a stream * * @substream: substream for which the function is called * * This function is called when a stream is started for internal preparation. */ static int snd_intelhad_pcm_prepare(struct snd_pcm_substream *substream) { int retval; u32 disp_samp_freq, n_param; struct snd_intelhad *intelhaddata; struct snd_pcm_runtime *runtime; struct had_pvt_data *had_stream; pr_debug("pcm_prepare called\n"); intelhaddata = snd_pcm_substream_chip(substream); runtime = substream->runtime; had_stream = intelhaddata->private_data; if (had_get_hwstate(intelhaddata)) { pr_err("%s: HDMI cable plugged-out\n", __func__); snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED); retval = -ENODEV; goto prep_end; } pr_debug("period_size=%d\n", frames_to_bytes(runtime, runtime->period_size)); pr_debug("periods=%d\n", runtime->periods); pr_debug("buffer_size=%d\n", snd_pcm_lib_buffer_bytes(substream)); pr_debug("rate=%d\n", runtime->rate); pr_debug("channels=%d\n", runtime->channels); if (intelhaddata->stream_info.str_id) { pr_debug("_prepare is called for existing str_id#%d\n", intelhaddata->stream_info.str_id); retval = snd_intelhad_pcm_trigger(substream, SNDRV_PCM_TRIGGER_STOP); return retval; } retval = snd_intelhad_init_stream(substream); if (retval) goto prep_end; /* Get N value in KHz */ retval = had_get_caps(HAD_GET_SAMPLING_FREQ, &disp_samp_freq); if (retval) { pr_err("querying display sampling freq failed %#x\n", retval); goto prep_end; } had_get_caps(HAD_GET_ELD, &intelhaddata->eeld); retval = snd_intelhad_prog_n(substream->runtime->rate, &n_param, intelhaddata); if (retval) { pr_err("programming N value failed %#x\n", retval); goto prep_end; } snd_intelhad_prog_cts(substream->runtime->rate, disp_samp_freq, n_param, intelhaddata); snd_intelhad_prog_dip(substream, intelhaddata, 0); retval = snd_intelhad_init_audio_ctrl(substream, intelhaddata, 0); /* Prog buffer address */ retval = snd_intelhad_prog_buffer(intelhaddata, HAD_BUF_TYPE_A, HAD_BUF_TYPE_D); prep_end: return retval; }
/** * snd_intelhad_pcm_trigger - stream activities are handled here * @substream:substream for which the stream function is called * @cmd:the stream commamd thats requested from upper layer * This function is called whenever an a stream activity is invoked */ static int snd_intelhad_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { int caps, retval = 0; unsigned long flag_irq; struct snd_intelhad *intelhaddata; struct had_stream_pvt *stream; struct had_pvt_data *had_stream; intelhaddata = snd_pcm_substream_chip(substream); stream = substream->runtime->private_data; had_stream = intelhaddata->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: pr_debug("Trigger Start\n"); /* Disable local INTRs till register prgmng is done */ if (had_get_hwstate(intelhaddata)) { pr_err("_START: HDMI cable plugged-out\n"); retval = -ENODEV; break; } stream->stream_status = STREAM_RUNNING; spin_lock_irqsave(&intelhaddata->had_spinlock, flag_irq); had_stream->stream_type = HAD_RUNNING_STREAM; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irq); /* Enable Audio */ /* ToDo: Need to enable UNDERRUN interrupts as well caps = HDMI_AUDIO_UNDERRUN | HDMI_AUDIO_BUFFER_DONE; */ caps = HDMI_AUDIO_BUFFER_DONE; retval = had_set_caps(HAD_SET_ENABLE_AUDIO_INT, &caps); retval = had_set_caps(HAD_SET_ENABLE_AUDIO, NULL); had_read_modify(AUD_CONFIG, 1, BIT(0)); pr_debug("Processed _Start\n"); break; case SNDRV_PCM_TRIGGER_STOP: pr_debug("Trigger Stop\n"); spin_lock_irqsave(&intelhaddata->had_spinlock, flag_irq); intelhaddata->stream_info.str_id = 0; intelhaddata->curr_buf = 0; /* Stop reporting BUFFER_DONE/UNDERRUN to above layers*/ had_stream->stream_type = HAD_INIT; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irq); /* Disable Audio */ /* ToDo: Need to disable UNDERRUN interrupts as well caps = HDMI_AUDIO_UNDERRUN | HDMI_AUDIO_BUFFER_DONE; */ caps = HDMI_AUDIO_BUFFER_DONE; had_set_caps(HAD_SET_DISABLE_AUDIO_INT, &caps); had_set_caps(HAD_SET_DISABLE_AUDIO, NULL); had_read_modify(AUD_CONFIG, 0, BIT(0)); /* Reset buffer pointers */ had_write_register(AUD_HDMI_STATUS, 1); had_write_register(AUD_HDMI_STATUS, 0); stream->stream_status = STREAM_DROPPED; break; default: retval = -EINVAL; } return retval; }
/** * snd_intelhad_init_audio_ctrl - to initialize audio channel status * registers and confgiuration registers * * @substream:substream for which the prepare function is called * @intelhaddata:substream private data * * This function is called in the prepare callback */ int snd_intelhad_init_audio_ctrl(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata, int flag_silence) { union aud_cfg cfg_val = {.cfg_regval = 0}; union aud_ch_status_0 ch_stat0 = {.status_0_regval = 0}; union aud_ch_status_1 ch_stat1 = {.status_1_regval = 0}; union aud_buf_config buf_cfg = {.buf_cfgval = 0}; u8 channels; int format, retval; u32 data; ch_stat0.status_0_regx.lpcm_id = (intelhaddata->aes_bits & IEC958_AES0_NONAUDIO)>>1; ch_stat0.status_0_regx.clk_acc = (intelhaddata->aes_bits & IEC958_AES3_CON_CLOCK)>>4; switch (substream->runtime->rate) { case AUD_SAMPLE_RATE_32: ch_stat0.status_0_regx.samp_freq = CH_STATUS_MAP_32KHZ; break; case AUD_SAMPLE_RATE_44_1: case AUD_SAMPLE_RATE_88_2: case AUD_SAMPLE_RATE_176_4: ch_stat0.status_0_regx.samp_freq = CH_STATUS_MAP_44KHZ; break; case AUD_SAMPLE_RATE_48: case AUD_SAMPLE_RATE_96: case HAD_MAX_RATE: ch_stat0.status_0_regx.samp_freq = CH_STATUS_MAP_48KHZ; break; default: return -EINVAL; break; } had_write_register(AUD_CH_STATUS_0, ch_stat0.status_0_regval); format = substream->runtime->format; if (format == SNDRV_PCM_FORMAT_S16_LE) { ch_stat1.status_1_regx.max_wrd_len = MAX_SMPL_WIDTH_20; ch_stat1.status_1_regx.wrd_len = SMPL_WIDTH_16BITS; } else if (format == SNDRV_PCM_FORMAT_S24_LE) { ch_stat1.status_1_regx.max_wrd_len = MAX_SMPL_WIDTH_24; ch_stat1.status_1_regx.wrd_len = SMPL_WIDTH_24BITS; } else { ch_stat1.status_1_regx.max_wrd_len = 0; ch_stat1.status_1_regx.wrd_len = 0; } had_write_register(AUD_CH_STATUS_1, ch_stat1.status_1_regval); buf_cfg.buf_cfg_regx.fifo_width = FIFO_THRESHOLD; buf_cfg.buf_cfg_regx.aud_delay = 0; had_write_register(AUD_BUF_CONFIG, buf_cfg.buf_cfgval); channels = substream->runtime->channels; switch (channels) { case 1: case 2: cfg_val.cfg_regx.num_ch = CH_STEREO; cfg_val.cfg_regx.layout = LAYOUT0; break; case 3: case 4: cfg_val.cfg_regx.num_ch = CH_THREE_FOUR; cfg_val.cfg_regx.layout = LAYOUT1; break; case 5: case 6: cfg_val.cfg_regx.num_ch = CH_FIVE_SIX; cfg_val.cfg_regx.layout = LAYOUT1; break; case 7: case 8: cfg_val.cfg_regx.num_ch = CH_SEVEN_EIGHT; cfg_val.cfg_regx.layout = LAYOUT1; break; } cfg_val.cfg_regx.val_bit = 1; had_write_register(AUD_CONFIG, cfg_val.cfg_regval); return 0; } /** * snd_intelhad_prog_dip - to initialize Data Island Packets registers * * @substream:substream for which the prepare function is called * @intelhaddata:substream private data * * This function is called in the prepare callback */ static void snd_intelhad_prog_dip(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata, int flag_silence) { int i; union aud_ctrl_st ctrl_state = {.ctrl_val = 0}; union aud_info_frame2 frame2 = {.fr2_val = 0}; union aud_info_frame3 frame3 = {.fr3_val = 0}; u8 checksum = 0; had_write_register(AUD_CNTL_ST, ctrl_state.ctrl_val); frame2.fr2_regx.chnl_cnt = substream->runtime->channels - 1; /*TODO: Read from intelhaddata->eeld.speaker_allocation_block;*/ frame3.fr3_regx.chnl_alloc = CHANNEL_ALLOCATION; /*Calculte the byte wide checksum for all valid DIP words*/ for (i = 0; i < BYTES_PER_WORD; i++) checksum += (INFO_FRAME_WORD1 >> i*BITS_PER_BYTE) & MASK_BYTE0; for (i = 0; i < BYTES_PER_WORD; i++) checksum += (frame2.fr2_val >> i*BITS_PER_BYTE) & MASK_BYTE0; for (i = 0; i < BYTES_PER_WORD; i++) checksum += (frame3.fr3_val >> i*BITS_PER_BYTE) & MASK_BYTE0; frame2.fr2_regx.chksum = -(checksum); had_write_register(AUD_HDMIW_INFOFR, INFO_FRAME_WORD1); had_write_register(AUD_HDMIW_INFOFR, frame2.fr2_val); had_write_register(AUD_HDMIW_INFOFR, frame3.fr3_val); /* program remaining DIP words with zero */ for (i = 0; i < HAD_MAX_DIP_WORDS-VALID_DIP_WORDS; i++) had_write_register(AUD_HDMIW_INFOFR, 0x0); ctrl_state.ctrl_regx.dip_freq = 1; ctrl_state.ctrl_regx.dip_en_sta = 1; had_write_register(AUD_CNTL_ST, ctrl_state.ctrl_val); } /** * snd_intelhad_prog_buffer - programs buffer * address and length registers * * @substream:substream for which the prepare function is called * @intelhaddata:substream private data * * This function programs ring buffer address and length into registers. */ int snd_intelhad_prog_buffer(struct snd_intelhad *intelhaddata, int start, int end) { u32 ring_buf_addr, ring_buf_size, period_bytes; u8 i, num_periods; struct snd_pcm_substream *substream; substream = intelhaddata->stream_info.had_substream; if (!substream) { pr_err("substream is NULL\n"); dump_stack(); return 0; } ring_buf_addr = substream->runtime->dma_addr; ring_buf_size = snd_pcm_lib_buffer_bytes(substream); intelhaddata->stream_info.ring_buf_size = ring_buf_size; period_bytes = frames_to_bytes(substream->runtime, substream->runtime->period_size); num_periods = substream->runtime->periods; /* buffer addr should be 64 byte aligned, period bytes will be used to calculate addr offset*/ period_bytes &= ~0x3F; /* Hardware supports MAX_PERIODS buffers */ if (end >= HAD_MAX_PERIODS) return -EINVAL; for (i = start; i <= end; i++) { /* Program the buf registers with addr and len */ intelhaddata->buf_info[i].buf_addr = ring_buf_addr + (i * period_bytes); if (i < num_periods-1) intelhaddata->buf_info[i].buf_size = period_bytes; else intelhaddata->buf_info[i].buf_size = ring_buf_size - (period_bytes*i); had_write_register(AUD_BUF_A_ADDR + (i * HAD_REG_WIDTH), intelhaddata->buf_info[i].buf_addr | BIT(0) | BIT(1)); had_write_register(AUD_BUF_A_LENGTH + (i * HAD_REG_WIDTH), period_bytes); intelhaddata->buf_info[i].is_valid = true; } pr_debug("%s:buf[%d-%d] addr=%#x and size=%d\n", __func__, start, end, intelhaddata->buf_info[start].buf_addr, intelhaddata->buf_info[start].buf_size); intelhaddata->valid_buf_cnt = num_periods; return 0; } inline int snd_intelhad_read_len(struct snd_intelhad *intelhaddata) { int i, retval = 0; u32 len[4]; for (i = 0; i < 4 ; i++) { had_read_register(AUD_BUF_A_LENGTH + (i * HAD_REG_WIDTH), &len[i]); if (!len[i]) retval++; } if (retval != 1) { for (i = 0; i < 4 ; i++) pr_debug("buf[%d] size=%d\n", i, len[i]); } return retval; } /** * snd_intelhad_prog_cts - Program HDMI audio CTS value * * @aud_samp_freq: sampling frequency of audio data * @tmds: sampling frequency of the display data * @n_param: N value, depends on aud_samp_freq * @intelhaddata:substream private data * * Program CTS register based on the audio and display sampling frequency */ static void snd_intelhad_prog_cts(u32 aud_samp_freq, u32 tmds, u32 n_param, struct snd_intelhad *intelhaddata) { u32 cts_val; u64 dividend, divisor; /* Calculate CTS according to HDMI 1.3a spec*/ dividend = (u64)tmds * n_param*1000; divisor = 128 * aud_samp_freq; cts_val = div64_u64(dividend, divisor); pr_debug("TMDS value=%d, N value=%d, CTS Value=%d\n", tmds, n_param, cts_val); had_write_register(AUD_HDMI_CTS, (BIT(20) | cts_val)); } /** * snd_intelhad_prog_n - Program HDMI audio N value * * @aud_samp_freq: sampling frequency of audio data * @n_param: N value, depends on aud_samp_freq * @intelhaddata:substream private data * * This function is called in the prepare callback. * It programs based on the audio and display sampling frequency */ static int snd_intelhad_prog_n(u32 aud_samp_freq, u32 *n_param, struct snd_intelhad *intelhaddata) { u32 n_val; int retval = 0; /* Select N according to HDMI 1.3a spec*/ switch (aud_samp_freq) { case AUD_SAMPLE_RATE_32: n_val = 4096; break; case AUD_SAMPLE_RATE_44_1: n_val = 6272; break; case AUD_SAMPLE_RATE_48: n_val = 6144; break; case AUD_SAMPLE_RATE_88_2: n_val = 12544; break; case AUD_SAMPLE_RATE_96: n_val = 12288; break; case AUD_SAMPLE_RATE_176_4: n_val = 25088; break; case HAD_MAX_RATE: n_val = 24576; break; default: retval = -EINVAL; break; } if (retval) return retval; had_write_register(AUD_N_ENABLE, (BIT(20) | n_val)); *n_param = n_val; return retval; } /** * snd_intelhad_open - stream initializations are done here * @substream:substream for which the stream function is called * * This function is called whenever a PCM stream is opened */ static int snd_intelhad_open(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata; struct snd_pcm_runtime *runtime; struct had_stream_pvt *stream; struct had_pvt_data *had_stream; int retval; pr_debug("snd_intelhad_open called\n"); intelhaddata = snd_pcm_substream_chip(substream); had_stream = intelhaddata->private_data; /* * HDMI driver might suspend the device already, * so we return it on */ if (!ospm_power_using_hw_begin(OSPM_DISPLAY_ISLAND, OSPM_UHB_FORCE_POWER_ON)) { pr_err("HDMI device can't be turned on\n"); return -ENODEV; } if (had_get_hwstate(intelhaddata)) { pr_err("%s: HDMI cable plugged-out\n", __func__); ospm_power_using_hw_end(OSPM_DISPLAY_ISLAND); return -ENODEV; } runtime = substream->runtime; /* Check, if device already in use */ if (runtime->private_data) { pr_err("Device already in use\n"); ospm_power_using_hw_end(OSPM_DISPLAY_ISLAND); return -EBUSY; } ospm_power_using_hw_end(OSPM_DISPLAY_ISLAND); /* set the runtime hw parameter with local snd_pcm_hardware struct */ runtime->hw = snd_intel_hadstream; stream = kzalloc(sizeof(*stream), GFP_KERNEL); if (!stream) { retval = -ENOMEM; goto exit_err; } stream->stream_status = STREAM_INIT; runtime->private_data = stream; retval = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (retval < 0) { kfree(stream); goto exit_err; } /* Make sure, that the period size is always aligned * 64byte boundary */ retval = snd_pcm_hw_constraint_step(substream->runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64); if (retval < 0) { pr_err("%s:step_size=64 failed,err=%d\n", __func__, retval); kfree(stream); goto exit_err; } return retval; exit_err: runtime->private_data = NULL; return retval; } /** * had_period_elapsed - updates the hardware pointer status * @had_substream:substream for which the stream function is called * */ static void had_period_elapsed(void *had_substream) { struct snd_pcm_substream *substream = had_substream; struct had_stream_pvt *stream; if (!substream || !substream->runtime) return; stream = substream->runtime->private_data; if (!stream) return; if (stream->stream_status != STREAM_RUNNING) return; snd_pcm_period_elapsed(substream); return; } /** * snd_intelhad_init_stream - internal function to initialize stream info * @substream:substream for which the stream function is called * */ static int snd_intelhad_init_stream(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata = snd_pcm_substream_chip(substream); pr_debug("setting buffer ptr param\n"); intelhaddata->stream_info.period_elapsed = had_period_elapsed; intelhaddata->stream_info.had_substream = substream; intelhaddata->stream_info.buffer_ptr = 0; intelhaddata->stream_info.buffer_rendered = 0; intelhaddata->stream_info.sfreq = substream->runtime->rate; return 0; } /** * snd_intelhad_close- to free parameteres when stream is stopped * * @substream: substream for which the function is called * * This function is called by ALSA framework when stream is stopped */ static int snd_intelhad_close(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata; struct snd_pcm_runtime *runtime; pr_debug("snd_intelhad_close called\n"); intelhaddata = snd_pcm_substream_chip(substream); runtime = substream->runtime; intelhaddata->stream_info.buffer_rendered = 0; intelhaddata->stream_info.buffer_ptr = 0; intelhaddata->stream_info.str_id = 0; intelhaddata->stream_info.had_substream = NULL; /* Check if following drv_status modification is required - VA */ if (intelhaddata->drv_status != HAD_DRV_DISCONNECTED) intelhaddata->drv_status = HAD_DRV_CONNECTED; kfree(runtime->private_data); runtime->private_data = NULL; return 0; } /** * snd_intelhad_hw_params- to setup the hardware parameters * like allocating the buffers * * @substream: substream for which the function is called * @hw_params: hardware parameters * * This function is called by ALSA framework when hardware params are set */ static int snd_intelhad_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { unsigned long addr; int pages, buf_size, retval; BUG_ON(!hw_params); buf_size = params_buffer_bytes(hw_params); retval = snd_pcm_lib_malloc_pages(substream, buf_size); if (retval < 0) return retval; pr_debug("%s:allocated memory = %d\n", __func__, buf_size); /* mark the pages as uncached region */ addr = (unsigned long) substream->runtime->dma_area; pages = (substream->runtime->dma_bytes + PAGE_SIZE - 1) / PAGE_SIZE; retval = set_memory_uc(addr, pages); if (retval) { pr_err("set_memory_uc failed.Error:%d\n", retval); return retval; } memset(substream->runtime->dma_area, 0, buf_size); return retval; } /** * snd_intelhad_hw_free- to release the resources allocated during * hardware params setup * * @substream: substream for which the function is called * * This function is called by ALSA framework before close callback. * */ static int snd_intelhad_hw_free(struct snd_pcm_substream *substream) { unsigned long addr; u32 pages; pr_debug("snd_intelhad_hw_free called\n"); /* mark back the pages as cached/writeback region before the free */ addr = (unsigned long) substream->runtime->dma_area; pages = (substream->runtime->dma_bytes + PAGE_SIZE - 1) / PAGE_SIZE; set_memory_wb(addr, pages); return snd_pcm_lib_free_pages(substream); }
int had_process_buffer_done(struct snd_intelhad *intelhaddata) { int retval = 0; u32 len = 1; enum intel_had_aud_buf_type buf_id; enum intel_had_aud_buf_type buff_done; struct pcm_stream_info *stream; u32 buf_size; struct had_pvt_data *had_stream; int intr_count; enum had_status_stream stream_type; unsigned long flag_irqs; had_stream = intelhaddata->private_data; stream = &intelhaddata->stream_info; intr_count = 1; spin_lock_irqsave(&intelhaddata->had_spinlock, flag_irqs); if (intelhaddata->drv_status == HAD_DRV_DISCONNECTED) { spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); pr_err("%s:Device already disconnected\n", __func__); return retval; } buf_id = intelhaddata->curr_buf; intelhaddata->buff_done = buf_id; buff_done = intelhaddata->buff_done; buf_size = intelhaddata->buf_info[buf_id].buf_size; stream_type = had_stream->stream_type; pr_debug("Enter:%s buf_id=%d", __func__, buf_id); /* Every debug statement has an implication * of ~5msec. Thus, avoid having >3 debug statements * for each buffer_done handling. */ /* Check for any intr_miss in case of active playback */ if (had_stream->stream_type == HAD_RUNNING_STREAM) { spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); intr_count = had_chk_intrmiss(intelhaddata, buf_id); if (!intr_count || (intr_count > 3)) { pr_err("HAD SW state in non-recoverable!!! mode\n"); pr_err("Already played stale data\n"); return retval; } buf_id += (intr_count - 1); buf_id = buf_id % 4; spin_lock_irqsave(&intelhaddata->had_spinlock, flag_irqs); } intelhaddata->buf_info[buf_id].is_valid = true; if (intelhaddata->valid_buf_cnt-1 == buf_id) { if (had_stream->stream_type >= HAD_RUNNING_STREAM) intelhaddata->curr_buf = HAD_BUF_TYPE_A; } else intelhaddata->curr_buf = buf_id + 1; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flag_irqs); if (had_get_hwstate(intelhaddata)) { pr_err("HDMI cable plugged-out\n"); return retval; } /*Reprogram the registers with addr and length*/ had_write_register(AUD_BUF_A_LENGTH + (buf_id * HAD_REG_WIDTH), buf_size); had_write_register(AUD_BUF_A_ADDR+(buf_id * HAD_REG_WIDTH), intelhaddata->buf_info[buf_id].buf_addr| BIT(0) | BIT(1)); had_read_register(AUD_BUF_A_LENGTH + (buf_id * HAD_REG_WIDTH), &len); pr_debug("%s:Enabled buf[%d]\n", __func__, buf_id); /* In case of actual data, * report buffer_done to above ALSA layer */ buf_size = intelhaddata->buf_info[buf_id].buf_size; if (stream_type >= HAD_RUNNING_STREAM) { intelhaddata->stream_info.buffer_rendered += (intr_count * buf_size); stream->period_elapsed(stream->had_substream); } return retval; }