[U-Boot] [PATCH 21/33] sound: Add support for Intel HDA
Bin Meng
bmeng.cn at gmail.com
Wed Feb 13 09:39:03 UTC 2019
Hi Simon,
On Tue, Jan 22, 2019 at 9:14 AM Simon Glass <sjg at chromium.org> wrote:
>
> The Intel High-definition Audio is a newer-generation audio system which
> provides for transfer of a large number of audio stream, each containing
> up to 16 channels.
>
> Add support for HDA as a library which can be used by other drivers.
> U-Boot currently uses only two channels (stereo).
>
I don't have knowledge about Intel HDA, just provide some general
comments below.
> Signed-off-by: Simon Glass <sjg at chromium.org>
> ---
>
> doc/device-tree-bindings/sound/intel-hda.txt | 26 +
> drivers/sound/Kconfig | 9 +
> drivers/sound/Makefile | 1 +
> drivers/sound/hda_codec.c | 545 +++++++++++++++++++
> include/dt-bindings/sound/azalia.h | 29 +
> include/hda_codec.h | 103 ++++
> 6 files changed, 713 insertions(+)
> create mode 100644 doc/device-tree-bindings/sound/intel-hda.txt
> create mode 100644 drivers/sound/hda_codec.c
> create mode 100644 include/dt-bindings/sound/azalia.h
> create mode 100644 include/hda_codec.h
>
> diff --git a/doc/device-tree-bindings/sound/intel-hda.txt b/doc/device-tree-bindings/sound/intel-hda.txt
> new file mode 100644
> index 0000000000..16eb1cf133
> --- /dev/null
> +++ b/doc/device-tree-bindings/sound/intel-hda.txt
> @@ -0,0 +1,26 @@
> +* Intel High-definition Audio
> +
> +Configuration is set using 'verbs' which are blocks of 16 bytes of data each
> +with a different purpose, a little like a simple instruction set.
> +
> +Top-level node
> +--------------
> +
> +Required properties:
> +- compatible: "intel,bd82x6x-hda"
It looks to me the Intel HDA is a well defined specification, is it
possible to specify a generic name here something like "intel,hda" or
"intel,hd-audio"?
> +- beep-verbs: list of verbs to send for a beep
> +
> +Optional properties
> +- intel,beep-nid: Node ID to use for beep (will be detected if not provided)
> +
> +Required subnodes:
> +- codecs: Contains a list of codec nodes
> +
> +
> +* Codec nodes
> +
> +Required properties:
> +- vendor-id: 16-bit vendor ID for audio codec
> +- device-id: 16-bit device ID for audio codec
> +- verbs: List of verbs, each 4 cells in length
> +
> diff --git a/drivers/sound/Kconfig b/drivers/sound/Kconfig
> index 506a60a7c7..a03d3057e1 100644
> --- a/drivers/sound/Kconfig
> +++ b/drivers/sound/Kconfig
> @@ -31,6 +31,15 @@ config I2S_SAMSUNG
> option provides an implementation for sound_init() and
> sound_play().
>
> +config SOUND_INTEL_HDA
> + bool "Intel HDA audio codec"
> + depends on SOUND
> + help
> + Most Intel chips have an HDA (High-definition audio) codec which can
> + be used by U-Boot to play simple beeps. This is also sometimes called
> + Azalia which was the development code-name. It requires setup
> + information in the device tree (see intel-hda.txt).
> +
> config SOUND_MAX98088
> bool "Support Maxim max98088 audio codec"
> depends on I2S
> diff --git a/drivers/sound/Makefile b/drivers/sound/Makefile
> index 238f33bbb4..705a09464d 100644
> --- a/drivers/sound/Makefile
> +++ b/drivers/sound/Makefile
> @@ -14,3 +14,4 @@ obj-$(CONFIG_SOUND_WM8994) += wm8994.o
> obj-$(CONFIG_SOUND_MAX98088) += max98088.o maxim_codec.o
> obj-$(CONFIG_SOUND_MAX98090) += max98090.o maxim_codec.o
> obj-$(CONFIG_SOUND_MAX98095) += max98095.o maxim_codec.o
> +obj-$(CONFIG_SOUND_INTEL_HDA) += hda_codec.o
> diff --git a/drivers/sound/hda_codec.c b/drivers/sound/hda_codec.c
> new file mode 100644
> index 0000000000..648038542e
> --- /dev/null
> +++ b/drivers/sound/hda_codec.c
> @@ -0,0 +1,545 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Implementation of per-board codec beeping
> + * Copyright (c) 2011 The Chromium OS Authors.
> + * Copyright 2018 Google LLC
> + */
> +
> +#define LOG_CATEGORY UCLASS_SOUND
> +
> +#include <common.h>
> +#include <dm.h>
> +#include <hda_codec.h>
> +#include <pci.h>
> +#include <sound.h>
> +#include <asm/io.h>
> +
> +/**
> + * struct hda_regs - HDA registers
> + *
> + * https://wiki.osdev.org/Intel_High_Definition_Audio
> + */
> +struct hda_regs {
> + u16 gcap;
> + u8 vmin;
> + u8 vmaj;
> + u16 outpay;
> + u16 inpay;
> + u32 gctl;
> + u16 wakeen;
> + u16 statests;
> + u8 reserved[0x50];
> + u32 cmd; /* 0x60 */
> + u32 resp;
> + u32 icii;
> +};
> +
> +enum {
> + HDA_ICII_BUSY = BIT(0),
> + HDA_ICII_VALID = BIT(1),
> +
> + /* Common node IDs */
> + HDA_ROOT_NODE = 0x00,
> +
> + /* HDA verbs fields */
> + HDA_VERB_NID_S = 20,
> + HDA_VERB_VERB_S = 8,
> + HDA_VERB_PARAM_S = 0,
> +
> + HDA_VERB_GET_PARAMS = 0xf00,
> + HDA_VERB_SET_BEEP = 0x70a,
> +
> + /* GET_PARAMS parameter IDs */
> + GET_PARAMS_NODE_COUNT = 0x04,
> + GET_PARAMS_AUDIO_GROUP_CAPS = 0x08,
> + GET_PARAMS_AUDIO_WIDGET_CAPS = 0x09,
> +
> + /* Sub-node fields */
> + NUM_SUB_NODES_S = 0,
> + NUM_SUB_NODES_M = 0xff << NUM_SUB_NODES_S,
> + FIRST_SUB_NODE_S = 16,
> + FIRST_SUB_NODE_M = 0xff << FIRST_SUB_NODE_S,
> +
> + /* Get Audio Function Group Capabilities fields */
> + AUDIO_GROUP_CAPS_BEEP_GEN = 0x10000,
> +
> + /* Get Audio Widget Capabilities fields */
> + AUDIO_WIDGET_TYPE_BEEP = 0x7,
> + AUDIO_WIDGET_TYPE_S = 20,
> + AUDIO_WIDGET_TYPE_M = 0xf << AUDIO_WIDGET_TYPE_S,
> +
> + BEEP_FREQ_BASE = 12000,
> +};
> +
> +static inline uint hda_verb(uint nid, uint verb, uint param)
> +{
> + return nid << HDA_VERB_NID_S | verb << HDA_VERB_VERB_S |
> + param << HDA_VERB_PARAM_S;
> +}
> +
> +int hda_wait_for_ready(struct hda_regs *regs)
> +{
> + int timeout = 1000; /* Use a 1msec timeout */
> +
> + while (timeout--) {
> + u32 reg32 = readl(®s->icii);
> +
> + if (!(reg32 & HDA_ICII_BUSY))
> + return 0;
> + udelay(1);
> + }
> +
> + return -ETIMEDOUT;
> +}
> +
> +static int wait_for_response(struct hda_regs *regs, uint *response)
> +{
> + int timeout = 1000;
> + u32 reg32;
> +
> + /* Send the verb to the codec */
> + setbits_le32(®s->icii, HDA_ICII_BUSY | HDA_ICII_VALID);
> +
> + /* Use a 1msec timeout */
> + while (timeout--) {
> + reg32 = readl(®s->icii);
> + if ((reg32 & (HDA_ICII_VALID | HDA_ICII_BUSY)) ==
> + HDA_ICII_VALID) {
> + if (response)
> + *response = readl(®s->resp);
> + return 0;
> + }
> + udelay(1);
> + }
> +
> + return -ETIMEDOUT;
> +}
> +
> +int hda_wait_for_valid(struct hda_regs *regs)
> +{
> + return wait_for_response(regs, NULL);
> +}
> +
> +static int set_bits(void *port, u32 mask, u32 val)
> +{
> + u32 reg32;
> + int count;
> +
> + /* Write (val & mask) to port */
> + clrsetbits_le32(port, mask, val);
> +
> + /* Wait for readback of register to match what was just written to it */
> + count = 50;
> + do {
> + /* Wait 1ms based on BKDG wait time */
> + mdelay(1);
> + reg32 = readl(port) & mask;
> + } while (reg32 != val && --count);
> +
> + /* Timeout occurred */
> + if (!count)
> + return -ETIMEDOUT;
> +
> + return 0;
> +}
> +
> +int hda_codec_detect(struct hda_regs *regs)
> +{
> + uint reg8;
> +
> + /* Set Bit 0 to 1 to exit reset state (BAR + 0x8)[0] */
> + if (set_bits(®s->gctl, 1, 1))
> + goto no_codec;
> +
> + /* Write back the value once reset bit is set */
> + writew(readw(®s->gcap), ®s->gcap);
> +
> + /* Read in Codec location */
> + reg8 = readb(®s->statests) & 0xf;
> + if (!reg8)
> + goto no_codec;
> +
> + return reg8;
> +
> +no_codec:
> + /* Codec Not found - put HDA back in reset */
> + set_bits(®s->gctl, 1, 0);
> + log_debug("No codec\n");
> +
> + return 0;
> +}
> +
> +static int find_verb_data(struct udevice *dev, uint id, ofnode *nodep)
> +{
> + ofnode parent = dev_read_subnode(dev, "codecs");
> + ofnode node;
> + u32 vendor_id, device_id;
> +
> + ofnode_for_each_subnode(node, parent) {
> + if (ofnode_read_u32(node, "vendor-id", &vendor_id) ||
> + ofnode_read_u32(node, "device-id", &device_id)) {
> + log_debug("Cannot get IDs for '%s'\n",
> + ofnode_get_name(node));
> + return -EINVAL;
> + }
> + if (id != (vendor_id << 16 | device_id)) {
> + log_debug("Skip codec node '%s' for %08x\n",
> + ofnode_get_name(node), id);
> + continue;
> + }
> +
> + log_debug("Found codec node '%s' for %08x\n",
> + ofnode_get_name(node), id);
> + *nodep = node;
> + return 0;
> + }
> +
> + return -ENOENT;
> +}
> +
> +static int send_verbs(ofnode node, const char *prop_name, struct hda_regs *regs)
> +{
> + int ret, verb_size, i;
> + const u32 *verb;
> +
> + verb = ofnode_get_property(node, prop_name, &verb_size);
> + if (verb_size < 0) {
> + log_debug("No verb data\n");
> + return -EINVAL;
> + }
> + log_debug("verb_size: %d\n", verb_size);
> +
> + for (i = 0; i < verb_size / sizeof(*verb); i++) {
> + ret = hda_wait_for_ready(regs);
> + if (ret) {
> + log_debug(" codec ready timeout\n");
> + return ret;
> + }
> +
> + writel(fdt32_to_cpu(verb[i]), ®s->cmd);
> +
> + ret = hda_wait_for_valid(regs);
> + if (ret) {
> + log_debug(" codec valid timeout\n");
> + return ret;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int codec_init(struct udevice *dev, struct hda_regs *regs, uint addr)
> +{
> + ofnode node;
> + uint id;
> + int ret;
> +
> + log_debug("Initializing codec #%d\n", addr);
> + ret = hda_wait_for_ready(regs);
> + if (ret) {
> + log_debug(" codec not ready\n");
> + return ret;
> + }
> +
> + writel((addr << 28) | 0x000f0000, ®s->cmd);
nits: could use some macros here for 0xf0000?
> + ret = hda_wait_for_valid(regs);
> + if (ret) {
> + log_debug(" codec not valid\n");
> + return ret;
> + }
> +
> + id = readl(®s->resp);
> + log_debug("codec vid/did: %08x\n", id);
> + ret = find_verb_data(dev, id, &node);
> + if (ret) {
> + log_debug("No verb (err=%d)\n", ret);
> + return ret;
> + }
> + ret = send_verbs(node, "verbs", regs);
> + if (ret) {
> + log_debug("failed to send verbs (err=%d)\n", ret);
> + return ret;
> + }
> + log_debug("verb loaded\n");
> +
> + return 0;
> +}
> +
> +int hda_codecs_init(struct udevice *dev, struct hda_regs *regs, u32 codec_mask)
> +{
> + int ret;
> + int i;
> +
> + for (i = 3; i >= 0; i--) {
> + if (codec_mask & (1 << i)) {
> + ret = codec_init(dev, regs, i);
> + if (ret)
> + return ret;
> + }
> + }
> +
> + ret = send_verbs(dev_ofnode(dev), "beep-verbs", regs);
> + if (ret) {
> + log_debug("failed to send beep verbs (err=%d)\n", ret);
> + return ret;
> + }
> + log_debug("beep verbs loaded\n");
> +
> + return 0;
> +}
> +
> +/**
> + * exec_verb() - Write a verb to the codec
> + *
> + * @regs: HDA registers
> + * @val: Command to write
> + * @response: Set to response from codec
> + * @return 0 if OK, -ve on error
> + */
> +static int exec_verb(struct hda_regs *regs, uint val, uint *response)
> +{
> + int ret;
> +
> + ret = hda_wait_for_ready(regs);
> + if (ret)
> + return ret;
> +
> + writel(val, ®s->cmd);
> +
> + return wait_for_response(regs, response);
> +}
> +
> +/**
> + * get_subnode_info() - Get subnode information
> + *
> + * @regs: HDA registers
> + * @nid: Parent node ID to check
> + * @num_sub_nodesp: Returns number of subnodes
> + * @start_sub_node_nidp: Returns start subnode number
> + * @return 0 if OK, -ve on error
> + */
> +static int get_subnode_info(struct hda_regs *regs, uint nid,
> + uint *num_sub_nodesp, uint *start_sub_node_nidp)
> +{
> + uint response;
> + int ret;
> +
> + ret = exec_verb(regs, hda_verb(nid, HDA_VERB_GET_PARAMS,
> + GET_PARAMS_NODE_COUNT),
> + &response);
> + if (ret < 0) {
> + printf("Audio: Error reading sub-node info %d\n", nid);
> + return ret;
> + }
> +
> + *num_sub_nodesp = (response & NUM_SUB_NODES_M) >> NUM_SUB_NODES_S;
> + *start_sub_node_nidp = (response & FIRST_SUB_NODE_M) >>
> + FIRST_SUB_NODE_S;
> +
> + return 0;
> +}
> +
> +/**
> + * find_beep_node_in_group() - Finds the beeping node
> + *
> + * Searches the audio group for a node that supports beeping
> + *
> + * @regs: HDA registers
> + * @group_nid: Group node ID to check
> + * @return 0 if OK, -ve on error
> + */
> +static uint find_beep_node_in_group(struct hda_regs *regs, uint group_nid)
> +{
> + uint node_count = 0;
> + uint current_nid = 0;
> + uint response;
> + uint end_nid;
> + int ret;
> +
> + ret = get_subnode_info(regs, group_nid, &node_count, ¤t_nid);
> + if (ret < 0)
> + return 0;
> +
> + end_nid = current_nid + node_count;
> + while (current_nid < end_nid) {
> + ret = exec_verb(regs,
> + hda_verb(current_nid, HDA_VERB_GET_PARAMS,
> + GET_PARAMS_AUDIO_WIDGET_CAPS),
> + &response);
> + if (ret < 0) {
> + printf("Audio: Error reading widget caps\n");
> + return 0;
> + }
> +
> + if ((response & AUDIO_WIDGET_TYPE_M) >> AUDIO_WIDGET_TYPE_S ==
> + AUDIO_WIDGET_TYPE_BEEP)
> + return current_nid;
> +
> + current_nid++;
> + }
> +
> + return 0; /* no beep node found */
> +}
> +
> +/**
> + * audio_group_has_beep_node() - Check if group has a beep node
> + *
> + * Checks if the given audio group contains a beep generator
> + * @regs: HDA registers
> + * @nid: Node ID to check
> + * @return 0 if OK, -ve on error
> + */
> +static int audio_group_has_beep_node(struct hda_regs *regs, uint nid)
> +{
> + uint response;
> + int ret;
> +
> + ret = exec_verb(regs, hda_verb(nid, HDA_VERB_GET_PARAMS,
> + GET_PARAMS_AUDIO_GROUP_CAPS),
> + &response);
> + if (ret < 0) {
> + printf("Audio: Error reading audio group caps %d\n", nid);
> + return 0;
> + }
> +
> + return !!(response & AUDIO_GROUP_CAPS_BEEP_GEN);
> +}
> +
> +/**
> + * get_hda_beep_nid() - Finds the node ID of the beep node
> + *
> + * Finds the nid of the beep node if it exists. Starts at the root node, for
> + * each sub-node checks if the group contains a beep node. If the group
> + * contains a beep node, polls each node in the group until it is found.
> + *
> + * If the device has a intel,beep-nid property, the value of that is used
> + * instead.
> + *
> + * @dev: Sound device
> + * @return Node ID >0 if found, -ve error code otherwise
> + */
> +static int get_hda_beep_nid(struct udevice *dev)
> +{
> + struct hda_codec_priv *priv = dev_get_priv(dev);
> + uint current_nid = 0;
> + uint node_count = 0;
> + uint end_nid;
> + int ret;
> +
> + /* If the field exists, use the beep nid set in the fdt */
> + ret = dev_read_u32(dev, "intel,beep-nid", ¤t_nid);
> + if (!ret)
> + return current_nid;
> +
> + ret = get_subnode_info(priv->regs, HDA_ROOT_NODE, &node_count,
> + ¤t_nid);
> + if (ret < 0)
> + return ret;
> +
> + end_nid = current_nid + node_count;
> + while (current_nid < end_nid) {
> + if (audio_group_has_beep_node(priv->regs, current_nid))
> + return find_beep_node_in_group(priv->regs,
> + current_nid);
> + current_nid++;
> + }
> + /* no beep node found */
> +
> + return -ENOENT;
> +}
> +
> +/**
> + * set_beep_divisor() - Sets the beep divisor to set the pitch
> + *
> + * @priv: Device's private data
> + * @divider: Divider value (0 to disable the beep)
> + * @return 0 if OK, -ve on error
> + */
> +static int set_beep_divisor(struct hda_codec_priv *priv, uint divider)
> +{
> + return exec_verb(priv->regs,
> + hda_verb(priv->beep_nid, HDA_VERB_SET_BEEP, divider),
> + NULL);
> +}
> +
> +int hda_codec_init(struct udevice *dev)
> +{
> + struct hda_codec_priv *priv = dev_get_priv(dev);
> + ulong base_addr;
> +
> + base_addr = dm_pci_read_bar32(dev, 0);
> + log_debug("base = %08lx\n", base_addr);
> + if (!base_addr)
> + return -EINVAL;
> +
> + priv->regs = (struct hda_regs *)base_addr;
> +
> + return 0;
> +}
> +
> +int hda_codec_finish_init(struct udevice *dev)
> +{
> + struct hda_codec_priv *priv = dev_get_priv(dev);
> + int ret;
> +
> + ret = get_hda_beep_nid(dev);
> + if (ret <= 0) {
> + log_warning("Could not find beep NID (err=%d)\n", ret);
> + return ret ? ret : -ENOENT;
> + }
> + priv->beep_nid = ret;
> +
> + return 0;
> +}
> +
> +int hda_codec_start_beep(struct udevice *dev, int frequency_hz)
> +{
> + struct hda_codec_priv *priv = dev_get_priv(dev);
> + uint divider_val;
> +
> + if (!priv->beep_nid) {
> + log_err("Failed to find a beep-capable node\n");
> + return -ENOENT;
> + }
> +
> + if (!frequency_hz)
> + divider_val = 0; /* off */
> + else if (frequency_hz > BEEP_FREQ_BASE)
> + divider_val = 1;
> + else if (frequency_hz < BEEP_FREQ_BASE / 0xff)
> + divider_val = 0xff;
> + else
> + divider_val = 0xff & (BEEP_FREQ_BASE / frequency_hz);
> +
> + return set_beep_divisor(priv, divider_val);
> +}
> +
> +int hda_codec_stop_beep(struct udevice *dev)
> +{
> + struct hda_codec_priv *priv = dev_get_priv(dev);
> +
> + return set_beep_divisor(priv, 0);
> +}
> +
> +static const struct sound_ops hda_codec_ops = {
> + .setup = hda_codec_finish_init,
> + .start_beep = hda_codec_start_beep,
> + .stop_beep = hda_codec_stop_beep,
> +};
> +
> +U_BOOT_DRIVER(hda_codec) = {
> + .name = "hda_codec",
> + .id = UCLASS_SOUND,
> + .ops = &hda_codec_ops,
> + .priv_auto_alloc_size = sizeof(struct hda_codec_priv),
> + .probe = hda_codec_init,
> +};
> +
> +static struct pci_device_id hda_supported[] = {
> + { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_HDA},
> + { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PANTHERPOINT_HDA},
> + { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
> + PCI_DEVICE_ID_INTEL_WILDCATPOINT_HDA) },
If this driver can be applied to generic Intel HDA devices, I wonder
if there is a generic class defined by the PCI spec we can put here in
the table?
> +};
> +
> +U_BOOT_PCI_DEVICE(hda_codec, hda_supported);
> diff --git a/include/dt-bindings/sound/azalia.h b/include/dt-bindings/sound/azalia.h
> new file mode 100644
> index 0000000000..e35ffa920d
> --- /dev/null
> +++ b/include/dt-bindings/sound/azalia.h
> @@ -0,0 +1,29 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Intel HDA audio codec config. This is a mechanicm to configure codecs when
> + * using Intel HDA audio.
> + *
> + * Copyright 2018 Google LLC
> + * Written by Simon Glass <sjg at chromium.org>
> + */
> +
> +#ifndef __AZALIA_H
> +#define __AZALIA_H
> +
> +#define AZALIA_PIN_CFG(codec, pin, val) \
> + (((codec) << 28) | ((pin) << 20) | (0x71c << 8) \
> + | ((val) & 0xff)) \
> + (((codec) << 28) | ((pin) << 20) | (0x71d << 8) \
> + | (((val) >> 8) & 0xff)) \
> + (((codec) << 28) | ((pin) << 20) | (0x71e << 8) \
> + | (((val) >> 16) & 0xff)) \
> + (((codec) << 28) | ((pin) << 20) | (0x71f << 8) \
> + | (((val) >> 24) & 0xff))
nits: can we use some macros for 0x71c/d/e/f?
> +
> +#define AZALIA_SUBVENDOR(codec, val) \
> + (((codec) << 28) | (0x01720 << 8) | ((val) & 0xff)) \
> + (((codec) << 28) | (0x01721 << 8) | (((val) >> 8) & 0xff)) \
> + (((codec) << 28) | (0x01722 << 8) | (((val) >> 16) & 0xff)) \
> + (((codec) << 28) | (0x01723 << 8) | (((val) >> 24) & 0xff))
> +
nits: can we use some macros for 0x01720/1/2/3?
> +#endif /* __AZALIA_H */
> diff --git a/include/hda_codec.h b/include/hda_codec.h
> new file mode 100644
> index 0000000000..56de571f0f
> --- /dev/null
> +++ b/include/hda_codec.h
> @@ -0,0 +1,103 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Support for Intel High-Definition Audio codec
> + *
> + * Copyright 2018 Google LLC
> + *
> + * Taken from coreboot file of the same name
> + */
> +
> +#ifndef __HDA_CODEC_H_
> +#define __HDA_CODEC_H_
> +
> +struct hda_regs;
> +
> +/**
> + * struct hda_codec_priv - Private data required by the HDA codec
> + *
> + * @regs: HDA registers
> + * @beep_nid: Node ID of beep node (>0)
> + */
> +struct hda_codec_priv {
> + struct hda_regs *regs;
> + uint beep_nid;
> +};
> +
> +/**
> + * hda_wait_for_ready() - Wait for the codec to indicate it is ready
> + *
> + * @regs: HDA registers
> + * @return 0 if OK -ETIMEDOUT if codec did not respond in time
> + */
> +int hda_wait_for_ready(struct hda_regs *regs);
> +
> +/**
> + * hda_wait_for_valid() - Wait for the codec to accept the last command
> + *
> + * @regs: HDA registers
> + * @return 0 if OK -ETIMEDOUT if codec did not respond in time
> + */
> +int hda_wait_for_valid(struct hda_regs *regs);
> +
> +/**
> + * hda_codec_detect() - Detect which codecs are present
> + *
> + * @regs: HDA registers
> + * @return bit mask of active codecs (0 if none)
> + * @return 0 if OK, -ve on error
> + */
> +int hda_codec_detect(struct hda_regs *regs);
> +
> +/**
> + * hda_codecs_init() - Init all codecs
> + *
> + * @dev: Sound device
> + * @regs: HDA registers
> + * @codec_mask: Mask of codecs to init (bits 3:0)
> + * @return 0 if OK, -ve on error
> + */
> +int hda_codecs_init(struct udevice *dev, struct hda_regs *regs, u32 codec_mask);
> +
> +/**
> + * hda_codec_start_beep() - Start beeping
> + *
> + * This tells the sound hardware to start a beep. It will continue until stopped
> + * by sound_stop_beep().
> + *
> + * @dev: Sound device
> + * @frequency_hz: Beep frequency in hertz
> + * @return if OK, -ve on error
> + */
> +int hda_codec_start_beep(struct udevice *dev, int frequency_hz);
> +
> +/**
> + * hda_codec_stop_beep() - Stop beeping
> + *
> + * This tells the sound hardware to stop a previously started beep.
> + *
> + * @dev: Sound device
> + * @return if OK, -ve on error
> + */
> +int hda_codec_stop_beep(struct udevice *dev);
> +
> +/**
> + * hda_codec_init() - Set up the HDA codec base address
> + *
> + * This should be called at the start of the probe() method.
> + *
> + * @dev: Sound device
> + * @return 0 if OK, -ve on error
> + */
> +int hda_codec_init(struct udevice *dev);
> +
> +/**
> + * hda_codec_finish_init() - Finish setting up the HDA codec base address
> + *
> + * This should be called at the end of the probe() method.
> + *
> + * @dev: Sound device
> + * @return 0 if OK, -ve on error
> + */
> +int hda_codec_finish_init(struct udevice *dev);
> +
> +#endif /* __HDA_CODEC_H_ */
> --
Regards,
Bin
More information about the U-Boot
mailing list