magician fix and UDA1380 i2c device registration change
Subsystems (5)
cover magician fix and UDA1380 i2c device registration change
Hi Mark,
Patch 1/3 is a follow-up fix to commit a820532002e70e3a06f1ea7133e9b02443d07382 "ASoC: pxa-ssp.c fix clock/frame invert".
Patch 2/3 removes the I2C board info registration from the UDA1380 driver. Instead, device instantiation will be done via global i2c_board_info from board files (patch 3/3). At the same time, platform specific configuration is moved to platform data. Common power/reset GPIO handling moves into the codec driver, which will allow to completely power down the codec depending on ASoC power state in the future.
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/3 ASoC: magician: fix PXA SSP clock polarity
Follow-up fix needed since "ASoC: pxa-ssp.c fix clock/frame invert".
--- sound/soc/pxa/magician.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
sound/soc/pxa/magician.c +1 -1
@@ -183,7 +183,7 @@ static int magician_playback_hw_params(struct snd_pcm_substream *substream,/* set cpu DAI configuration */ ret =snd_soc_dai_set_fmt (cpu_dai,SND_SOC_DAIFMT_DSP_A | -SND_SOC_DAIFMT_IB_IF |SND_SOC_DAIFMT_CBS_CFS ); +SND_SOC_DAIFMT_NB_IF |SND_SOC_DAIFMT_CBS_CFS );if (ret <0 )return ret;
Signature · 1 line
1.6.3.1
RFC PATCH 2/3 ASoC: UDA1380: register from board files, configure via pdata
This patch removes the I2C board info registration from the codec driver. Instead, device instantiation will be done via global i2c_board_info from board files. At the same time, platform specific configuration is moved to platform data and common power/reset GPIO handling moves into the codec driver.
--- include/sound/uda1380.h | 22 ++++++++++ sound/soc/codecs/uda1380.c | 95 +++++++++++++++++++++---------------------- sound/soc/codecs/uda1380.h | 13 ------ sound/soc/pxa/magician.c | 26 ------------ 4 files changed, 68 insertions(+), 88 deletions(-) create mode 100644 include/sound/uda1380.h
include/sound/uda1380.h new file +22 -0
@@ -0,0 +1,22 @@ +/* +* UDA1380 ALSA SoC Codec driver +* +* Copyright 2009 Philipp Zabel +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +*/ + +#ifndef _UDA1380_H +#define _UDA1380_H + +struct uda1380_platform_data { +int gpio_power; +int gpio_reset; +int dac_clk; +#define UDA1380_DAC_CLK_SYSCLK 0 +#define UDA1380_DAC_CLK_WSPLL 1 +}; + +#endif /* _UDA1380_H */
sound/soc/codecs/uda1380.c +46 -49
159 lines not on this page · raw message
sound/soc/codecs/uda1380.h +0 -13
@@ -8,9 +8,6 @@* Copyright (c) 2005 Giorgio Padrin <[email protected]> */ -#ifndef _UDA1380_H -#define _UDA1380_H -#define UDA1380_CLK 0x00#define UDA1380_IFACE 0x01#define UDA1380_PM 0x02
@@ -72,19 +69,9 @@#define R22_SKIP_DCFIL 0x0002#define R23_AGC_EN 0x0001 -struct uda1380_setup_data { -int i2c_bus; -unsigned short i2c_address; -int dac_clk; -#define UDA1380_DAC_CLK_SYSCLK 0 -#define UDA1380_DAC_CLK_WSPLL 1 -}; -#define UDA1380_DAI_DUPLEX 0/* playback and capture on single DAI */ #define UDA1380_DAI_PLAYBACK 1/* playback DAI */ #define UDA1380_DAI_CAPTURE 2/* capture DAI */ extern struct snd_soc_dai uda1380_dai[3 ];extern struct snd_soc_codec_device soc_codec_dev_uda1380; - -#endif /* _UDA1380_H */
sound/soc/pxa/magician.c +0 -26
@@ -448,17 +448,10 @@ static struct snd_soc_card snd_soc_card_magician = { .platform = &pxa2xx_soc_platform, }; -/* magician audio private data */ -static struct uda1380_setup_data magician_uda1380_setup = { - .i2c_address =0x18 , - .dac_clk =UDA1380_DAC_CLK_WSPLL , -}; -/* magician audio subsystem */ static struct snd_soc_device magician_snd_devdata = { .card = &snd_soc_card_magician, .codec_dev = &soc_codec_dev_uda1380, - .codec_data = &magician_uda1380_setup, };static struct platform_device *magician_snd_device;
@@ -470,12 +463,6 @@ static int __init magician_init(void)if (!machine_is_magician ())return -ENODEV ; - ret =gpio_request (EGPIO_MAGICIAN_CODEC_POWER ,"CODEC_POWER" ); -if (ret) - goto err_request_power; - ret =gpio_request (EGPIO_MAGICIAN_CODEC_RESET ,"CODEC_RESET" ); -if (ret) - goto err_request_reset; ret =gpio_request (EGPIO_MAGICIAN_SPK_POWER ,"SPK_POWER" );if (ret) goto err_request_spk;
@@ -492,14 +479,8 @@ static int __init magician_init(void)if (ret) goto err_request_in_sel1; -gpio_set_value (EGPIO_MAGICIAN_CODEC_POWER ,1 );gpio_set_value (EGPIO_MAGICIAN_IN_SEL0 ,0 ); -/* we may need to have the clock running here - pH5 */ -gpio_set_value (EGPIO_MAGICIAN_CODEC_RESET ,1 ); -udelay (5 ); -gpio_set_value (EGPIO_MAGICIAN_CODEC_RESET ,0 ); - magician_snd_device =platform_device_alloc ("soc-audio" ,-1 );if (!magician_snd_device) { ret = -ENOMEM ;
@@ -527,10 +508,6 @@ err_request_mic: err_request_ep:gpio_free (EGPIO_MAGICIAN_SPK_POWER ); err_request_spk: -gpio_free (EGPIO_MAGICIAN_CODEC_RESET ); -err_request_reset: -gpio_free (EGPIO_MAGICIAN_CODEC_POWER ); -err_request_power:return ret; }
@@ -541,15 +518,12 @@ static void __exit magician_exit(void)gpio_set_value (EGPIO_MAGICIAN_SPK_POWER ,0 );gpio_set_value (EGPIO_MAGICIAN_EP_POWER ,0 );gpio_set_value (EGPIO_MAGICIAN_MIC_POWER ,0 ); -gpio_set_value (EGPIO_MAGICIAN_CODEC_POWER ,0 );gpio_free (EGPIO_MAGICIAN_IN_SEL1 );gpio_free (EGPIO_MAGICIAN_IN_SEL0 );gpio_free (EGPIO_MAGICIAN_MIC_POWER );gpio_free (EGPIO_MAGICIAN_EP_POWER );gpio_free (EGPIO_MAGICIAN_SPK_POWER ); -gpio_free (EGPIO_MAGICIAN_CODEC_RESET ); -gpio_free (EGPIO_MAGICIAN_CODEC_POWER ); }module_init (magician_init);
Signature · 1 line
1.6.3.1
RFC PATCH 3/3 pxa/magician: add I2C board info and platform data for UDA1380
Configures I2C address, power/reset GPIOs and DAC clock from WSPLL.
--- arch/arm/mach-pxa/magician.c | 18 +++++++++++++++++- 1 files changed, 17 insertions(+), 1 deletions(-)
arch/arm/mach-pxa/magician.c +17 -1
@@ -43,6 +43,8 @@#include <mach/irda.h> #include <mach/ohci.h> +#include <sound/uda1380.h> +#include "devices.h" #include "generic.h"
@@ -862,9 +864,22 @@ static struct platform_device calypso = { };/* -* I2C +* Philips UDA1380 on I2C */ +static struct uda1380_platform_data uda1380_info = { + .gpio_power =EGPIO_MAGICIAN_CODEC_POWER , + .gpio_reset =EGPIO_MAGICIAN_CODEC_RESET , + .dac_clk =UDA1380_DAC_CLK_WSPLL , +}; + +static struct i2c_board_info i2c_board_info[] = { + { +I2C_BOARD_INFO ("uda1380" ,0x18 ), + .platform_data = &uda1380_info, + }, +}; +static struct i2c_pxa_platform_data i2c_info = { .fast_mode =1 , };
@@ -906,6 +921,7 @@ static void __init magician_init(void) }pxa27x_set_i2c_power_info (NULL );pxa_set_i2c_info (&i2c_info); +i2c_register_board_info (0 ,ARRAY_AND_SIZE (i2c_board_info));i2c_register_board_info (1 ,ARRAY_AND_SIZE (pi2c_board_info));pxa_set_mci_info (&magician_mci_info);pxa_set_ohci_info (&magician_ohci_info);
Signature · 1 line
1.6.3.1
Re: [PATCH, RFC 3/3] pxa/magician: add I2C board info and platform data for UDA1380
Quoted 3 lines · Philipp Zabel
Configures I2C address, power/reset GPIOs and DAC clock from WSPLL.
Signed-off-by Philipp Zabel <[email protected]>
Eric, I don't know how you want to deal with the cross tree issues for this patch? It's part of a conversion of the UDA1380 driver to the standard device model so it'll depend on ASoC changes to the UDA1380 driver but obviously there's arch/arm/mach-pxa changes too.
One way of making sure there aren't any problem would be for one of us to apply both patches to a branch which can then be pulled in to both the ASoC and PXA trees. Does that sound sane?
Quoted 57 lines
--- arch/arm/mach-pxa/magician.c | 18 +++++++++++++++++- 1 files changed, 17 insertions(+), 1 deletions(-)arch/arm/mach-pxa/magician.c +17
-1@@ -43,6 +43,8 @@#include <mach/irda.h> #include <mach/ohci.h> +#include <sound/uda1380.h> +#include "devices.h" #include "generic.h" @@ -862,9 +864,22 @@ static struct platform_device calypso = { };/* -* I2C +* Philips UDA1380 on I2C */ +static struct uda1380_platform_data uda1380_info = { + .gpio_power =EGPIO_MAGICIAN_CODEC_POWER , + .gpio_reset =EGPIO_MAGICIAN_CODEC_RESET , + .dac_clk =UDA1380_DAC_CLK_WSPLL , +}; + +static struct i2c_board_info i2c_board_info[] = { + { +I2C_BOARD_INFO ("uda1380" ,0x18 ), + .platform_data = &uda1380_info, + }, +}; +static struct i2c_pxa_platform_data i2c_info = { .fast_mode =1 , };@@ -906,6 +921,7 @@ static void __init magician_init(void) }pxa27x_set_i2c_power_info (NULL );pxa_set_i2c_info (&i2c_info); +i2c_register_board_info (0 ,ARRAY_AND_SIZE (i2c_board_info));i2c_register_board_info (1 ,ARRAY_AND_SIZE (pi2c_board_info));pxa_set_mci_info (&magician_mci_info);pxa_set_ohci_info (&magician_ohci_info);Signature · 6 lines
1.6.3.1 _______________________________________________ Alsa-devel mailing list [email protected] http://mailman.alsa-project.org/mailman/listinfo/alsa-devel
Re: [PATCH, RFC 3/3] pxa/magician: add I2C board info and platform data for UDA1380
Quoted 5 lines · Mark Brown
Quoted 3 lines · Philipp Zabel
Configures I2C address, power/reset GPIOs and DAC clock from WSPLL.
Signed-off-by Philipp Zabel <[email protected]>
Quoted 8 lines
Eric, I don't know how you want to deal with the cross tree issues for this patch? It's part of a conversion of the UDA1380 driver to the standard device model so it'll depend on ASoC changes to the UDA1380 driver but obviously there's
arch/arm/mach-pxachanges too.One way of making sure there aren't any problem would be for one of us to apply both patches to a branch which can then be pulled in to both the ASoC and PXA trees. Does that sound sane?
Normally, I'll queue such patch in my pending branch and will be pushed out until the other patch(es) with dependency has been merged upstream.
_______________________________________________
Alsa-devel mailing list
[email protected]
http://mailman.alsa-project.org/mailman/listinfo/alsa-devel
Re: [PATCH, RFC 3/3] pxa/magician: add I2C board info and platform data for UDA1380
Quoted 2 lines · Eric Miao
Normally, I'll queue such patch in my pending branch and will be pushed out until the other patch(es) with dependency has been merged upstream.
That's fine for me.
Philipp, if you want to avoid bisection issues I'd suggest making the first patch shuffle the registration code into the ASoC machine driver then have your PXA patch shuffle that into arch/arm. I did something similar for wm8731 when converting that.
Re: [PATCH, RFC 2/3] ASoC: UDA1380: register from board files, configure via pdata
In reply to Philipp ZabelQuoted 5 lines · Philipp Zabel
This patch removes the I2C board info registration from the codec driver. Instead, device instantiation will be done via global
i2c_board_infofrom board files. At the same time, platform specific configuration is moved to platform data and common power/reset GPIO handling moves into the codec driver.
Thanks for doing this. This should probably either be squashed in with the arch patch that follows.
include/sound/uda1380.h line 19
Quoted 6 lines
include/sound/uda1380.h new file +6
-0+struct uda1380_platform_data { +int gpio_power; +int gpio_reset; +int dac_clk; +#define UDA1380_DAC_CLK_SYSCLK 0 +#define UDA1380_DAC_CLK_WSPLL 1
Is it worth changing this to make both options non-zero so that there's no possibility that it could be left zero by default?
Quoted 2 lines
+static int
uda1380_add_i2c_device(struct platform_device *pdev)
{
...
Quoted 1 line
ret =
i2c_add_driver(&uda1380_i2c_driver);
If you're doing this conversion the ideal thing is to convert the driver completely so that the driver is registered when the module loads and does the DAI registration once the I2C device probes. The I2C device probe should also do any other initialisation that can be done without the rest of the ASoC subsystem such as registering the GPIOs.
This implies a bit more rearrangment of the registration functions - most of the initialisation can stay in the I2C function but anything that uses the entire ASoC device and the final instantiation of the card should be moved into the ASoC probe function which will be called once the entire card has started. WM8731 is a good template to look at here.
sound/soc/codecs/uda1380.h line 13
Quoted 9 lines
sound/soc/codecs/uda1380.h +0
-3@@ -8,9 +8,6 @@* Copyright (c) 2005 Giorgio Padrin <[email protected]> */ -#ifndef _UDA1380_H -#define _UDA1380_H -
Best practice would be to keep these with a different name.
Re: [PATCH, RFC 2/3] ASoC: UDA1380: register from board files, configure via pdata
Quoted 9 lines · Mark Brown
Quoted 5 lines · Philipp Zabel
This patch removes the I2C board info registration from the codec driver. Instead, device instantiation will be done via global
i2c_board_infofrom board files. At the same time, platform specific configuration is moved to platform data and common power/reset GPIO handling moves into the codec driver.Thanks for doing this. This should probably either be squashed in with the arch patch that follows.
Ok. If Eric agrees, I'll squash as you propose.
Quoted 9 lines
include/sound/uda1380.h line 19
Quoted 6 lines
include/sound/uda1380.h new file +6
-0+struct uda1380_platform_data { + int gpio_power; + int gpio_reset; + int dac_clk; +#define UDA1380_DAC_CLK_SYSCLK 0 +#define UDA1380_DAC_CLK_WSPLL 1Is it worth changing this to make both options non-zero so that there's no possibility that it could be left zero by default?
I think this is fine as-is: SYSCLK is the default setting for DAC clock input when the chip comes out of reset.
Quoted 5 lines
Quoted 2 lines
+static int
uda1380_add_i2c_device(struct platform_device *pdev){...
Quoted 7 lines
Quoted 1 line
ret =
i2c_add_driver(&uda1380_i2c_driver);If you're doing this conversion the ideal thing is to convert the driver completely so that the driver is registered when the module loads and does the DAI registration once the I2C device probes. The I2C device probe should also do any other initialisation that can be done without the rest of the ASoC subsystem such as registering the GPIOs.
Ok.
Quoted 5 lines
This implies a bit more rearrangment of the registration functions - most of the initialisation can stay in the I2C function but anything that uses the entire ASoC device and the final instantiation of the card should be moved into the ASoC probe function which will be called once the entire card has started. WM8731 is a good template to look at here.
I'll look at WM8731 for guidance, thanks.
Quoted 11 lines
sound/soc/codecs/uda1380.h line 13
Quoted 9 lines
sound/soc/codecs/uda1380.h +0
-3@@ -8,9 +8,6 @@* Copyright (c) 2005 Giorgio Padrin <[email protected]> */ -#ifndef _UDA1380_H -#define _UDA1380_H -Best practice would be to keep these with a different name.
uda1380.h is only a one-time private header file, but I won't say no to best practice.
cheers
Philipp
Can't use bluetooth headset after upgrade of alsa/bluez with fedora 11
ALSA lib pcm_bluetooth.c:1607:(audioservice_expect) BT_OPEN failed :
Invalid argument(22)
** WARNING **: alsa_setup(): Unable to install hw params
I get this all the time now. What does this error mean?
arecord -D bluetoothh550 -f S16_LE | aplay -D bluetoothh550 -f S16_LE Recording WAVE 'stdin' : Signed 16 bit Little Endian, Rate 8000 Hz, Mono ALSA lib pcm_bluetooth.c:1607:(audioservice_expect) BT_OPEN failed :
Invalid argument(22)
arecord: set_params:1041: Unable to install hw params: ACCESS: RW_INTERLEAVED FORMAT: S16_LE SUBFORMAT: STD SAMPLE_BITS: 16 FRAME_BITS: 16 CHANNELS: 1 RATE: 8000 PERIOD_TIME: 125000 PERIOD_SIZE: 1000 PERIOD_BYTES: 2000 PERIODS: 4 BUFFER_TIME: 500000 BUFFER_SIZE: 4000 BUFFER_BYTES: 8000 TICK_TIME: [0 0] aplay: playback:2297: read error
and here with mplayer
Playing skypering.wav.
Audio only file format detected.
==========================================================================
Opening audio decoder: [pcm] Uncompressed PCM audio decoder
AUDIO: 16000 Hz, 2 ch, s16le, 512.0 kbit/100.00% (ratio: 64000->64000) Selected audio codec: [pcm] afm: pcm (Uncompressed PCM)
==========================================================================
[AO_ALSA] alsa-lib: pcm_bluetooth.c:1607:(audioservice_expect) BT_OPEN failed : Invalid argument(22)
[AO_ALSA] Unable to set hw-parameters: Invalid argument Failed to initialize audio driver 'alsa:device=bluetoothh550' Could not open/initialize audio device -> no sound.
Audio: no sound
Video: no video
busy device issue when it is not busy!
Mates...
I am running a simple app that I found called pcm.c and I can't get through with that. It creates and send simple sine wave to the speakers!
When I run the app I get the following error:
guilherme@lap:/home/guilherme/Experimentos# ./PCM Playback device is plughw:0,0 Stream parameters are 44100Hz, S16_LE, 1 channels sine wave rate is 0 0.0000Hz Using transfer method: write Playback open error: Device or resource busy
Every application I start playbacks the sound without a problem. Is there any special conf I should do to free the Device?
Here is the code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <errno.h>
#include <getopt.h>
#include <alsa/asoundlib.h>
#include <sys/time.h>
#include <math.h>
static char *device = "plughw:0,0"; //playback device
aplay -l
static snd_pcm_format_t format = SND_PCM_FORMAT_S16; //sample format
unsigned 16 bit endian
static unsigned int rate = 44100; //stream rate
static unsigned int channels = 1; //contagem dos
canais
static unsigned int buffer_time = 500000; //ring buffer
length on us
static unsigned int period_time = 100000; //period time in us
static double freq = 400; // frequencia da
senóide em Hz
static int verbose = 0; //verbose flag
static int resample = 1; //abilitar
alsa-lib resampling
static int period_event = 0; // produz um
event pool a cada periodo
static snd_pcm_sframes_t buffer_size; //quantidade de
buffers frames
static snd_pcm_sframes_t period_size; //quantidade de
periods frames
static snd_output_t *output = NULL; //ALSA usa esse
ponteiro para lidar com output objects
static void generate_sine(const snd_pcm_channel_area_t *areas,
snd_pcm_uframes_t offset, int count, double *_phase)
{
static double max_phase = 2. * M_PI;
double phase = *_phase;
double step = max_phase*freq / (double)rate;
double res;
unsigned char *samples[channels], *tmp;
int steps[channels];
unsigned int chn, byte;
union {
int i;
unsigned char c[4];
} ires;
unsigned int maxval = (1 << (snd_pcm_format_width(format) - 1)) - 1;
int bps = snd_pcm_format_width(format) / 8; //bits per sample
/*verificar e preparar o conteúdo das areas*/
for (chn = 0; chn < channels; chn++) {
if ((areas[chn].first % 8) != 0) {
printf("areas[%i].first == %i, abortando...\n", chn,
areas[chn].first);
exit(EXIT_FAILURE);
}
//pega endereço e offset da area
samples[chn] = /*(signed short *)*/(((unsigned char
*)areas[chn].addr) + (areas[chn].first / 8));
if ((areas[chn].step % 16) != 0) {
printf("areas[%i].step == %i, aborting...\n", chn,
areas[chn].step);
exit(EXIT_FAILURE);
}
steps[chn] = areas[chn].step / 8;
samples[chn] += offset * steps[chn];
}
//completa os channels da area
while(count-- > 0) {
res = sin(phase) * maxval;
ires.i = res;
tmp = ires.c;
for (chn = 0; chn < channels; chn++) {
for (byte = 0; byte < (unsigned int)bps; byte++)
*(samples[chn] + byte) = tmp[byte];
samples[chn] += steps[chn];
}
phase += step;
if (phase >= max_phase)
phase -= max_phase;
}
*_phase = phase;}
static int set_hwparams(snd_pcm_t *handle,
snd_pcm_hw_params_t *params, snd_pcm_access_t access)
{
unsigned int rrate;
snd_pcm_uframes_t size;
int err, dir;
/*escolha todos os parametros*/
err = snd_pcm_hw_params_any(handle, params);
if (err < 0) {
printf("Broken configuration for playback: no
configuration available: %s\n", snd_strerror(err));
return err;
}
/*set hardware resampling*/
err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
if (err < 0) {
printf("Resampling setup failed for playback: %s\n",
snd_strerror(err));
return err;
}
/* set the interleaved read/write format */
err = snd_pcm_hw_params_set_access(handle, params, access);
if (err < 0) {
printf("Access type not available for playback: %s\n",
snd_strerror(err));
return err;
}
/* set the sample format SND_PCM_FORMAT_S16 */
err = snd_pcm_hw_params_set_format(handle, params, format);
if (err < 0) {
printf("Sample format not available for playback: %s\n",
snd_strerror(err));
return err;
}
/* set the count of channels 1 */
err = snd_pcm_hw_params_set_channels(handle, params, channels);
if (err < 0) {
printf("Channels count (%i) not available for playbacks:
%s\n", channels, snd_strerror(err));
return err;
}
/* set the stream rate */
rrate = rate;
err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
if (err < 0) {
printf("Rate %iHz not available for playback: %s\n", rate,
snd_strerror(err));
return err;
}
if (rrate != rate) {
printf("Rate doesn't match (requested %iHz, get %iHz)\n",
rate, err);
return -EINVAL;
}
/* set the buffer time */
err = snd_pcm_hw_params_set_buffer_time_near(handle, params,
&buffer_time, &dir);
if (err < 0) {
printf("Unable to set buffer time %i for playback: %s\n",
buffer_time, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_get_buffer_size(params, &size);
if (err < 0) {
printf("Unable to get buffer size for playback: %s\n",
snd_strerror(err));
return err;
}
buffer_size = size;
/* set the period time */
err = snd_pcm_hw_params_set_period_time_near(handle, params,
&period_time, &dir);
if (err < 0) {
printf("Unable to set period time %i for playback: %s\n",
period_time, snd_strerror(err));
return err;
}
err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
if (err < 0) {
printf("Unable to get period size for playback: %s\n",
snd_strerror(err));
return err;
}
period_size = size;
/* write the parameters to device */
err = snd_pcm_hw_params(handle, params);
if (err < 0) {
printf("Unable to set hw params for playback: %s\n",
snd_strerror(err));
return err;
}
return 0;
}static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams) {
int err;
/*pegar os parametros atuais swparams*/
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for
playback: %s\n", snd_strerror(err));
return err;
}
/*Começa a transferência quando o buffer está quase cheio*/
/*(buffer_size / avail_min) * avail_min */
err = snd_pcm_sw_params_set_avail_min(handle, swparams,
(buffer_size / period_size) * period_size);
if (err < 0) {
printf("Unable to set start threshold mode for playback:
%s\n", snd_strerror(err));
return err;
}
/* allow the transfer when at least period_size samples can
be processed */
/* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
err = snd_pcm_sw_params_set_avail_min(handle, swparams,period_event ? buffer_size : period_size);
if (err < 0) {
printf("Unable to set avail min for playback: %s\n",
snd_strerror(err));
return err;
}
/* enable period events when requested */
if (period_event) {
err = snd_pcm_sw_params_set_period_event(handle,
swparams, 1);
if (err < 0) {
printf("Unable to set period event: %s\n",
snd_strerror(err));
return err;
}
}
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for playback: %s\n",
snd_strerror(err));
return err;
}
return 0;}
/* Tenta recuperar estados de underrun e suspend */
static int xrun_recovery(snd_pcm_t *handle, int err)
{
if (verbose)
printf("stream recovery\n");
if (err == -EPIPE) { //under-run*/
err = snd_pcm_prepare(handle);
if (err < 0)
printf("Can't recovery from underrun,
prepare failed: %s\n", snd_strerror(err));
return 0;
} else if (err == -ESTRPIPE) {
while ((err = snd_pcm_resume(handle)) == -EAGAIN)
sleep(1); /*espera pela release flag*/
if (err < 0) {
err = snd_pcm_prepare(handle);
if (err < 0)
printf("Can't recovery from suspend,
prepare failed: %s\n", snd_strerror(err));
}
return 0;
}
return err;
}/* Metodo de transferência *WRITE-ONLY* */
static int write_loop(snd_pcm_t *handle,
signed short *samples, snd_pcm_channel_area_t *areas)
{
double phase = 0;
signed short *ptr;
int err, cptr;
while(1) {
generate_sine(areas, 0, period_size, &phase);
ptr = samples;
cptr = period_size;
while (cptr > 0) {
err = snd_pcm_writei(handle, ptr, cptr);
if (err == -EAGAIN)
continue;
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
printf("Write error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}//if
ptr += err * channels;
cptr -= err;
}//if
}//if
}//while
} /*
* Método de transferência - write and wait por espaço no buffer
*/
static int wait_for_poll(snd_pcm_t *handle, struct pollfd *ufds, unsigned int count)
{
unsigned short revents;
while (1) {
poll(ufds, count, -1);
snd_pcm_poll_descriptors_revents(handle, ufds, count,
&revents);
if (revents & POLLERR)
return -EIO;
if (revents & POLLOUT)
return 0;
}
}static int write_and_poll_loop(snd_pcm_t *handle,
signed short *samples, snd_pcm_channel_area_t *areas)
{
struct pollfd *ufds;
double phase = 0;
signed short *ptr;
int err, count, cptr, init;
count = snd_pcm_poll_descriptors_count (handle);
if (count <= 0) {
printf("Invalid poll descriptors count\n");
return count;
}
ufds = malloc(sizeof(struct pollfd) * count);
if (ufds == NULL) {
printf("No enough memory\n");
return -ENOMEM;
}
if ((err = snd_pcm_poll_descriptors(handle, ufds, count)) < 0) {
printf("Unable to obtain poll descriptors for
playback: %s\n", snd_strerror(err));
return err;
}
init = 1;
while (1) {
if (!init) {
err = wait_for_poll(handle, ufds, count);
if (err < 0) {
if (snd_pcm_state(handle) ==
SND_PCM_STATE_XRUN ||
snd_pcm_state(handle) ==
SND_PCM_STATE_SUSPENDED) {
err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
if (xrun_recovery(handle, err)
< 0) {
printf("Write error:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
init = 1;
} else {
printf("Wait for poll failed\n");
return err;
}
}
}
generate_sine(areas, 0, period_size, &phase);
ptr = samples;
cptr = period_size;
while (cptr > 0) {
err = snd_pcm_writei(handle, ptr, cptr);
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
printf("Write error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
init = 1;
break; /* skip one period */
}
if (snd_pcm_state(handle) ==
SND_PCM_STATE_RUNNING)
init = 0;
ptr += err * channels;
cptr -= err;
if (cptr == 0)
break;
/* it is possible, that the initial buffer
cannot store */
/* all data from the last period, so wait
awhile */
err = wait_for_poll(handle, ufds, count);
if (err < 0) {
if (snd_pcm_state(handle) ==
SND_PCM_STATE_XRUN ||
snd_pcm_state(handle) ==
SND_PCM_STATE_SUSPENDED) {
err = snd_pcm_state(handle) == SND_PCM_STATE_XRUN ? -EPIPE : -ESTRPIPE;
if (xrun_recovery(handle, err)
< 0) {
printf("Write error:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
init = 1;
} else {
printf("Wait for poll failed\n");
return err;
}
}
}
}
}/*
* Metodo de transferencia - Notificação assincrona */
struct async_private_data {
signed short *samples;
snd_pcm_channel_area_t *areas;
double phase;};
static void async_callback(snd_async_handler_t *ahandler) {
snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler); struct async_private_data *data =
snd_async_handler_get_callback_private(ahandler);
signed short *samples = data->samples;
snd_pcm_channel_area_t *areas = data->areas;
snd_pcm_sframes_t avail;
int err;
avail = snd_pcm_avail_update(handle);
while (avail >= period_size) {
generate_sine(areas, 0, period_size, &data->phase);
err = snd_pcm_writei(handle, samples, period_size);
if (err < 0) {
printf("Write error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
if (err != period_size) {
printf("Write error: written %i expected
%li\n", err, period_size);
exit(EXIT_FAILURE);
}
avail = snd_pcm_avail_update(handle);
}
}static int async_loop(snd_pcm_t *handle,
signed short *samples,
snd_pcm_channel_area_t *areas)
{
struct async_private_data data;
snd_async_handler_t *ahandler;
int err, count;
data.samples = samples;
data.areas = areas;
data.phase = 0;
err = snd_async_add_pcm_handler(&ahandler, handle,
async_callback, &data);
if (err < 0) {
printf("Unable to register async handler\n");
exit(EXIT_FAILURE);
}
for (count = 0; count < 2; count++) {
generate_sine(areas, 0, period_size, &data.phase);
err = snd_pcm_writei(handle, samples, period_size);
if (err < 0) {
printf("Initial write error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
if (err != period_size) {
printf("Initial write error: written %i
expected %li\n", err, period_size);
exit(EXIT_FAILURE);
}
}
if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED) {
err = snd_pcm_start(handle);
if (err < 0) {
printf("Start error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
}
/* because all other work is done in the signal handler,
suspend the process */
while (1) {
sleep(1);
}
} /*
* Transfer method - asynchronous notification + direct write
*/
static void async_direct_callback(snd_async_handler_t *ahandler) {
snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler); struct async_private_data *data =
snd_async_handler_get_callback_private(ahandler);
const snd_pcm_channel_area_t *my_areas;
snd_pcm_uframes_t offset, frames, size;
snd_pcm_sframes_t avail, commitres;
snd_pcm_state_t state;
int first = 0, err;
while (1) {
state = snd_pcm_state(handle);
if (state == SND_PCM_STATE_XRUN) {
err = xrun_recovery(handle, -EPIPE);
if (err < 0) {
printf("XRUN recovery failed: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
} else if (state == SND_PCM_STATE_SUSPENDED) {
err = xrun_recovery(handle, -ESTRPIPE);
if (err < 0) {
printf("SUSPEND recovery failed:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
}
avail = snd_pcm_avail_update(handle);
if (avail < 0) {
err = xrun_recovery(handle, avail);
if (err < 0) {
printf("avail update failed: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
continue;
}
if (avail < period_size) {
if (first) {
first = 0;
err = snd_pcm_start(handle);
if (err < 0) {
printf("Start error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
} else {
break;
}
continue;
}
size = period_size;
while (size > 0) {
frames = size;
err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
if (err < 0) {
if ((err = xrun_recovery(handle, err))
< 0) {
printf("MMAP begin avail
error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
}
generate_sine(my_areas, offset, frames,
&data->phase);
commitres = snd_pcm_mmap_commit(handle,
offset, frames);
if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
if ((err = xrun_recovery(handle,
commitres >= 0 ? -EPIPE : commitres)) < 0) {
printf("MMAP commit error:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
}
size -= frames;
}
}
}static int async_direct_loop(snd_pcm_t *handle,
signed short *samples ATTRIBUTE_UNUSED, snd_pcm_channel_area_t *areasATTRIBUTE_UNUSED)
{
struct async_private_data data;
snd_async_handler_t *ahandler;
const snd_pcm_channel_area_t *my_areas;
snd_pcm_uframes_t offset, frames, size;
snd_pcm_sframes_t commitres;
int err, count;
data.samples = NULL; /* we do not require the global sample area for direct write */
data.areas = NULL; /* we do not require the global areas
for direct write */
data.phase = 0;
err = snd_async_add_pcm_handler(&ahandler, handle,
async_direct_callback, &data);
if (err < 0) {
printf("Unable to register async handler\n");
exit(EXIT_FAILURE);
}
for (count = 0; count < 2; count++) {
size = period_size;
while (size > 0) {
frames = size;
err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
if (err < 0) {
if ((err = xrun_recovery(handle, err))
< 0) {
printf("MMAP begin avail
error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
}
generate_sine(my_areas, offset, frames,
&data.phase);
commitres = snd_pcm_mmap_commit(handle,
offset, frames);
if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
if ((err = xrun_recovery(handle,
commitres >= 0 ? -EPIPE : commitres)) < 0) {
printf("MMAP commit error:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
}
size -= frames;
}
}
err = snd_pcm_start(handle);
if (err < 0) {
printf("Start error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
/* because all other work is done in the signal handler,
suspend the process */
while (1) {
sleep(1);
}
} /*
* Transfer method - direct write only
*/
static int direct_loop(snd_pcm_t *handle,
signed short *samples ATTRIBUTE_UNUSED, snd_pcm_channel_area_t *areas ATTRIBUTE_UNUSED)
{
double phase = 0;
const snd_pcm_channel_area_t *my_areas;
snd_pcm_uframes_t offset, frames, size;
snd_pcm_sframes_t avail, commitres;
snd_pcm_state_t state;
int err, first = 1;
while (1) {
state = snd_pcm_state(handle);
if (state == SND_PCM_STATE_XRUN) {
err = xrun_recovery(handle, -EPIPE);
if (err < 0) {
printf("XRUN recovery failed: %s\n",
snd_strerror(err));
return err;
}
first = 1;
} else if (state == SND_PCM_STATE_SUSPENDED) {
err = xrun_recovery(handle, -ESTRPIPE);
if (err < 0) {
printf("SUSPEND recovery failed:
%s\n", snd_strerror(err));
return err;
}
}
avail = snd_pcm_avail_update(handle);
if (avail < 0) {
err = xrun_recovery(handle, avail);
if (err < 0) {
printf("avail update failed: %s\n",
snd_strerror(err));
return err;
}
first = 1;
continue;
}
if (avail < period_size) {
if (first) {
first = 0;
err = snd_pcm_start(handle);
if (err < 0) {
printf("Start error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
} else {
err = snd_pcm_wait(handle, -1);
if (err < 0) {
if ((err =
xrun_recovery(handle, err)) < 0) {
printf("snd_pcm_wait
error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
}
}
continue;
}
size = period_size;
while (size > 0) {
frames = size;
err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
if (err < 0) {
if ((err = xrun_recovery(handle, err))
< 0) {
printf("MMAP begin avail
error: %s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
}
generate_sine(my_areas, offset, frames, &phase);
commitres = snd_pcm_mmap_commit(handle,
offset, frames);
if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
if ((err = xrun_recovery(handle,
commitres >= 0 ? -EPIPE : commitres)) < 0) {
printf("MMAP commit error:
%s\n", snd_strerror(err));
exit(EXIT_FAILURE);
}
first = 1;
}
size -= frames;
}
}
}/*
* Transfer method - direct write only using mmap_write functions
*/
static int direct_write_loop(snd_pcm_t *handle,
signed short *samples,
snd_pcm_channel_area_t *areas)
{
double phase = 0;
signed short *ptr;
int err, cptr;
while (1) {
generate_sine(areas, 0, period_size, &phase);
ptr = samples;
cptr = period_size;
while (cptr > 0) {
err = snd_pcm_mmap_writei(handle, ptr, cptr);
if (err == -EAGAIN)
continue;
if (err < 0) {
if (xrun_recovery(handle, err) < 0) {
printf("Write error: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
break; /* skip one period */
}
ptr += err * channels;
cptr -= err;
}
}
}struct transfer_method {
const char *name;
snd_pcm_access_t access;
int (*transfer_loop)(snd_pcm_t *handle,
signed short *samples,
snd_pcm_channel_area_t *areas);
};static struct transfer_method transfer_methods[] = {
{ "write", SND_PCM_ACCESS_RW_INTERLEAVED, write_loop }, { "write_and_poll", SND_PCM_ACCESS_RW_INTERLEAVED,write_and_poll_loop },
{ "async", SND_PCM_ACCESS_RW_INTERLEAVED, async_loop }, { "async_direct", SND_PCM_ACCESS_MMAP_INTERLEAVED,async_direct_loop },
{ "direct_interleaved", SND_PCM_ACCESS_MMAP_INTERLEAVED,direct_loop },
{ "direct_noninterleaved", SND_PCM_ACCESS_MMAP_NONINTERLEAVED,direct_loop },
{ "direct_write", SND_PCM_ACCESS_MMAP_INTERLEAVED,direct_write_loop },
{ NULL, SND_PCM_ACCESS_RW_INTERLEAVED, NULL }
};static void help(void)
{
int k;
printf(
"Usage: pcm [OPTION]... [FILE]...\n"
"-h,--help help\n"
"-D,--device playback device\n"
"-r,--rate stream rate in Hz\n"
"-c,--channels count of channels in stream\n"
"-f,--frequency sine wave frequency in Hz\n"
"-b,--buffer ring buffer size in us\n"
"-p,--period period size in us\n"
"-m,--method transfer method\n"
"-o,--format sample format\n"
"-v,--verbose show the PCM setup parameters\n"
"-n,--noresample do not resample\n"
"-e,--pevent enable poll event after each period\n"
"\n");
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
const char *s = snd_pcm_format_name(k);
if (s)
printf(" %s", s);
}
printf("\n");
printf("Recognized transfer methods are:");
for (k = 0; transfer_methods[k].name; k++)
printf(" %s", transfer_methods[k].name);
printf("\n");
}int main (int argc, char *argv[])
{
struct option long_option[] =
{
{"help", 0, NULL, 'h'},
{"device", 1, NULL, 'd'},
{"rate", 1, NULL, 'r'},
{"channels", 1, NULL, 'c'},
{"frequency", 1, NULL, 'f'},
{"buffer", 1, NULL, 'b'},
{"period", 1, NULL, 'p'},
{"method", 1, NULL, 'm'},
{"format", 1, NULL, 'o'},
{"verbose", 1, NULL, 'v'},
{"noresample", 1, NULL, 'n'},
{"pevent", 1, NULL, 'e'},
{NULL, 0, NULL, 0},
};
snd_pcm_t *handle; //ponteiro
para pcm handle
int err, morehelp;
snd_pcm_hw_params_t *hwparams;
//parametros de hardware
snd_pcm_sw_params_t *swparams;
//parametros de software
int method = 0;
signed short *samples;
unsigned int chn;
snd_pcm_channel_area_t *areas;
//snd_pcm_hw_params_alloca(&hwparams);
//snd_pcm_sw_params_alloca(&swparams);
morehelp = 0;
while (1) {
int c;
if ((c = getopt_long(argc, argv,
"hd:r:c:f:b:p:m:o:vne", long_option, NULL)) < 0)
break;
switch(c) {
case 'h':
morehelp++;
break;
case 'd':
device = strdup(optarg);
break;
case 'r':
rate = atoi(optarg);
rate = rate < 4000 ? 4000 : rate;
rate = rate > 196000 ? 19600 : rate;
break;
case 'c':
channels = atoi(optarg);
channels = channels < 1 ? 1 : channels;
channels = channels > 1024 ? 1024 : channels;
break;
case 'f':
freq = atoi(optarg);
freq = freq < 50 ? 50 : freq;
freq = freq > 5000 ? 5000 : freq;
break;
case 'b':
buffer_time = atoi(optarg);
buffer_time = buffer_time < 1000 ? 1000 :
buffer_time;
buffer_time = buffer_time > 1000000 ?
1000000 : buffer_time;
break;
case 'p':
period_time = atoi(optarg);
period_time = period_time < 1000 ? 1000 :
period_time;
period_time = period_time > 1000000 ?
1000000 : period_time;
break;
case 'm':
for (method = 0;
transfer_methods[method].name; method++)
if
(!strcasecmp(transfer_methods[method].name, optarg))
break;
if (transfer_methods[method].name == NULL)
method = 0;
break;
case 'o':
for (format = 0; format < SND_PCM_FORMAT_LAST; format++) {
const char *format_name =snd_pcm_format_name(format);
if (format_name)
if
(!strcasecmp(format_name, optarg))
break;
}
if (format == SND_PCM_FORMAT_LAST)
format = SND_PCM_FORMAT_S16;
break;
case 'v':
verbose = 1;
break;
case 'n':
resample = 0;
break;
case 'e':
period_event = 1;
break;
}//switch
}//while
if(morehelp) {
help();
return 0;
}
//cria um novo output objeto
err = snd_output_stdio_attach(&output, &stdout, 0);
if (err < 0) {
printf("Output failed: %s\n", snd_strerror(err));
return 0;
}
printf("Playback device is %s\n", device);
printf("Stream parameters are %iHz, %s, %i channels\n", rate, snd_pcm_format_name(format), channels);
printf("sine wave rate is %i %.4fHz\n", freq); printf("Using transfer method: %s\n",
transfer_methods[method].name);
if ((err = snd_pcm_open(&handle, device,SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
printf("Playback open error: %s\n",
snd_strerror(err));
return 0;
}
if ((err = set_hwparams(handle, hwparams,
transfer_methods[method].access)) < 0) {
printf("Setting of hwparams failed: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
if ((err = set_swparams(handle, swparams)) < 0) {
printf("Setting of swparams failed: %s\n",
snd_strerror(err));
exit(EXIT_FAILURE);
}
if (verbose > 0)
snd_pcm_dump(handle, output);
samples = malloc((period_size * channels *
snd_pcm_format_physical_width(format)) / 8);
if (samples == NULL) {
printf("No enough memory\n");
exit(EXIT_FAILURE);
}
areas = calloc(channels, sizeof(snd_pcm_channel_area_t));
if (areas == NULL) {
printf("No enough memory\n");
exit(EXIT_FAILURE);
}
for (chn = 0; chn < channels; chn++) {
areas[chn].addr = samples;
areas[chn].first = chn * snd_pcm_format_physical_width(format);
areas[chn].step = channels *snd_pcm_format_physical_width(format);
}
err = transfer_methods[method].transfer_loop(handle,
samples, areas);
if (err < 0)
printf("Transfer failed: %s\n", snd_strerror(err));
free(areas);
free(samples);
snd_pcm_close(handle);
return 0;
}Thanks in advance;
Tks!
-------------------
Guilherme Longo
Dept. Eng. da Computação
Unaerp
Linux User - #484927
*Before Asking
http://www.istf.com.br/?page=perguntas
!- I'd rather die on my feet than live on my knees -!
Quoted 59 lines · Ted T. Logan
ALSA lib pcm_bluetooth.c:1607:(audioservice_expect)
BT_OPENfailed :
Invalid argument(22)** WARNING **:
alsa_setup(): Unable to install hw paramsI get this all the time now. What does this error mean?
arecord -D bluetoothh550 -f
S16_LE| aplay -D bluetoothh550 -fS16_LERecording WAVE 'stdin' : Signed 16 bit Little Endian, Rate 8000 Hz, Mono ALSA lib pcm_bluetooth.c:1607:(audioservice_expect)BT_OPENfailed :
Invalid argument(22)arecord: set_params:1041: Unable to install hw params: ACCESS: RW_INTERLEAVED FORMAT: S16_LE SUBFORMAT: STD SAMPLE_BITS: 16 FRAME_BITS: 16 CHANNELS: 1 RATE: 8000 PERIOD_TIME: 125000 PERIOD_SIZE: 1000 PERIOD_BYTES: 2000 PERIODS: 4 BUFFER_TIME: 500000 BUFFER_SIZE: 4000 BUFFER_BYTES: 8000 TICK_TIME: [0 0] aplay: playback:2297: read errorand here with mplayer
Playing skypering.wav.
Audio only file format detected.
==========================================================================
Opening audio decoder: [pcm] Uncompressed PCM audio decoder
AUDIO: 16000 Hz, 2 ch, s16le, 512.0 kbit/100.00% (ratio: 64000->64000) Selected audio codec: [pcm] afm: pcm (Uncompressed PCM)
==========================================================================
[AO_ALSA] alsa-lib: pcm_bluetooth.c:1607:(audioservice_expect)BT_OPENfailed : Invalid argument(22)
[AO_ALSA] Unable to set hw-parameters: Invalid argument Failed to initialize audio driver 'alsa:device=bluetoothh550' Could not open/initialize audio device -> no sound.
Audio: no sound
Video: no video_______________________________________________
Alsa-devel mailing list
[email protected]
http://mailman.alsa-project.org/mailman/listinfo/alsa-devel
PATCH 1/1 ASoC: UDA1380: refactor device registration
In reply to Mark BrownThis patch mostly follows commit 5998102b9095fdb7c67755812038612afea315c5 "ASoC: Refactor WM8731 device registration" to make UDA1380 use standard device instantiation. Similarly, the I2C device registration temporarily moves into the magician machine driver before it will find its final resting place in the board file.
At the same time, platform specific configuration is moved to platform data and common power/reset GPIO handling moves into the codec driver.
--- include/sound/uda1380.h | 22 +++ sound/soc/codecs/uda1380.c | 313 ++++++++++++++++++++++++-------------------- sound/soc/codecs/uda1380.h | 8 - sound/soc/pxa/magician.c | 54 ++++---- 4 files changed, 221 insertions(+), 176 deletions(-) create mode 100644 include/sound/uda1380.h
include/sound/uda1380.h new file +22 -0
@@ -0,0 +1,22 @@ +/* +* UDA1380 ALSA SoC Codec driver +* +* Copyright 2009 Philipp Zabel +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +*/ + +#ifndef __UDA1380_H +#define __UDA1380_H + +struct uda1380_platform_data { +int gpio_power; +int gpio_reset; +int dac_clk; +#define UDA1380_DAC_CLK_SYSCLK 0 +#define UDA1380_DAC_CLK_WSPLL 1 +}; + +#endif /* __UDA1380_H */
sound/soc/codecs/uda1380.c +171 -142
447 lines not on this page · raw message
sound/soc/codecs/uda1380.h +0 -8
@@ -72,14 +72,6 @@#define R22_SKIP_DCFIL 0x0002#define R23_AGC_EN 0x0001 -struct uda1380_setup_data { -int i2c_bus; -unsigned short i2c_address; -int dac_clk; -#define UDA1380_DAC_CLK_SYSCLK 0 -#define UDA1380_DAC_CLK_WSPLL 1 -}; -#define UDA1380_DAI_DUPLEX 0/* playback and capture on single DAI */ #define UDA1380_DAI_PLAYBACK 1/* playback DAI */ #define UDA1380_DAI_CAPTURE 2/* capture DAI */
sound/soc/pxa/magician.c +28 -26
113 lines not on this page · raw message
Signature · 1 line
1.6.3.1
Re: [PATCH] ASoC: UDA1380: refactor device registration
Quoted 10 lines · Philipp Zabel
This patch mostly follows commit
5998102b9095fdb7c67755812038612afea315c5"ASoC: Refactor WM8731 device registration" to make UDA1380 use standard device instantiation. Similarly, the I2C device registration temporarily moves into the magician machine driver before it will find its final resting place in the board file.At the same time, platform specific configuration is moved to platform data and common power/reset GPIO handling moves into the codec driver.
Signed-off-by Philipp Zabel <[email protected]>
Great stuff, applied thanks.
Mark Brown
AppliedRe: [PATCH 1/3] ASoC: magician: fix PXA SSP clock polarity
In reply to Philipp ZabelQuoted 3 lines · Philipp Zabel
Follow-up fix needed since "ASoC:
pxa-ssp.cfix clock/frame invert".Signed-off-by Philipp Zabel <[email protected]>
Applied, thanks.