Skip to contentSkip to conversation

magician fix and UDA1380 i2c device registration change

RFC PATCH Applied Philipp Zabel 6 participants 14 messages Jun 14, 2009 – Jun 15, 2009 1 message not in the archive

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

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]

#2 lore raw

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
index a04ddc3..fa0e7e6 100644
@@ -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
#3 lore raw

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
new file mode 100644
index 0000000..69f8775
@@ -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
index c55c17a..d7904c5 100644
@@ -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
index fa0e7e6..cc7dbe5 100644
@@ -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
#4 lore raw

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
index 869f083..3da8284 100644
@@ -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
#5 lore raw

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.

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
index 869f083..3da8284 100644
@@ -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
#6 lore raw

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.

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-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?

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

#7 lore raw

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.

#8 lore raw

Re: [PATCH, RFC 2/3] ASoC: UDA1380: register from board files, configure via pdata

In reply to Philipp Zabel
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_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.

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.

#9 lore raw

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_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.

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  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?

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

#10 lore raw

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

#11 lore raw

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 *areas
ATTRIBUTE_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_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

_______________________________________________
Alsa-devel mailing list
[email protected]
http://mailman.alsa-project.org/mailman/listinfo/alsa-devel

#12 lore raw

PATCH 1/1 ASoC: UDA1380: refactor device registration

In reply to Mark Brown

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.

---
 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
new file mode 100644
index 0000000..381319c
@@ -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
index c55c17a..9cefa8a 100644
@@ -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
#13 lore raw

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.

Great stuff, applied thanks.