| // SPDX-License-Identifier: GPL-2.0 |
| // |
| // ASoC Audio Graph Card2 support |
| // |
| // Copyright (C) 2020 Renesas Electronics Corp. |
| // Copyright (C) 2020 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> |
| // |
| // based on ${LINUX}/sound/soc/generic/audio-graph-card.c |
| #include <linux/clk.h> |
| #include <linux/device.h> |
| #include <linux/gpio.h> |
| #include <linux/gpio/consumer.h> |
| #include <linux/module.h> |
| #include <linux/of.h> |
| #include <linux/of_device.h> |
| #include <linux/of_gpio.h> |
| #include <linux/of_graph.h> |
| #include <linux/platform_device.h> |
| #include <linux/string.h> |
| #include <sound/graph_card.h> |
| |
| /************************************ |
| daifmt |
| ************************************ |
| ports { |
| format = "left_j"; |
| port@0 { |
| bitclock-master; |
| sample0: endpoint@0 { |
| frame-master; |
| }; |
| sample1: endpoint@1 { |
| format = "i2s"; |
| }; |
| }; |
| ... |
| }; |
| |
| You can set daifmt at ports/port/endpoint. |
| It uses *latest* format, and *share* master settings. |
| In above case, |
| sample0: left_j, bitclock-master, frame-master |
| sample1: i2s, bitclock-master |
| |
| If there was no settings, *Codec* will be |
| bitclock/frame provider as default. |
| see |
| graph_parse_daifmt(). |
| |
| ************************************ |
| Normal Audio-Graph |
| ************************************ |
| |
| CPU <---> Codec |
| |
| sound { |
| compatible = "audio-graph-card2"; |
| links = <&cpu>; |
| }; |
| |
| CPU { |
| cpu: port { |
| bitclock-master; |
| frame-master; |
| cpu_ep: endpoint { remote-endpoint = <&codec_ep>; }; }; |
| }; |
| |
| Codec { |
| port { codec_ep: endpoint { remote-endpoint = <&cpu_ep>; }; }; |
| }; |
| |
| ************************************ |
| Multi-CPU/Codec |
| ************************************ |
| |
| It has connection part (= X) and list part (= y). |
| links indicates connection part of CPU side (= A). |
| |
| +-+ (A) +-+ |
| CPU1 --(y) | | <-(X)--(X)-> | | (y)-- Codec1 |
| CPU2 --(y) | | | | (y)-- Codec2 |
| +-+ +-+ |
| |
| sound { |
| compatible = "audio-graph-card2"; |
| |
| (A) links = <&mcpu>; |
| |
| multi { |
| ports@0 { |
| (X) (A) mcpu: port@0 { mcpu0_ep: endpoint { remote-endpoint = <&mcodec0_ep>; }; }; |
| (y) port@1 { mcpu1_ep: endpoint { remote-endpoint = <&cpu1_ep>; }; }; |
| (y) port@1 { mcpu2_ep: endpoint { remote-endpoint = <&cpu2_ep>; }; }; |
| }; |
| ports@1 { |
| (X) port@0 { mcodec0_ep: endpoint { remote-endpoint = <&mcpu0_ep>; }; }; |
| (y) port@0 { mcodec1_ep: endpoint { remote-endpoint = <&codec1_ep>; }; }; |
| (y) port@1 { mcodec2_ep: endpoint { remote-endpoint = <&codec2_ep>; }; }; |
| }; |
| }; |
| }; |
| |
| CPU { |
| ports { |
| bitclock-master; |
| frame-master; |
| port@0 { cpu1_ep: endpoint { remote-endpoint = <&mcpu1_ep>; }; }; |
| port@1 { cpu2_ep: endpoint { remote-endpoint = <&mcpu2_ep>; }; }; |
| }; |
| }; |
| |
| Codec { |
| ports { |
| port@0 { codec1_ep: endpoint { remote-endpoint = <&mcodec1_ep>; }; }; |
| port@1 { codec2_ep: endpoint { remote-endpoint = <&mcodec2_ep>; }; }; |
| }; |
| }; |
| |
| ************************************ |
| DPCM |
| ************************************ |
| |
| DSP |
| ************ |
| PCM0 <--> * fe0 be0 * <--> DAI0: Codec Headset |
| PCM1 <--> * fe1 be1 * <--> DAI1: Codec Speakers |
| PCM2 <--> * fe2 be2 * <--> DAI2: MODEM |
| PCM3 <--> * fe3 be3 * <--> DAI3: BT |
| * be4 * <--> DAI4: DMIC |
| * be5 * <--> DAI5: FM |
| ************ |
| |
| sound { |
| compatible = "audio-graph-card2"; |
| |
| // indicate routing |
| routing = "xxx Playback", "xxx Playback", |
| "xxx Playback", "xxx Playback", |
| "xxx Playback", "xxx Playback"; |
| |
| // indicate all Front-End, Back-End |
| links = <&fe0, &fe1, ..., |
| &be0, &be1, ...>; |
| |
| dpcm { |
| // Front-End |
| ports@0 { |
| fe0: port@0 { fe0_ep: endpoint { remote-endpoint = <&pcm0_ep>; }; }; |
| fe1: port@1 { fe1_ep: endpoint { remote-endpoint = <&pcm1_ep>; }; }; |
| ... |
| }; |
| // Back-End |
| ports@1 { |
| be0: port@0 { be0_ep: endpoint { remote-endpoint = <&dai0_ep>; }; }; |
| be1: port@1 { be1_ep: endpoint { remote-endpoint = <&dai1_ep>; }; }; |
| ... |
| }; |
| }; |
| }; |
| |
| CPU { |
| ports { |
| bitclock-master; |
| frame-master; |
| port@0 { pcm0_ep: endpoint { remote-endpoint = <&fe0_ep>; }; }; |
| port@1 { pcm1_ep: endpoint { remote-endpoint = <&fe1_ep>; }; }; |
| ... |
| }; |
| }; |
| |
| Codec { |
| ports { |
| port@0 { dai0_ep: endpoint { remote-endpoint = <&be0_ep>; }; }; |
| port@1 { dai1_ep: endpoint { remote-endpoint = <&be1_ep>; }; }; |
| ... |
| }; |
| }; |
| |
| ************************************ |
| Codec to Codec |
| ************************************ |
| |
| +--+ |
| | |<-- Codec0 <- IN |
| | |--> Codec1 -> OUT |
| +--+ |
| |
| sound { |
| compatible = "audio-graph-card2"; |
| |
| routing = "OUT" ,"DAI1 Playback", |
| "DAI0 Capture", "IN"; |
| |
| links = <&c2c>; |
| |
| codec2codec { |
| ports { |
| rate = <48000>; |
| c2c: port@0 { c2cf_ep: endpoint { remote-endpoint = <&codec0_ep>; }; }; |
| port@1 { c2cb_ep: endpoint { remote-endpoint = <&codec1_ep>; }; }; |
| }; |
| }; |
| |
| Codec { |
| ports { |
| port@0 { |
| bitclock-master; |
| frame-master; |
| codec0_ep: endpoint { remote-endpoint = <&c2cf_ep>; }; }; |
| port@1 { codec1_ep: endpoint { remote-endpoint = <&c2cb_ep>; }; }; |
| }; |
| }; |
| |
| */ |
| |
| enum graph_type { |
| GRAPH_NORMAL, |
| GRAPH_DPCM, |
| GRAPH_C2C, |
| |
| GRAPH_MULTI, /* don't use ! Use this only in __graph_get_type() */ |
| }; |
| |
| #define GRAPH_NODENAME_MULTI "multi" |
| #define GRAPH_NODENAME_DPCM "dpcm" |
| #define GRAPH_NODENAME_C2C "codec2codec" |
| |
| #define port_to_endpoint(port) of_get_child_by_name(port, "endpoint") |
| |
| static enum graph_type __graph_get_type(struct device_node *lnk) |
| { |
| struct device_node *np; |
| |
| /* |
| * target { |
| * ports { |
| * => lnk: port@0 { ... }; |
| * port@1 { ... }; |
| * }; |
| * }; |
| */ |
| np = of_get_parent(lnk); |
| if (of_node_name_eq(np, "ports")) |
| np = of_get_parent(np); |
| |
| if (of_node_name_eq(np, GRAPH_NODENAME_MULTI)) |
| return GRAPH_MULTI; |
| |
| if (of_node_name_eq(np, GRAPH_NODENAME_DPCM)) |
| return GRAPH_DPCM; |
| |
| if (of_node_name_eq(np, GRAPH_NODENAME_C2C)) |
| return GRAPH_C2C; |
| |
| return GRAPH_NORMAL; |
| } |
| |
| static enum graph_type graph_get_type(struct asoc_simple_priv *priv, |
| struct device_node *lnk) |
| { |
| enum graph_type type = __graph_get_type(lnk); |
| |
| /* GRAPH_MULTI here means GRAPH_NORMAL */ |
| if (type == GRAPH_MULTI) |
| type = GRAPH_NORMAL; |
| |
| #ifdef DEBUG |
| { |
| struct device *dev = simple_priv_to_dev(priv); |
| const char *str = "Normal"; |
| |
| switch (type) { |
| case GRAPH_DPCM: |
| if (asoc_graph_is_ports0(lnk)) |
| str = "DPCM Front-End"; |
| else |
| str = "DPCM Back-End"; |
| break; |
| case GRAPH_C2C: |
| str = "Codec2Codec"; |
| break; |
| default: |
| break; |
| } |
| |
| dev_dbg(dev, "%pOF (%s)", lnk, str); |
| } |
| #endif |
| return type; |
| } |
| |
| static int graph_lnk_is_multi(struct device_node *lnk) |
| { |
| return __graph_get_type(lnk) == GRAPH_MULTI; |
| } |
| |
| static struct device_node *graph_get_next_multi_ep(struct device_node **port) |
| { |
| struct device_node *ports = of_get_parent(*port); |
| struct device_node *ep = NULL; |
| struct device_node *rep = NULL; |
| |
| /* |
| * multi { |
| * ports { |
| * => lnk: port@0 { ... }; |
| * port@1 { ep { ... = rep0 } }; |
| * port@2 { ep { ... = rep1 } }; |
| * ... |
| * }; |
| * }; |
| * |
| * xxx { |
| * port@0 { rep0 }; |
| * port@1 { rep1 }; |
| * }; |
| */ |
| do { |
| *port = of_get_next_child(ports, *port); |
| if (!*port) |
| break; |
| } while (!of_node_name_eq(*port, "port")); |
| |
| if (*port) { |
| ep = port_to_endpoint(*port); |
| rep = of_graph_get_remote_endpoint(ep); |
| } |
| |
| of_node_put(ep); |
| of_node_put(ports); |
| |
| return rep; |
| } |
| |
| static const struct snd_soc_ops graph_ops = { |
| .startup = asoc_simple_startup, |
| .shutdown = asoc_simple_shutdown, |
| .hw_params = asoc_simple_hw_params, |
| }; |
| |
| static int graph_get_dai_id(struct device_node *ep) |
| { |
| struct device_node *node; |
| struct device_node *endpoint; |
| struct of_endpoint info; |
| int i, id; |
| const u32 *reg; |
| int ret; |
| |
| /* use driver specified DAI ID if exist */ |
| ret = snd_soc_get_dai_id(ep); |
| if (ret != -ENOTSUPP) |
| return ret; |
| |
| /* use endpoint/port reg if exist */ |
| ret = of_graph_parse_endpoint(ep, &info); |
| if (ret == 0) { |
| /* |
| * Because it will count port/endpoint if it doesn't have "reg". |
| * But, we can't judge whether it has "no reg", or "reg = <0>" |
| * only of_graph_parse_endpoint(). |
| * We need to check "reg" property |
| */ |
| if (of_get_property(ep, "reg", NULL)) |
| return info.id; |
| |
| node = of_get_parent(ep); |
| reg = of_get_property(node, "reg", NULL); |
| of_node_put(node); |
| if (reg) |
| return info.port; |
| } |
| node = of_graph_get_port_parent(ep); |
| |
| /* |
| * Non HDMI sound case, counting port/endpoint on its DT |
| * is enough. Let's count it. |
| */ |
| i = 0; |
| id = -1; |
| for_each_endpoint_of_node(node, endpoint) { |
| if (endpoint == ep) |
| id = i; |
| i++; |
| } |
| |
| of_node_put(node); |
| |
| if (id < 0) |
| return -ENODEV; |
| |
| return id; |
| } |
| |
| static int asoc_simple_parse_dai(struct device_node *ep, |
| struct snd_soc_dai_link_component *dlc, |
| int *is_single_link) |
| { |
| struct device_node *node; |
| struct of_phandle_args args; |
| int ret; |
| |
| if (!ep) |
| return 0; |
| |
| node = of_graph_get_port_parent(ep); |
| |
| /* Get dai->name */ |
| args.np = node; |
| args.args[0] = graph_get_dai_id(ep); |
| args.args_count = (of_graph_get_endpoint_count(node) > 1); |
| |
| /* |
| * FIXME |
| * |
| * Here, dlc->dai_name is pointer to CPU/Codec DAI name. |
| * If user unbinded CPU or Codec driver, but not for Sound Card, |
| * dlc->dai_name is keeping unbinded CPU or Codec |
| * driver's pointer. |
| * |
| * If user re-bind CPU or Codec driver again, ALSA SoC will try |
| * to rebind Card via snd_soc_try_rebind_card(), but because of |
| * above reason, it might can't bind Sound Card. |
| * Because Sound Card is pointing to released dai_name pointer. |
| * |
| * To avoid this rebind Card issue, |
| * 1) It needs to alloc memory to keep dai_name eventhough |
| * CPU or Codec driver was unbinded, or |
| * 2) user need to rebind Sound Card everytime |
| * if he unbinded CPU or Codec. |
| */ |
| ret = snd_soc_get_dai_name(&args, &dlc->dai_name); |
| if (ret < 0) |
| return ret; |
| |
| dlc->of_node = node; |
| |
| if (is_single_link) |
| *is_single_link = of_graph_get_endpoint_count(node) == 1; |
| |
| return 0; |
| } |
| |
| static void graph_parse_convert(struct device_node *ep, |
| struct simple_dai_props *props) |
| { |
| struct device_node *port = of_get_parent(ep); |
| struct device_node *ports = of_get_parent(port); |
| struct asoc_simple_data *adata = &props->adata; |
| |
| if (of_node_name_eq(ports, "ports")) |
| asoc_simple_parse_convert(ports, NULL, adata); |
| asoc_simple_parse_convert(port, NULL, adata); |
| asoc_simple_parse_convert(ep, NULL, adata); |
| |
| of_node_put(port); |
| of_node_put(ports); |
| } |
| |
| static void graph_parse_mclk_fs(struct device_node *ep, |
| struct simple_dai_props *props) |
| { |
| struct device_node *port = of_get_parent(ep); |
| struct device_node *ports = of_get_parent(port); |
| |
| if (of_node_name_eq(ports, "ports")) |
| of_property_read_u32(ports, "mclk-fs", &props->mclk_fs); |
| of_property_read_u32(port, "mclk-fs", &props->mclk_fs); |
| of_property_read_u32(ep, "mclk-fs", &props->mclk_fs); |
| |
| of_node_put(port); |
| of_node_put(ports); |
| } |
| |
| static int __graph_parse_node(struct asoc_simple_priv *priv, |
| enum graph_type gtype, |
| struct device_node *ep, |
| struct link_info *li, |
| int is_cpu, int idx) |
| { |
| struct device *dev = simple_priv_to_dev(priv); |
| struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); |
| struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); |
| struct snd_soc_dai_link_component *dlc; |
| struct asoc_simple_dai *dai; |
| int ret, is_single_links = 0; |
| |
| if (is_cpu) { |
| dlc = asoc_link_to_cpu(dai_link, idx); |
| dai = simple_props_to_dai_cpu(dai_props, idx); |
| } else { |
| dlc = asoc_link_to_codec(dai_link, idx); |
| dai = simple_props_to_dai_codec(dai_props, idx); |
| } |
| |
| graph_parse_mclk_fs(ep, dai_props); |
| |
| ret = asoc_simple_parse_dai(ep, dlc, &is_single_links); |
| if (ret < 0) |
| return ret; |
| |
| ret = asoc_simple_parse_tdm(ep, dai); |
| if (ret < 0) |
| return ret; |
| |
| ret = asoc_simple_parse_tdm_width_map(dev, ep, dai); |
| if (ret < 0) |
| return ret; |
| |
| ret = asoc_simple_parse_clk(dev, ep, dai, dlc); |
| if (ret < 0) |
| return ret; |
| |
| /* |
| * set DAI Name |
| */ |
| if (!dai_link->name) { |
| struct snd_soc_dai_link_component *cpus = dlc; |
| struct snd_soc_dai_link_component *codecs = asoc_link_to_codec(dai_link, idx); |
| char *cpu_multi = ""; |
| char *codec_multi = ""; |
| |
| if (dai_link->num_cpus > 1) |
| cpu_multi = "_multi"; |
| if (dai_link->num_codecs > 1) |
| codec_multi = "_multi"; |
| |
| switch (gtype) { |
| case GRAPH_NORMAL: |
| /* run is_cpu only. see audio_graph2_link_normal() */ |
| if (is_cpu) |
| asoc_simple_set_dailink_name(dev, dai_link, "%s%s-%s%s", |
| cpus->dai_name, cpu_multi, |
| codecs->dai_name, codec_multi); |
| break; |
| case GRAPH_DPCM: |
| if (is_cpu) |
| asoc_simple_set_dailink_name(dev, dai_link, "fe.%pOFP.%s%s", |
| cpus->of_node, cpus->dai_name, cpu_multi); |
| else |
| asoc_simple_set_dailink_name(dev, dai_link, "be.%pOFP.%s%s", |
| codecs->of_node, codecs->dai_name, codec_multi); |
| break; |
| case GRAPH_C2C: |
| /* run is_cpu only. see audio_graph2_link_c2c() */ |
| if (is_cpu) |
| asoc_simple_set_dailink_name(dev, dai_link, "c2c.%s%s-%s%s", |
| cpus->dai_name, cpu_multi, |
| codecs->dai_name, codec_multi); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /* |
| * Check "prefix" from top node |
| * if DPCM-BE case |
| */ |
| if (!is_cpu && gtype == GRAPH_DPCM) { |
| struct snd_soc_dai_link_component *codecs = asoc_link_to_codec(dai_link, idx); |
| struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, idx); |
| struct device_node *rport = of_get_parent(ep); |
| struct device_node *rports = of_get_parent(rport); |
| |
| if (of_node_name_eq(rports, "ports")) |
| snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix"); |
| snd_soc_of_parse_node_prefix(rport, cconf, codecs->of_node, "prefix"); |
| |
| of_node_put(rport); |
| of_node_put(rports); |
| } |
| |
| if (is_cpu) { |
| struct snd_soc_dai_link_component *cpus = dlc; |
| struct snd_soc_dai_link_component *platforms = asoc_link_to_platform(dai_link, idx); |
| |
| asoc_simple_canonicalize_cpu(cpus, is_single_links); |
| asoc_simple_canonicalize_platform(platforms, cpus); |
| } |
| |
| return 0; |
| } |
| |
| static int graph_parse_node(struct asoc_simple_priv *priv, |
| enum graph_type gtype, |
| struct device_node *port, |
| struct link_info *li, int is_cpu) |
| { |
| struct device_node *ep; |
| int ret = 0; |
| |
| if (graph_lnk_is_multi(port)) { |
| int idx; |
| |
| of_node_get(port); |
| |
| for (idx = 0;; idx++) { |
| ep = graph_get_next_multi_ep(&port); |
| if (!ep) |
| break; |
| |
| ret = __graph_parse_node(priv, gtype, ep, |
| li, is_cpu, idx); |
| of_node_put(ep); |
| if (ret < 0) |
| break; |
| } |
| } else { |
| /* Single CPU / Codec */ |
| ep = port_to_endpoint(port); |
| ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, 0); |
| of_node_put(ep); |
| } |
| |
| return ret; |
| } |
| |
| static void graph_parse_daifmt(struct device_node *node, |
| unsigned int *daifmt, unsigned int *bit_frame) |
| { |
| unsigned int fmt; |
| |
| /* |
| * see also above "daifmt" explanation |
| * and samples. |
| */ |
| |
| /* |
| * ports { |
| * (A) |
| * port { |
| * (B) |
| * endpoint { |
| * (C) |
| * }; |
| * }; |
| * }; |
| * }; |
| */ |
| |
| /* |
| * clock_provider: |
| * |
| * It can be judged it is provider |
| * if (A) or (B) or (C) has bitclock-master / frame-master flag. |
| * |
| * use "or" |
| */ |
| *bit_frame |= snd_soc_daifmt_parse_clock_provider_as_bitmap(node, NULL); |
| |
| #define update_daifmt(name) \ |
| if (!(*daifmt & SND_SOC_DAIFMT_##name##_MASK) && \ |
| (fmt & SND_SOC_DAIFMT_##name##_MASK)) \ |
| *daifmt |= fmt & SND_SOC_DAIFMT_##name##_MASK |
| |
| /* |
| * format |
| * |
| * This function is called by (C) -> (B) -> (A) order. |
| * Set if applicable part was not yet set. |
| */ |
| fmt = snd_soc_daifmt_parse_format(node, NULL); |
| update_daifmt(FORMAT); |
| update_daifmt(CLOCK); |
| update_daifmt(INV); |
| } |
| |
| static void graph_link_init(struct asoc_simple_priv *priv, |
| struct device_node *port, |
| struct link_info *li, |
| int is_cpu_node) |
| { |
| struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); |
| struct device_node *ep; |
| struct device_node *ports; |
| unsigned int daifmt = 0, daiclk = 0; |
| unsigned int bit_frame = 0; |
| |
| if (graph_lnk_is_multi(port)) { |
| of_node_get(port); |
| ep = graph_get_next_multi_ep(&port); |
| port = of_get_parent(ep); |
| } else { |
| ep = port_to_endpoint(port); |
| } |
| |
| ports = of_get_parent(port); |
| |
| /* |
| * ports { |
| * (A) |
| * port { |
| * (B) |
| * endpoint { |
| * (C) |
| * }; |
| * }; |
| * }; |
| * }; |
| */ |
| graph_parse_daifmt(ep, &daifmt, &bit_frame); /* (C) */ |
| graph_parse_daifmt(port, &daifmt, &bit_frame); /* (B) */ |
| if (of_node_name_eq(ports, "ports")) |
| graph_parse_daifmt(ports, &daifmt, &bit_frame); /* (A) */ |
| |
| /* |
| * convert bit_frame |
| * We need to flip clock_provider if it was CPU node, |
| * because it is Codec base. |
| */ |
| daiclk = snd_soc_daifmt_clock_provider_from_bitmap(bit_frame); |
| if (is_cpu_node) |
| daiclk = snd_soc_daifmt_clock_provider_flipped(daiclk); |
| |
| dai_link->dai_fmt = daifmt | daiclk; |
| dai_link->init = asoc_simple_dai_init; |
| dai_link->ops = &graph_ops; |
| if (priv->ops) |
| dai_link->ops = priv->ops; |
| } |
| |
| int audio_graph2_link_normal(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device_node *cpu_port = lnk; |
| struct device_node *cpu_ep = port_to_endpoint(cpu_port); |
| struct device_node *codec_port = of_graph_get_remote_port(cpu_ep); |
| int ret; |
| |
| /* |
| * call Codec first. |
| * see |
| * __graph_parse_node() :: DAI Naming |
| */ |
| ret = graph_parse_node(priv, GRAPH_NORMAL, codec_port, li, 0); |
| if (ret < 0) |
| goto err; |
| |
| /* |
| * call CPU, and set DAI Name |
| */ |
| ret = graph_parse_node(priv, GRAPH_NORMAL, cpu_port, li, 1); |
| if (ret < 0) |
| goto err; |
| |
| graph_link_init(priv, cpu_port, li, 1); |
| err: |
| of_node_put(codec_port); |
| of_node_put(cpu_ep); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL_GPL(audio_graph2_link_normal); |
| |
| int audio_graph2_link_dpcm(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device_node *ep = port_to_endpoint(lnk); |
| struct device_node *rep = of_graph_get_remote_endpoint(ep); |
| struct device_node *rport = of_graph_get_remote_port(ep); |
| struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); |
| struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); |
| int is_cpu = asoc_graph_is_ports0(lnk); |
| int ret; |
| |
| if (is_cpu) { |
| /* |
| * dpcm { |
| * // Front-End |
| * ports@0 { |
| * => lnk: port@0 { ep: { ... = rep }; }; |
| * ... |
| * }; |
| * // Back-End |
| * ports@0 { |
| * ... |
| * }; |
| * }; |
| * |
| * CPU { |
| * rports: ports { |
| * rport: port@0 { rep: { ... = ep } }; |
| * } |
| * } |
| */ |
| /* |
| * setup CPU here, Codec is already set as dummy. |
| * see |
| * asoc_simple_init_priv() |
| */ |
| dai_link->dynamic = 1; |
| dai_link->dpcm_merged_format = 1; |
| |
| ret = graph_parse_node(priv, GRAPH_DPCM, rport, li, 1); |
| if (ret) |
| goto err; |
| } else { |
| /* |
| * dpcm { |
| * // Front-End |
| * ports@0 { |
| * ... |
| * }; |
| * // Back-End |
| * ports@0 { |
| * => lnk: port@0 { ep: { ... = rep; }; }; |
| * ... |
| * }; |
| * }; |
| * |
| * Codec { |
| * rports: ports { |
| * rport: port@0 { rep: { ... = ep; }; }; |
| * } |
| * } |
| */ |
| /* |
| * setup Codec here, CPU is already set as dummy. |
| * see |
| * asoc_simple_init_priv() |
| */ |
| |
| /* BE settings */ |
| dai_link->no_pcm = 1; |
| dai_link->be_hw_params_fixup = asoc_simple_be_hw_params_fixup; |
| |
| ret = graph_parse_node(priv, GRAPH_DPCM, rport, li, 0); |
| if (ret < 0) |
| goto err; |
| } |
| |
| graph_parse_convert(rep, dai_props); |
| |
| snd_soc_dai_link_set_capabilities(dai_link); |
| |
| graph_link_init(priv, rport, li, is_cpu); |
| err: |
| of_node_put(ep); |
| of_node_put(rep); |
| of_node_put(rport); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL_GPL(audio_graph2_link_dpcm); |
| |
| int audio_graph2_link_c2c(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); |
| struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); |
| struct snd_soc_pcm_stream *c2c_conf = dai_props->c2c_conf; |
| struct device_node *port0, *port1, *ports; |
| struct device_node *codec0_port, *codec1_port; |
| struct device_node *ep0, *ep1; |
| u32 val; |
| int ret = -EINVAL; |
| |
| /* |
| * codec2codec { |
| * ports { |
| * rate = <48000>; |
| * => lnk: port@0 { c2c0_ep: { ... = codec0_ep; }; }; |
| * port@1 { c2c1_ep: { ... = codec1_ep; }; }; |
| * }; |
| * }; |
| * |
| * Codec { |
| * ports { |
| * port@0 { codec0_ep: ... }; }; |
| * port@1 { codec1_ep: ... }; }; |
| * }; |
| * }; |
| */ |
| of_node_get(lnk); |
| port0 = lnk; |
| ports = of_get_parent(port0); |
| port1 = of_get_next_child(ports, lnk); |
| |
| if (!of_get_property(ports, "rate", &val)) { |
| struct device *dev = simple_priv_to_dev(priv); |
| |
| dev_err(dev, "Codec2Codec needs rate settings\n"); |
| goto err1; |
| } |
| |
| c2c_conf->formats = SNDRV_PCM_FMTBIT_S32_LE; /* update ME */ |
| c2c_conf->rate_min = |
| c2c_conf->rate_max = val; |
| c2c_conf->channels_min = |
| c2c_conf->channels_max = 2; /* update ME */ |
| dai_link->params = c2c_conf; |
| |
| ep0 = port_to_endpoint(port0); |
| ep1 = port_to_endpoint(port1); |
| |
| codec0_port = of_graph_get_remote_port(ep0); |
| codec1_port = of_graph_get_remote_port(ep1); |
| |
| /* |
| * call Codec first. |
| * see |
| * __graph_parse_node() :: DAI Naming |
| */ |
| ret = graph_parse_node(priv, GRAPH_C2C, codec1_port, li, 0); |
| if (ret < 0) |
| goto err2; |
| |
| /* |
| * call CPU, and set DAI Name |
| */ |
| ret = graph_parse_node(priv, GRAPH_C2C, codec0_port, li, 1); |
| if (ret < 0) |
| goto err2; |
| |
| graph_link_init(priv, codec0_port, li, 1); |
| err2: |
| of_node_put(ep0); |
| of_node_put(ep1); |
| of_node_put(codec0_port); |
| of_node_put(codec1_port); |
| err1: |
| of_node_put(ports); |
| of_node_put(port0); |
| of_node_put(port1); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL_GPL(audio_graph2_link_c2c); |
| |
| static int graph_link(struct asoc_simple_priv *priv, |
| struct graph2_custom_hooks *hooks, |
| enum graph_type gtype, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device *dev = simple_priv_to_dev(priv); |
| GRAPH2_CUSTOM func = NULL; |
| int ret = -EINVAL; |
| |
| switch (gtype) { |
| case GRAPH_NORMAL: |
| if (hooks && hooks->custom_normal) |
| func = hooks->custom_normal; |
| else |
| func = audio_graph2_link_normal; |
| break; |
| case GRAPH_DPCM: |
| if (hooks && hooks->custom_dpcm) |
| func = hooks->custom_dpcm; |
| else |
| func = audio_graph2_link_dpcm; |
| break; |
| case GRAPH_C2C: |
| if (hooks && hooks->custom_c2c) |
| func = hooks->custom_c2c; |
| else |
| func = audio_graph2_link_c2c; |
| break; |
| default: |
| break; |
| } |
| |
| if (!func) { |
| dev_err(dev, "non supported gtype (%d)\n", gtype); |
| goto err; |
| } |
| |
| ret = func(priv, lnk, li); |
| if (ret < 0) |
| goto err; |
| |
| li->link++; |
| err: |
| return ret; |
| } |
| |
| static int graph_counter(struct device_node *lnk) |
| { |
| /* |
| * Multi CPU / Codec |
| * |
| * multi { |
| * ports { |
| * => lnk: port@0 { ... }; |
| * port@1 { ... }; |
| * port@2 { ... }; |
| * ... |
| * }; |
| * }; |
| * |
| * ignore first lnk part |
| */ |
| if (graph_lnk_is_multi(lnk)) |
| return of_graph_get_endpoint_count(of_get_parent(lnk)) - 1; |
| /* |
| * Single CPU / Codec |
| */ |
| else |
| return 1; |
| } |
| |
| static int graph_count_normal(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device_node *cpu_port = lnk; |
| struct device_node *cpu_ep = port_to_endpoint(cpu_port); |
| struct device_node *codec_port = of_graph_get_remote_port(cpu_ep); |
| |
| /* |
| * CPU { |
| * => lnk: port { endpoint { .. }; }; |
| * }; |
| */ |
| li->num[li->link].cpus = |
| li->num[li->link].platforms = graph_counter(cpu_port); |
| li->num[li->link].codecs = graph_counter(codec_port); |
| |
| of_node_put(cpu_ep); |
| of_node_put(codec_port); |
| |
| return 0; |
| } |
| |
| static int graph_count_dpcm(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device_node *ep = port_to_endpoint(lnk); |
| struct device_node *rport = of_graph_get_remote_port(ep); |
| |
| /* |
| * dpcm { |
| * // Front-End |
| * ports@0 { |
| * => lnk: port@0 { endpoint { ... }; }; |
| * ... |
| * }; |
| * // Back-End |
| * ports@1 { |
| * => lnk: port@0 { endpoint { ... }; }; |
| * ... |
| * }; |
| * }; |
| */ |
| |
| if (asoc_graph_is_ports0(lnk)) { |
| li->num[li->link].cpus = graph_counter(rport); /* FE */ |
| li->num[li->link].platforms = graph_counter(rport); |
| } else { |
| li->num[li->link].codecs = graph_counter(rport); /* BE */ |
| } |
| |
| of_node_put(ep); |
| of_node_put(rport); |
| |
| return 0; |
| } |
| |
| static int graph_count_c2c(struct asoc_simple_priv *priv, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device_node *ports = of_get_parent(lnk); |
| struct device_node *port0 = lnk; |
| struct device_node *port1 = of_get_next_child(ports, lnk); |
| struct device_node *ep0 = port_to_endpoint(port0); |
| struct device_node *ep1 = port_to_endpoint(port1); |
| struct device_node *codec0 = of_graph_get_remote_port(ep0); |
| struct device_node *codec1 = of_graph_get_remote_port(ep1); |
| |
| of_node_get(lnk); |
| |
| /* |
| * codec2codec { |
| * ports { |
| * => lnk: port@0 { endpoint { ... }; }; |
| * port@1 { endpoint { ... }; }; |
| * }; |
| * }; |
| */ |
| li->num[li->link].cpus = |
| li->num[li->link].platforms = graph_counter(codec0); |
| li->num[li->link].codecs = graph_counter(codec1); |
| li->num[li->link].c2c = 1; |
| |
| of_node_put(ports); |
| of_node_put(port1); |
| of_node_put(ep0); |
| of_node_put(ep1); |
| of_node_put(codec0); |
| of_node_put(codec1); |
| |
| return 0; |
| } |
| |
| static int graph_count(struct asoc_simple_priv *priv, |
| struct graph2_custom_hooks *hooks, |
| enum graph_type gtype, |
| struct device_node *lnk, |
| struct link_info *li) |
| { |
| struct device *dev = simple_priv_to_dev(priv); |
| GRAPH2_CUSTOM func = NULL; |
| int ret = -EINVAL; |
| |
| if (li->link >= SNDRV_MAX_LINKS) { |
| dev_err(dev, "too many links\n"); |
| return ret; |
| } |
| |
| switch (gtype) { |
| case GRAPH_NORMAL: |
| func = graph_count_normal; |
| break; |
| case GRAPH_DPCM: |
| func = graph_count_dpcm; |
| break; |
| case GRAPH_C2C: |
| func = graph_count_c2c; |
| break; |
| default: |
| break; |
| } |
| |
| if (!func) { |
| dev_err(dev, "non supported gtype (%d)\n", gtype); |
| goto err; |
| } |
| |
| ret = func(priv, lnk, li); |
| if (ret < 0) |
| goto err; |
| |
| li->link++; |
| err: |
| return ret; |
| } |
| |
| static int graph_for_each_link(struct asoc_simple_priv *priv, |
| struct graph2_custom_hooks *hooks, |
| struct link_info *li, |
| int (*func)(struct asoc_simple_priv *priv, |
| struct graph2_custom_hooks *hooks, |
| enum graph_type gtype, |
| struct device_node *lnk, |
| struct link_info *li)) |
| { |
| struct of_phandle_iterator it; |
| struct device *dev = simple_priv_to_dev(priv); |
| struct device_node *node = dev->of_node; |
| struct device_node *lnk; |
| enum graph_type gtype; |
| int rc, ret; |
| |
| /* loop for all listed CPU port */ |
| of_for_each_phandle(&it, rc, node, "links", NULL, 0) { |
| lnk = it.node; |
| |
| gtype = graph_get_type(priv, lnk); |
| |
| ret = func(priv, hooks, gtype, lnk, li); |
| if (ret < 0) |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| int audio_graph2_parse_of(struct asoc_simple_priv *priv, struct device *dev, |
| struct graph2_custom_hooks *hooks) |
| { |
| struct snd_soc_card *card = simple_priv_to_card(priv); |
| struct link_info *li; |
| int ret; |
| |
| li = devm_kzalloc(dev, sizeof(*li), GFP_KERNEL); |
| if (!li) |
| return -ENOMEM; |
| |
| card->probe = asoc_graph_card_probe; |
| card->owner = THIS_MODULE; |
| card->dev = dev; |
| |
| if ((hooks) && (hooks)->hook_pre) { |
| ret = (hooks)->hook_pre(priv); |
| if (ret < 0) |
| goto err; |
| } |
| |
| ret = graph_for_each_link(priv, hooks, li, graph_count); |
| if (!li->link) |
| ret = -EINVAL; |
| if (ret < 0) |
| goto err; |
| |
| ret = asoc_simple_init_priv(priv, li); |
| if (ret < 0) |
| goto err; |
| |
| priv->pa_gpio = devm_gpiod_get_optional(dev, "pa", GPIOD_OUT_LOW); |
| if (IS_ERR(priv->pa_gpio)) { |
| ret = PTR_ERR(priv->pa_gpio); |
| dev_err(dev, "failed to get amplifier gpio: %d\n", ret); |
| goto err; |
| } |
| |
| ret = asoc_simple_parse_widgets(card, NULL); |
| if (ret < 0) |
| goto err; |
| |
| ret = asoc_simple_parse_routing(card, NULL); |
| if (ret < 0) |
| goto err; |
| |
| memset(li, 0, sizeof(*li)); |
| ret = graph_for_each_link(priv, hooks, li, graph_link); |
| if (ret < 0) |
| goto err; |
| |
| ret = asoc_simple_parse_card_name(card, NULL); |
| if (ret < 0) |
| goto err; |
| |
| snd_soc_card_set_drvdata(card, priv); |
| |
| if ((hooks) && (hooks)->hook_post) { |
| ret = (hooks)->hook_post(priv); |
| if (ret < 0) |
| goto err; |
| } |
| |
| asoc_simple_debug_info(priv); |
| |
| ret = devm_snd_soc_register_card(dev, card); |
| err: |
| devm_kfree(dev, li); |
| |
| if (ret < 0) |
| dev_err_probe(dev, ret, "parse error\n"); |
| |
| if (ret == 0) |
| dev_warn(dev, "Audio Graph Card2 is still under Experimental stage\n"); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL_GPL(audio_graph2_parse_of); |
| |
| static int graph_probe(struct platform_device *pdev) |
| { |
| struct asoc_simple_priv *priv; |
| struct device *dev = &pdev->dev; |
| |
| /* Allocate the private data and the DAI link array */ |
| priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); |
| if (!priv) |
| return -ENOMEM; |
| |
| return audio_graph2_parse_of(priv, dev, NULL); |
| } |
| |
| static const struct of_device_id graph_of_match[] = { |
| { .compatible = "audio-graph-card2", }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, graph_of_match); |
| |
| static struct platform_driver graph_card = { |
| .driver = { |
| .name = "asoc-audio-graph-card2", |
| .pm = &snd_soc_pm_ops, |
| .of_match_table = graph_of_match, |
| }, |
| .probe = graph_probe, |
| .remove = asoc_simple_remove, |
| }; |
| module_platform_driver(graph_card); |
| |
| MODULE_ALIAS("platform:asoc-audio-graph-card2"); |
| MODULE_LICENSE("GPL v2"); |
| MODULE_DESCRIPTION("ASoC Audio Graph Card2"); |
| MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); |