From: Takashi Iwai Subject: Re: [PATCH 5/8] ALSA: Update CA0132 codec to load DSP firmware binary Date: Fri, 14 Sep 2012 10:52:05 +0200 Message-ID: References: <1347585358-2403-1-git-send-email-ian_minett@creativelabs.com> <1347585358-2403-6-git-send-email-ian_minett@creativelabs.com> Mime-Version: 1.0 (generated by SEMI 1.14.6 - "Maruoka") Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: Received: from mx2.suse.de (cantor2.suse.de [195.135.220.15]) by alsa0.perex.cz (Postfix) with ESMTP id 52EEF265CDC for ; Fri, 14 Sep 2012 10:52:05 +0200 (CEST) In-Reply-To: <1347585358-2403-6-git-send-email-ian_minett@creativelabs.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: alsa-devel-bounces@alsa-project.org Sender: alsa-devel-bounces@alsa-project.org To: Ian Minett Cc: alsa-devel@alsa-project.org List-Id: alsa-devel@alsa-project.org At Thu, 13 Sep 2012 18:15:55 -0700, Ian Minett wrote: > > From: Ian Minett > Give a bit more description what this patch really does and also what it doesn't. This just implements the firmware loading, but the new DSP functionality itself isn't used yet, right? > Signed-off-by: Ian Minett > > diff --git a/sound/pci/hda/patch_ca0132.c b/sound/pci/hda/patch_ca0132.c > index 8ea3348..11f5910 100644 > --- a/sound/pci/hda/patch_ca0132.c > +++ b/sound/pci/hda/patch_ca0132.c > @@ -48,9 +48,6 @@ > #define WIDGET_CHIP_CTRL 0x15 > #define WIDGET_DSP_CTRL 0x16 > > -#define WUH_MEM_CONNID 10 > -#define DSP_MEM_CONNID 16 > - > #define MEM_CONNID_MICIN1 3 > #define MEM_CONNID_MICIN2 5 > #define MEM_CONNID_MICOUT1 12 > @@ -352,6 +349,25 @@ static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx, > #define add_in_mono_volume(codec, nid, pfx, chan) \ > _add_volume(codec, nid, pfx, chan, 1) > > +enum dsp_download_state { > + DSP_DOWNLOAD_FAILED = -1, > + DSP_DOWNLOAD_INIT = 0, > + DSP_DOWNLOADING = 1, > + DSP_DOWNLOADED = 2 > +}; > + > +struct hda_stream_format { > + unsigned int sample_rate; > + unsigned short valid_bits_per_sample; > + unsigned short container_size; > + unsigned short number_channels; > +}; > + > +/* retrieve parameters from hda format */ > +#define get_hdafmt_chs(fmt) (fmt & 0xf) > +#define get_hdafmt_bits(fmt) ((fmt >> 4) & 0x7) > +#define get_hdafmt_rate(fmt) ((fmt >> 8) & 0x7f) > +#define get_hdafmt_type(fmt) ((fmt >> 15) & 0x1) This can be well in hda_codec.h. But it's fine to define here for now... > /* > * CA0132 specific > @@ -371,11 +387,55 @@ struct ca0132_spec { > long curr_hp_switch; > long curr_hp_volume[2]; > long curr_speaker_switch; > - struct mutex chipio_mutex; > const char *input_labels[AUTO_PIN_LAST]; > struct hda_pcm pcm_rec[2]; /* PCM information */ > + > + /* chip access */ > + struct mutex chipio_mutex; /* chip access mutex */ > + u32 curr_chip_addx; > + > + /* DSP download related */ > + enum dsp_download_state dsp_state; > + unsigned int dsp_stream_id; > + unsigned int wait_scp; > + unsigned int wait_scp_header; > + unsigned int wait_num_data; > + unsigned int scp_resp_header; > + unsigned int scp_resp_data[4]; > + unsigned int scp_resp_count; > }; > > +/* > + * CA0132 codec access > + */ > +unsigned int codec_send_command(struct hda_codec *codec, hda_nid_t nid, > + unsigned int verb, unsigned int parm, unsigned int *res) > +{ > + unsigned int response; > + response = snd_hda_codec_read(codec, nid, 0, verb, parm); > + *res = response; > + > + return ((response == -1) ? -1 : 0); > +} > + > +static int codec_set_converter_format(struct hda_codec *codec, hda_nid_t nid, > + unsigned short converter_format, unsigned int *res) > +{ > + return codec_send_command(codec, nid, VENDOR_CHIPIO_STREAM_FORMAT, > + converter_format & 0xffff, res); > +} > + > +static int codec_set_converter_stream_channel(struct hda_codec *codec, > + hda_nid_t nid, unsigned char stream, > + unsigned char channel, unsigned int *res) > +{ > + unsigned char converter_stream_channel = 0; > + > + converter_stream_channel = (stream << 4) | (channel & 0x0f); > + return codec_send_command(codec, nid, AC_VERB_SET_CHANNEL_STREAMID, > + converter_stream_channel, res); > +} > + > /* Chip access helper function */ > static int chipio_send(struct hda_codec *codec, > unsigned int reg, > @@ -415,6 +475,30 @@ static int chipio_write_address(struct hda_codec *codec, > return res; > } > > +static int chipio_write_addx(struct hda_codec *codec, u32 chip_addx) > +{ > + struct ca0132_spec *spec = codec->spec; > + int status; > + > + if (spec->curr_chip_addx == chip_addx) > + return 0; > + > + /* send low 16 bits of the address */ > + status = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW, > + chip_addx & 0xffff); > + > + if (status < 0) > + return status; > + > + /* send high 16 bits of the address */ > + status = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH, > + chip_addx >> 16); > + > + spec->curr_chip_addx = (status < 0) ? ~0UL : chip_addx; > + > + return status; > +} > + > /* > * Write data through the vendor widget -- NOT protected by the Mutex! > */ > @@ -435,6 +519,24 @@ static int chipio_write_data(struct hda_codec *codec, unsigned int data) > return res; > } > > +static int chipio_write_data_multiple(struct hda_codec *codec, > + const u32 *data, > + unsigned int count) > +{ > + int status = 0; > + > + if (data == NULL) { > + snd_printdd(KERN_ERR "chipio_write_data null ptr"); > + return -EINVAL; > + } > + > + while ((count-- != 0) && (status == 0)) > + status = chipio_write_data(codec, *data++); > + > + return status; > +} > + > + > /* > * Read data through the vendor widget -- NOT protected by the Mutex! > */ > @@ -486,6 +588,26 @@ exit: > return err; > } > > +static int chipio_write_multiple(struct hda_codec *codec, > + u32 chip_addx, > + const u32 *data, > + unsigned int count) > +{ > + struct ca0132_spec *spec = codec->spec; > + int status; > + > + mutex_lock(&spec->chipio_mutex); > + status = chipio_write_addx(codec, chip_addx); > + if (status < 0) > + goto error; > + > + status = chipio_write_data_multiple(codec, data, count); > +error: > + mutex_unlock(&spec->chipio_mutex); > + > + return status; > +} > + > /* > * Read the given address through the chip I/O widget > * protected by the Mutex > @@ -512,6 +634,1425 @@ exit: > return err; > } > > +static void chipio_set_control_flag(struct hda_codec *codec, > + enum control_flag_id flag_id, > + bool flag_state) > +{ > + unsigned int val; > + unsigned int flag_bit; > + > + flag_bit = (flag_state ? 1 : 0); > + val = (flag_bit << 7) | (flag_id); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_FLAG_SET, val); > +} > + > +static void chipio_set_control_param(struct hda_codec *codec, > + enum control_param_id param_id, int param_val) > +{ > + struct ca0132_spec *spec = codec->spec; > + int val; > + > + if ((param_id < 32) && (param_val < 8)) { > + val = (param_val << 5) | (param_id); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PARAM_SET, val); > + } else { > + mutex_lock(&spec->chipio_mutex); > + if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) { > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PARAM_EX_ID_SET, > + param_id); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PARAM_EX_VALUE_SET, > + param_val); > + } > + mutex_unlock(&spec->chipio_mutex); > + } > +} > + > +static void chipio_set_conn_rate(struct hda_codec *codec, > + int connid, enum ca0132_sample_rate rate) > +{ > + chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_ID, connid); > + chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE, > + rate); > +} > + > +static void chipio_enable_clocks(struct hda_codec *codec) > +{ > + struct ca0132_spec *spec = codec->spec; > + > + mutex_lock(&spec->chipio_mutex); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_8051_ADDRESS_LOW, 0); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_8051_ADDRESS_LOW, 5); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PLL_PMU_WRITE, 0x0b); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_8051_ADDRESS_LOW, 6); > + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, > + VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff); > + mutex_unlock(&spec->chipio_mutex); > +} > + > +/* > + * CA0132 DSP IO stuffs > + */ > +static int dspio_send(struct hda_codec *codec, unsigned int reg, > + unsigned int data) > +{ > + unsigned int res; > + int retry = 50; > + > + /* send bits of data specified by reg to dsp */ > + do { > + res = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, reg, data); > + if ((res >= 0) && (res != VENDOR_STATUS_DSPIO_BUSY)) > + return res; > + } while (--retry); > + > + return -EIO; > +} > + > +static void dspio_write_wait(struct hda_codec *codec) > +{ > + int cur_val, prv_val; > + int retry = 50; > + > + cur_val = 0; > + do { > + prv_val = cur_val; > + msleep(20); > + dspio_send(codec, VENDOR_DSPIO_SCP_POST_COUNT_QUERY, 1); > + dspio_send(codec, VENDOR_DSPIO_STATUS, 0); > + cur_val = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, > + VENDOR_DSPIO_SCP_READ_COUNT, 0); > + } while (cur_val && (cur_val == prv_val) && --retry); > +} > + > +static int dspio_write(struct hda_codec *codec, unsigned int scp_data) > +{ > + struct ca0132_spec *spec = codec->spec; > + int status; > + > + dspio_write_wait(codec); > + > + mutex_lock(&spec->chipio_mutex); > + status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_LOW, > + scp_data & 0xffff); > + if (status < 0) > + goto error; > + > + status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_HIGH, > + scp_data >> 16); > + if (status < 0) > + goto error; > + > + /* OK, now check if the write itself has executed*/ > + status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, > + VENDOR_DSPIO_STATUS, 0); > +error: > + mutex_unlock(&spec->chipio_mutex); > + > + return (status == VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL) ? > + -EIO : 0; > +} > + > +static int dspio_write_multiple(struct hda_codec *codec, > + unsigned int *buffer, unsigned int size) > +{ > + int status = 0; > + unsigned int count; > + > + if ((buffer == NULL)) > + return -EINVAL; > + > + count = 0; > + while (count < size) { > + status = dspio_write(codec, *buffer++); > + if (status != 0) > + break; > + count++; > + } > + > + return status; > +} > + > +static inline unsigned int > +make_scp_header(unsigned int target_id, unsigned int source_id, > + unsigned int get_flag, unsigned int req, > + unsigned int device_flag, unsigned int resp_flag, > + unsigned int error_flag, unsigned int data_size) > +{ > + unsigned int header = 0; > + > + header = (data_size & 0x1f) << 27; > + header |= (error_flag & 0x01) << 26; > + header |= (resp_flag & 0x01) << 25; > + header |= (device_flag & 0x01) << 24; > + header |= (req & 0x7f) << 17; > + header |= (get_flag & 0x01) << 16; > + header |= (source_id & 0xff) << 8; > + header |= target_id & 0xff; > + > + return header; > +} > + > +static inline void > +extract_scp_header(unsigned int header, > + unsigned int *target_id, unsigned int *source_id, > + unsigned int *get_flag, unsigned int *req, > + unsigned int *device_flag, unsigned int *resp_flag, > + unsigned int *error_flag, unsigned int *data_size) > +{ > + if (data_size) > + *data_size = (header >> 27) & 0x1f; > + if (error_flag) > + *error_flag = (header >> 26) & 0x01; > + if (resp_flag) > + *resp_flag = (header >> 25) & 0x01; > + if (device_flag) > + *device_flag = (header >> 24) & 0x01; > + if (req) > + *req = (header >> 17) & 0x7f; > + if (get_flag) > + *get_flag = (header >> 16) & 0x01; > + if (source_id) > + *source_id = (header >> 8) & 0xff; > + if (target_id) > + *target_id = header & 0xff; > +} > + > +#define SCP_MAX_DATA_WORDS (16) > + > +/* Structure to contain any SCP message */ > +struct scp_msg { > + unsigned int hdr; > + unsigned int data[SCP_MAX_DATA_WORDS]; > +}; > + > +static int dspio_send_scp_message(struct hda_codec *codec, > + unsigned char *send_buf, > + unsigned int send_buf_size, > + unsigned char *return_buf, > + unsigned int return_buf_size, > + unsigned int *bytes_returned) > +{ > + struct ca0132_spec *spec = codec->spec; > + int retry; > + int status = -1; > + unsigned int scp_send_size = 0; > + unsigned int total_size; > + bool waiting_for_resp = false; > + unsigned int header; > + struct scp_msg *ret_msg; > + unsigned int resp_src_id, resp_target_id; > + unsigned int data_size, src_id, target_id, get_flag, device_flag; > + > + if (bytes_returned) > + *bytes_returned = 0; > + > + /* get scp header from buffer */ > + header = *((unsigned int *)send_buf); This is not quite portable. The HD-audio itself might be implemented in big-endian machines, too. Or, this might be more about struct scp_msg definition. What is the expectation from the hardware? Does the codec expect 32bit little endian values? Then you'd need to convert data explicitly when the architecture is big-endian. (snip) > static int ca0132_init(struct hda_codec *codec) > { > struct ca0132_spec *spec = codec->spec; > struct auto_pin_cfg *cfg = &spec->autocfg; > int i; > > + ca0132_download_dsp(codec); > + As I mentioned earlier, you cannot implement the DSP loading code unconditionally. User might not have a DSP firmware but only updated the kernel. Then it gets broken. The DSP loading code (and the relevant stuff) must be protected via ifdef CONFIG_SND_HDA_DSP_LOADER. And yet, it wouldn't be bad to have a module option to control the firmware loading as wel. Takashi