Additional updates to the multi-component branch. Liam, please squash these
in.
Signed-off-by: Timur Tabi <timur(a)freescale.com>
---
sound/soc/fsl/fsl_dma.c | 68 +++++++++++++++--------
sound/soc/fsl/fsl_dma.h | 3 -
sound/soc/fsl/fsl_ssi.c | 37 +++++++-----
sound/soc/fsl/mpc8610_hpcd.c | 125 ++++++++++++++++++++++++++---------------
4 files changed, 144 insertions(+), 89 deletions(-)
diff --git a/sound/soc/fsl/fsl_dma.c b/sound/soc/fsl/fsl_dma.c
index 7f87297..d09e194 100644
--- a/sound/soc/fsl/fsl_dma.c
+++ b/sound/soc/fsl/fsl_dma.c
@@ -32,6 +32,7 @@
#include <asm/io.h>
#include "fsl_dma.h"
+#include "fsl_ssi.h" /* For the offset of stx0 and srx0 */
/*
* The formats that the DMA controller supports, which is anything
@@ -798,36 +799,35 @@ static void fsl_dma_free_dma_buffers(struct snd_pcm *pcm)
static LIST_HEAD(dma_list);
/**
- * fsl_soc_dma_to_dai - returning the DAI struct for a given DMA node
- *
- * When a machine driver registers itself with ASoC, it must provide the
- * address of the DAI structures that it wants to connect. Most drivers simply
- * reference global data structures in the various drivers, but we PowerPC
- * developers are better than that. This driver keeps a list of every DMA
- * node that it probes, and when the machine driver wants to reference a
- * DMA DAI, this function provides that service.
- *
- * Hopefully one day, ASoC will just want the name of the DMA device, not
- * some obscure pointer, and this function will go away.
+ * find_ssi_node -- returns the SSI node that points to his DMA channel node
+ *
+ * Although this DMA driver attempts to operate independently of the other
+ * devices, it still needs to determine some information about the SSI device
+ * that it's working with. Unfortunately, the device tree does not contain
+ * a pointer from the DMA channel node to the SSI node -- the pointer goes the
+ * other way. So we need to scan the device tree for SSI nodes until we find
+ * the one that points to the given DMA channel node. It's ugly, but at least
+ * it's contained in this one function.
*/
-struct snd_soc_platform_driver *fsl_soc_dma_to_dai(const char *path,
- dma_addr_t ssi_stx_phys, dma_addr_t ssi_srx_phys)
+static struct device_node *find_ssi_node(struct device_node *dma_channel_np)
{
- struct list_head *ptr;
- struct dma_object *dma;
+ struct device_node *ssi_np, *np;
- list_for_each(ptr, &dma_list) {
- dma = list_entry(ptr, struct dma_object, list);
- if (strcmp(path, dma->path) == 0) {
- dma->ssi_stx_phys = ssi_stx_phys;
- dma->ssi_srx_phys = ssi_srx_phys;
- return &dma->dai;
- }
+ for_each_compatible_node(ssi_np, NULL, "fsl,mpc8610-ssi") {
+ /* Check each DMA phandle to see if it points to us. We
+ * assume that device_node pointers are a valid comparison.
+ */
+ np = of_parse_phandle(ssi_np, "fsl,playback-dma", 0);
+ if (np == dma_channel_np)
+ return ssi_np;
+
+ np = of_parse_phandle(ssi_np, "fsl,capture-dma", 0);
+ if (np == dma_channel_np)
+ return ssi_np;
}
return NULL;
}
-EXPORT_SYMBOL(fsl_soc_dma_to_dai);
static struct snd_pcm_ops fsl_dma_ops = {
.open = fsl_dma_open,
@@ -843,8 +843,24 @@ static int __devinit fsl_soc_dma_probe(struct of_device *of_dev,
{
struct dma_object *dma;
struct device_node *np = of_dev->dev.of_node;
+ struct device_node *ssi_np;
+ struct resource res;
int ret;
+ /* Find the SSI node that points to us. */
+ ssi_np = find_ssi_node(np);
+ if (!ssi_np) {
+ dev_err(&of_dev->dev, "cannot find parent SSI node\n");
+ return -ENODEV;
+ }
+
+ ret = of_address_to_resource(ssi_np, 0, &res);
+ of_node_put(ssi_np);
+ if (ret) {
+ dev_err(&of_dev->dev, "could not determine device resources\n");
+ return ret;
+ }
+
dma = kzalloc(sizeof(*dma) + strlen(np->full_name), GFP_KERNEL);
if (!dma) {
dev_err(&of_dev->dev, "could not allocate dma object\n");
@@ -856,6 +872,10 @@ static int __devinit fsl_soc_dma_probe(struct of_device *of_dev,
dma->dai.pcm_new = fsl_dma_new;
dma->dai.pcm_free = fsl_dma_free_dma_buffers;
+ /* Store the SSI-specific information that we need */
+ dma->ssi_stx_phys = res.start + offsetof(struct ccsr_ssi, stx0);
+ dma->ssi_srx_phys = res.start + offsetof(struct ccsr_ssi, srx0);
+
ret = snd_soc_register_platform(&of_dev->dev, &dma->dai);
if (ret) {
dev_err(&of_dev->dev, "could not register platform\n");
@@ -921,7 +941,7 @@ static void __exit fsl_soc_dma_exit(void)
* will already have been probed. The easiest way to do that is to make the
* __init function called via arch_initcall().
*/
-arch_initcall(fsl_soc_dma_init);
+module_init(fsl_soc_dma_init);
module_exit(fsl_soc_dma_exit);
MODULE_AUTHOR("Timur Tabi <timur(a)freescale.com>");
diff --git a/sound/soc/fsl/fsl_dma.h b/sound/soc/fsl/fsl_dma.h
index e152bc6..78fee97 100644
--- a/sound/soc/fsl/fsl_dma.h
+++ b/sound/soc/fsl/fsl_dma.h
@@ -126,7 +126,4 @@ struct fsl_dma_link_descriptor {
u8 res[4]; /* Reserved */
} __attribute__ ((aligned(32), packed));
-struct snd_soc_platform_driver *fsl_soc_dma_to_dai(const char *path,
- dma_addr_t ssi_stx_phys, dma_addr_t ssi_srx_phys);
-
#endif
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 2388484..51b089f 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -292,8 +292,7 @@ static int fsl_ssi_startup(struct snd_pcm_substream *substream,
/* The 'name' should not have any slashes in it. */
ret = request_irq(ssi_private->irq, fsl_ssi_isr, 0,
- strrchr(ssi_private->name, '/') + 1,
- ssi_private);
+ ssi_private->name, ssi_private);
if (ret < 0) {
dev_err(substream->pcm->card->dev,
"could not claim irq %u\n", ssi_private->irq);
@@ -622,11 +621,9 @@ static int __devinit fsl_ssi_probe(struct of_device *of_dev,
int ret = 0;
struct device_attribute *dev_attr;
struct device_node *np = of_dev->dev.of_node;
- const char *sprop;
+ const char *p, *sprop;
struct resource res;
char name[64];
- struct platform_device *pdev;
- void *platform_data;
/* We are only interested in SSIs with a codec phandle in them, so let's
* make sure this SSI has one.
@@ -641,21 +638,22 @@ static int __devinit fsl_ssi_probe(struct of_device *of_dev,
return -ENODEV;
}
- ssi_private = kzalloc(sizeof(struct fsl_ssi_private) +
- strlen(np->full_name), GFP_KERNEL);
+ /* The DAI name is the last part of the full name of the node. */
+ p = strrchr(np->full_name, '/') + 1;
+ ssi_private = kzalloc(sizeof(struct fsl_ssi_private) + strlen(p),
+ GFP_KERNEL);
if (!ssi_private) {
dev_err(&of_dev->dev, "could not allocate DAI object\n");
return -ENOMEM;
}
+ strcpy(ssi_private->name, p);
+
/* Initialize this copy of the CPU DAI driver structure */
memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template,
sizeof(fsl_ssi_dai_template));
ssi_private->cpu_dai_drv.name = ssi_private->name;
- /* The name we register with ASoC is the full node name */
- strlcpy(ssi_private->name, np->full_name, sizeof(ssi_private->name));
-
/* Get the addresses and IRQ */
ret = of_address_to_resource(np, 0, &res);
if (ret) {
@@ -698,19 +696,26 @@ static int __devinit fsl_ssi_probe(struct of_device *of_dev,
}
/* Trigger the machine driver's probe function. The platform driver
- * name of the machine driver is taken from the /model node of the
+ * name of the machine driver is taken from the /model property of the
* device tree. We also pass the address of the CPU DAI driver
* structure.
*/
sprop = of_get_property(of_find_node_by_path("/"), "model", NULL);
+ /* Sometimes the model name has a "fsl," prefix, so we strip that. */
+ p = strrchr(sprop, ',');
+ if (p)
+ sprop = p + 1;
snprintf(name, sizeof(name), "snd-soc-%s", sprop);
make_lowercase(name);
- platform_data = &ssi_private->cpu_dai_drv;
- pdev = platform_device_register_data(&of_dev->dev, name,
- 0, &platform_data, sizeof(void *));
-
- ssi_private->pdev = pdev;
+ ssi_private->pdev =
+ platform_device_register_data(&of_dev->dev, name, 0, NULL, 0);
+ if (IS_ERR(ssi_private->pdev)) {
+ ret = PTR_ERR(ssi_private->pdev);
+ dev_err(&of_dev->dev, "failed to register platform: %d\n", ret);
+ kfree(ssi_private);
+ return ret;
+ }
return 0;
}
diff --git a/sound/soc/fsl/mpc8610_hpcd.c b/sound/soc/fsl/mpc8610_hpcd.c
index e87cd1e..38339c1 100644
--- a/sound/soc/fsl/mpc8610_hpcd.c
+++ b/sound/soc/fsl/mpc8610_hpcd.c
@@ -22,6 +22,8 @@
/* There's only one global utilities register */
static phys_addr_t guts_phys;
+#define DAI_NAME_SIZE 32
+
/**
* mpc8610_hpcd_data: machine-specific ASoC device data
*
@@ -38,7 +40,9 @@ struct mpc8610_hpcd_data {
unsigned int ssi_id; /* 0 = SSI1, 1 = SSI2, etc */
unsigned int dma_id[2]; /* 0 = DMA1, 1 = DMA2, etc */
unsigned int dma_channel_id[2]; /* 0 = ch 0, 1 = ch 1, etc*/
- char dai_name[32];
+ char codec_dai_name[DAI_NAME_SIZE];
+ char codec_name[DAI_NAME_SIZE];
+ char platform_name[2][DAI_NAME_SIZE]; /* One for each DMA channel */
};
/**
@@ -233,25 +237,68 @@ static int get_parent_cell_index(struct device_node *np)
return *iprop;
}
+/**
+ * codec_node_dev_name - determine the dev_name for a codec node
+ *
+ * This function determines the dev_name for an I2C node. This is the name
+ * that would be returned by dev_name() if this device_node were part of a
+ * 'struct device' It's ugly and hackish, but it works.
+ *
+ * The dev_name for such devices include the bus number and I2C address. For
+ * example, "cs4270-codec.0-004f".
+ */
+static int codec_node_dev_name(struct device_node *np, char *buf, size_t len)
+{
+ const u32 *iprop;
+ int bus, addr;
+ char temp[DAI_NAME_SIZE];
+
+ of_modalias_node(np, temp, DAI_NAME_SIZE);
+
+ iprop = of_get_property(np, "reg", NULL);
+ if (!iprop)
+ return -EINVAL;
+
+ addr = *iprop;
+
+ bus = get_parent_cell_index(np);
+ if (bus < 0)
+ return bus;
+
+ snprintf(buf, len, "%s-codec.%u-%04x", temp, bus, addr);
+
+ return 0;
+}
+
static int get_dma_channel(struct device_node *ssi_np,
const char *compatible,
- dma_addr_t ssi_stx_phys,
- dma_addr_t ssi_srx_phys,
struct snd_soc_dai_link *dai,
unsigned int *dma_channel_id,
unsigned int *dma_id)
{
+ struct resource res;
struct device_node *dma_channel_np;
const u32 *iprop;
+ int ret;
dma_channel_np = get_node_by_phandle_name(ssi_np, compatible,
"fsl,ssi-dma-channel");
if (!dma_channel_np)
return -EINVAL;
- // FIXME: change this to get the OF device name
- dai->platform_name = fsl_soc_dma_to_dai(dma_channel_np->full_name,
- ssi_stx_phys, ssi_srx_phys);
+ /* Determine the dev_name for the device_node. This code mimics the
+ * behavior of of_device_make_bus_id(). We need this because ASoC uses
+ * the dev_name() of the device to match the platform (DMA) device with
+ * the CPU (SSI) device. It's all ugly and hackish, but it works (for
+ * now).
+ *
+ * dai->platform name should already point to an allocated buffer.
+ */
+ ret = of_address_to_resource(dma_channel_np, 0, &res);
+ if (ret)
+ return ret;
+ snprintf((char *)dai->platform_name, DAI_NAME_SIZE, "%llx.%s",
+ (unsigned long long) res.start, dma_channel_np->name);
iprop = of_get_property(dma_channel_np, "cell-index", NULL);
if (!iprop) {
@@ -265,6 +312,7 @@ static int get_dma_channel(struct device_node *ssi_np,
return 0;
}
+
/**
* mpc8610_hpcd_probe: platform probe function for the machine driver
*
@@ -274,22 +322,16 @@ static int get_dma_channel(struct device_node *ssi_np,
*/
static int mpc8610_hpcd_probe(struct platform_device *pdev)
{
- struct snd_soc_dai_driver **platform_data = pdev->dev.platform_data;
struct device *dev = pdev->dev.parent;
+ /* of_dev is the OF device for the SSI node that probed us */
struct of_device *of_dev = container_of(dev, struct of_device, dev);
struct device_node *np = of_dev->dev.of_node;
struct device_node *codec_np = NULL;
- struct device_node *dma_np = NULL;
- struct device_node *dma_channel_np = NULL;
struct platform_device *sound_device = NULL;
struct mpc8610_hpcd_data *machine_data;
- int id;
- dma_addr_t ssi_stx_phys;
- dma_addr_t ssi_srx_phys;
int ret = -ENODEV;
const char *sprop;
const u32 *iprop;
- struct resource res;
/* We are only interested in SSIs with a codec phandle in them,
* so let's make sure this SSI has one. The MPC8610 HPCD only
@@ -306,20 +348,27 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
if (!machine_data)
return -ENOMEM;
- machine_data->dai[0].name = machine_data->dai_name;
+ machine_data->dai[0].cpu_dai_name = dev_name(&of_dev->dev);
+ machine_data->dai[0].ops = &mpc8610_hpcd_ops;
- /* FIXME: Timur, do we need to append .0 or .1 suffix here ? */
- machine_data->dai[0].cpu_dai_name = "fsl-ssi-dai";
- machine_data->dai[0].platform_name = "fsl-pcm-audio";
+ /* Determine the codec name, it will be used as the codec DAI name */
+ ret = codec_node_dev_name(codec_np, machine_data->codec_name,
+ DAI_NAME_SIZE);
+ if (ret) {
+ dev_err(&pdev->dev, "invalid codec node %s\n",
+ codec_np->full_name);
+ ret = -EINVAL;
+ goto error;
+ }
+ machine_data->dai[0].codec_name = machine_data->codec_name;
+ /* The DAI name from the codec (snd_soc_dai_driver.name) */
machine_data->dai[0].codec_dai_name = "cs4270-hifi";
- machine_data->dai[0].codec_name = "cs4270-codec";
- machine_data->dai[0].ops = &mpc8610_hpcd_ops;
-
- /* Store the codec name, it will be used as the codec DAI name */
- of_modalias_node(codec_np, machine_data->dai_name,
- sizeof(machine_data->dai_name));
+ /* We register two DAIs per SSI, one for playback and the other for
+ * capture. Currently, we only support codecs that have one DAI for
+ * both playback and capture.
+ */
memcpy(&machine_data->dai[1], &machine_data->dai[0],
sizeof(struct snd_soc_dai_link));
@@ -331,7 +380,6 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
goto error;
}
machine_data->ssi_id = *iprop;
- id = *iprop;
/* Get the serial format and clock direction. */
sprop = of_get_property(np, "fsl,mode", NULL);
@@ -399,18 +447,9 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
goto error;
}
- /* Read the SSI information from the device tree */
- ret = of_address_to_resource(np, 0, &res);
- if (ret || !res.start) {
- dev_err(&pdev->dev, "could not obtain SSI address\n");
- goto error;
- }
- ssi_stx_phys = res.start + offsetof(struct ccsr_ssi, stx0);
- ssi_srx_phys = res.start + offsetof(struct ccsr_ssi, srx0);
-
/* Find the playback DMA channel to use. */
- ret = get_dma_channel(np, "fsl,playback-dma", ssi_stx_phys,
- ssi_srx_phys, &machine_data->dai[0],
+ machine_data->dai[0].platform_name = machine_data->platform_name[0];
+ ret = get_dma_channel(np, "fsl,playback-dma", &machine_data->dai[0],
&machine_data->dma_channel_id[0],
&machine_data->dma_id[0]);
if (ret) {
@@ -419,8 +458,8 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
}
/* Find the capture DMA channel to use. */
- ret = get_dma_channel(np, "fsl,capture-dma", ssi_stx_phys,
- ssi_srx_phys, &machine_data->dai[1],
+ machine_data->dai[1].platform_name = machine_data->platform_name[1];
+ ret = get_dma_channel(np, "fsl,capture-dma", &machine_data->dai[1],
&machine_data->dma_channel_id[1],
&machine_data->dma_id[1]);
if (ret) {
@@ -429,18 +468,14 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
}
/* Initialize our DAI data structure. */
- iprop = of_get_property(codec_np, "reg", NULL);
- if (!iprop) {
- dev_err(&pdev->dev, "codec node is missing 'reg' property\n");
- goto error;
- }
-
machine_data->dai[0].stream_name = "playback";
machine_data->dai[1].stream_name = "capture";
+ machine_data->dai[0].name = machine_data->dai[0].stream_name;
+ machine_data->dai[1].name = machine_data->dai[1].stream_name;
machine_data->card.probe = mpc8610_hpcd_machine_probe;
machine_data->card.remove = mpc8610_hpcd_machine_remove;
- machine_data->card.name = "MPC8610 HPCD";
+ machine_data->card.name = pdev->name; /* The platform driver name */
machine_data->card.num_links = 2;
machine_data->card.dai_link = machine_data->dai;
@@ -468,8 +503,6 @@ static int mpc8610_hpcd_probe(struct platform_device *pdev)
error:
of_node_put(codec_np);
- of_node_put(dma_np);
- of_node_put(dma_channel_np);
if (sound_device)
platform_device_unregister(sound_device);
--
1.7.0.1
