[u-boot.git] / drivers / sound / hda_codec.c

// 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 <log.h>
#include <pci.h>
#include <sound.h>
#include <asm/io.h>
#include <dt-bindings/sound/azalia.h>
#include <linux/delay.h>

/**
 * struct hda_regs - HDA registers
 *
 * https://wiki.osdev.org/Intel_High_Definition_Audio
 * https://www.intel.com/content/www/us/en/standards/high-definition-audio-specification.html
 */
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(&regs->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(&regs->icii, HDA_ICII_BUSY | HDA_ICII_VALID);

	/* Use a 1msec timeout */
	while (timeout--) {
		reg32 = readl(&regs->icii);
		if ((reg32 & (HDA_ICII_VALID | HDA_ICII_BUSY)) ==
			HDA_ICII_VALID) {
			if (response)
				*response = readl(&regs->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(&regs->gctl, 1, 1))
		goto no_codec;

	/* Write back the value once reset bit is set */
	writew(readw(&regs->gcap), &regs->gcap);

	/* Read in Codec location */
	reg8 = readb(&regs->statests) & 0xf;
	if (!reg8)
		goto no_codec;

	return reg8;

no_codec:
	/* Codec Not found - put HDA back in reset */
	set_bits(&regs->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]), &regs->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;
	}

	/* Read the codec's vendor ID */
	writel(addr << AZALIA_CODEC_SHIFT |
	       AZALIA_OPCODE_READ_PARAM << AZALIA_VERB_SHIFT |
	       AZALIA_PARAM_VENDOR_ID, &regs->cmd);
	ret = hda_wait_for_valid(regs);
	if (ret) {
		log_debug("  codec not valid\n");
		return ret;
	}

	id = readl(&regs->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, &regs->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, &current_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", &current_nid);
	if (!ret)
		return current_nid;

	ret = get_subnode_info(priv->regs, HDA_ROOT_NODE, &node_count,
			       &current_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) },

	/*
	 * Note this driver is not necessarily generic, but it attempts to
	 * support any codec in the hd-audio class
	 */
	{ PCI_DEVICE_CLASS(PCI_CLASS_MULTIMEDIA_HD_AUDIO, 0xffffff) },
};

U_BOOT_PCI_DEVICE(hda_codec, hda_supported);
Commit	Line	Data
2ca47137 SG	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Implementation of per-board codec beeping
	4	* Copyright (c) 2011 The Chromium OS Authors.
	5	* Copyright 2018 Google LLC
	6	*/
	7
	8	#define LOG_CATEGORY UCLASS_SOUND
	9
	10	#include <common.h>
	11	#include <dm.h>
	12	#include <hda_codec.h>
f7ae49fc	13	#include <log.h>
2ca47137 SG	14	#include <pci.h>
	15	#include <sound.h>
	16	#include <asm/io.h>
	17	#include <dt-bindings/sound/azalia.h>
c05ed00a	18	#include <linux/delay.h>
2ca47137 SG	19
	20	/**
	21	* struct hda_regs - HDA registers
	22	*
	23	* https://wiki.osdev.org/Intel_High_Definition_Audio
	24	* https://www.intel.com/content/www/us/en/standards/high-definition-audio-specification.html
	25	*/
	26	struct hda_regs {
	27	u16 gcap;
	28	u8 vmin;
	29	u8 vmaj;
	30	u16 outpay;
	31	u16 inpay;
	32	u32 gctl;
	33	u16 wakeen;
	34	u16 statests;
	35	u8 reserved[0x50];
	36	u32 cmd; /* 0x60 */
	37	u32 resp;
	38	u32 icii;
	39	};
	40
	41	enum {
	42	HDA_ICII_BUSY = BIT(0),
	43	HDA_ICII_VALID = BIT(1),
	44
	45	/* Common node IDs */
	46	HDA_ROOT_NODE = 0x00,
	47
	48	/* HDA verbs fields */
	49	HDA_VERB_NID_S = 20,
	50	HDA_VERB_VERB_S = 8,
	51	HDA_VERB_PARAM_S = 0,
	52
	53	HDA_VERB_GET_PARAMS = 0xf00,
	54	HDA_VERB_SET_BEEP = 0x70a,
	55
	56	/* GET_PARAMS parameter IDs */
	57	GET_PARAMS_NODE_COUNT = 0x04,
	58	GET_PARAMS_AUDIO_GROUP_CAPS = 0x08,
	59	GET_PARAMS_AUDIO_WIDGET_CAPS = 0x09,
	60
	61	/* Sub-node fields */
	62	NUM_SUB_NODES_S = 0,
	63	NUM_SUB_NODES_M = 0xff << NUM_SUB_NODES_S,
	64	FIRST_SUB_NODE_S = 16,
	65	FIRST_SUB_NODE_M = 0xff << FIRST_SUB_NODE_S,
	66
	67	/* Get Audio Function Group Capabilities fields */
	68	AUDIO_GROUP_CAPS_BEEP_GEN = 0x10000,
	69
	70	/* Get Audio Widget Capabilities fields */
	71	AUDIO_WIDGET_TYPE_BEEP = 0x7,
	72	AUDIO_WIDGET_TYPE_S = 20,
	73	AUDIO_WIDGET_TYPE_M = 0xf << AUDIO_WIDGET_TYPE_S,
	74
	75	BEEP_FREQ_BASE = 12000,
	76	};
	77
	78	static inline uint hda_verb(uint nid, uint verb, uint param)
	79	{
	80	return nid << HDA_VERB_NID_S \| verb << HDA_VERB_VERB_S \|
	81	param << HDA_VERB_PARAM_S;
	82	}
83
84	int hda_wait_for_ready(struct hda_regs *regs)
85	{
86	int timeout = 1000; /* Use a 1msec timeout */
87
88	while (timeout--) {
89	u32 reg32 = readl(&regs->icii);
90
91	if (!(reg32 & HDA_ICII_BUSY))
92	return 0;
93	udelay(1);
94	}
95
96	return -ETIMEDOUT;
97	}
98
99	static int wait_for_response(struct hda_regs regs, uint response)
100	{
101	int timeout = 1000;
102	u32 reg32;
103
104	/* Send the verb to the codec */
105	setbits_le32(&regs->icii, HDA_ICII_BUSY \| HDA_ICII_VALID);
106
107	/* Use a 1msec timeout */
108	while (timeout--) {
109	reg32 = readl(&regs->icii);
110	if ((reg32 & (HDA_ICII_VALID \| HDA_ICII_BUSY)) ==
111	HDA_ICII_VALID) {
112	if (response)
113	*response = readl(&regs->resp);
114	return 0;
115	}
116	udelay(1);
117	}
118
119	return -ETIMEDOUT;
120	}
121
122	int hda_wait_for_valid(struct hda_regs *regs)
123	{
124	return wait_for_response(regs, NULL);
125	}
126
127	static int set_bits(void *port, u32 mask, u32 val)
128	{
129	u32 reg32;
130	int count;
131
132	/* Write (val & mask) to port */
133	clrsetbits_le32(port, mask, val);
134
135	/* Wait for readback of register to match what was just written to it */
136	count = 50;
137	do {
138	/* Wait 1ms based on BKDG wait time */
139	mdelay(1);
140	reg32 = readl(port) & mask;
141	} while (reg32 != val && --count);
142
143	/* Timeout occurred */
144	if (!count)
145	return -ETIMEDOUT;
146
147	return 0;
148	}
149
150	int hda_codec_detect(struct hda_regs *regs)
151	{
152	uint reg8;
153
154	/* Set Bit 0 to 1 to exit reset state (BAR + 0x8)[0] */
155	if (set_bits(&regs->gctl, 1, 1))
156	goto no_codec;
157
158	/* Write back the value once reset bit is set */
159	writew(readw(&regs->gcap), &regs->gcap);
160
161	/* Read in Codec location */
162	reg8 = readb(&regs->statests) & 0xf;
163	if (!reg8)
164	goto no_codec;
165
166	return reg8;
167
168	no_codec:
169	/* Codec Not found - put HDA back in reset */
170	set_bits(&regs->gctl, 1, 0);
171	log_debug("No codec\n");
172
173	return 0;
174	}
175
176	static int find_verb_data(struct udevice dev, uint id, ofnode nodep)
177	{
178	ofnode parent = dev_read_subnode(dev, "codecs");
179	ofnode node;
180	u32 vendor_id, device_id;
181
182	ofnode_for_each_subnode(node, parent) {
183	if (ofnode_read_u32(node, "vendor-id", &vendor_id) \|\|
184	ofnode_read_u32(node, "device-id", &device_id)) {
185	log_debug("Cannot get IDs for '%s'\n",
186	ofnode_get_name(node));
187	return -EINVAL;
188	}
189	if (id != (vendor_id << 16 \| device_id)) {
190	log_debug("Skip codec node '%s' for %08x\n",
191	ofnode_get_name(node), id);
192	continue;
193	}
194
195	log_debug("Found codec node '%s' for %08x\n",
196	ofnode_get_name(node), id);
197	*nodep = node;
198	return 0;
199	}
200
201	return -ENOENT;
202	}
203
204	static int send_verbs(ofnode node, const char prop_name, struct hda_regs regs)
205	{
206	int ret, verb_size, i;
207	const u32 *verb;
208
209	verb = ofnode_get_property(node, prop_name, &verb_size);
210	if (verb_size < 0) {
211	log_debug("No verb data\n");
212	return -EINVAL;
213	}
214	log_debug("verb_size: %d\n", verb_size);
215
216	for (i = 0; i < verb_size / sizeof(*verb); i++) {
217	ret = hda_wait_for_ready(regs);
218	if (ret) {
219	log_debug(" codec ready timeout\n");
220	return ret;
221	}
222
223	writel(fdt32_to_cpu(verb[i]), &regs->cmd);
224
225	ret = hda_wait_for_valid(regs);
226	if (ret) {
227	log_debug(" codec valid timeout\n");
228	return ret;
229	}
230	}
231
232	return 0;
233	}
234
235	static int codec_init(struct udevice dev, struct hda_regs regs, uint addr)
236	{
237	ofnode node;
238	uint id;
239	int ret;
240
241	log_debug("Initializing codec #%d\n", addr);
242	ret = hda_wait_for_ready(regs);
243	if (ret) {
244	log_debug(" codec not ready\n");
245	return ret;
246	}
247
248	/* Read the codec's vendor ID */
249	writel(addr << AZALIA_CODEC_SHIFT \|
250	AZALIA_OPCODE_READ_PARAM << AZALIA_VERB_SHIFT \|
251	AZALIA_PARAM_VENDOR_ID, &regs->cmd);
252	ret = hda_wait_for_valid(regs);
253	if (ret) {
254	log_debug(" codec not valid\n");
255	return ret;
256	}
257
258	id = readl(&regs->resp);
259	log_debug("codec vid/did: %08x\n", id);
260	ret = find_verb_data(dev, id, &node);
261	if (ret) {
262	log_debug("No verb (err=%d)\n", ret);
263	return ret;
264	}
265	ret = send_verbs(node, "verbs", regs);
266	if (ret) {
267	log_debug("failed to send verbs (err=%d)\n", ret);
268	return ret;
269	}
270	log_debug("verb loaded\n");
271
272	return 0;
273	}
274
275	int hda_codecs_init(struct udevice dev, struct hda_regs regs, u32 codec_mask)
276	{
277	int ret;
278	int i;
279
280	for (i = 3; i >= 0; i--) {
281	if (codec_mask & (1 << i)) {
282	ret = codec_init(dev, regs, i);
283	if (ret)
284	return ret;
285	}
286	}
287
288	ret = send_verbs(dev_ofnode(dev), "beep-verbs", regs);
289	if (ret) {
290	log_debug("failed to send beep verbs (err=%d)\n", ret);
291	return ret;
292	}
293	log_debug("beep verbs loaded\n");
294
295	return 0;
296	}
297
298	/**
299	* exec_verb() - Write a verb to the codec
300	*
301	* @regs: HDA registers
302	* @val: Command to write
303	* @response: Set to response from codec
304	* @return 0 if OK, -ve on error
305	*/
306	static int exec_verb(struct hda_regs regs, uint val, uint response)
307	{
308	int ret;
309
310	ret = hda_wait_for_ready(regs);
311	if (ret)
312	return ret;
313
314	writel(val, &regs->cmd);
315
316	return wait_for_response(regs, response);
317	}
318
319	/**
320	* get_subnode_info() - Get subnode information
321	*
322	* @regs: HDA registers
323	* @nid: Parent node ID to check
324	* @num_sub_nodesp: Returns number of subnodes
325	* @start_sub_node_nidp: Returns start subnode number
326	* @return 0 if OK, -ve on error
327	*/
328	static int get_subnode_info(struct hda_regs *regs, uint nid,
329	uint num_sub_nodesp, uint start_sub_node_nidp)
330	{
331	uint response;
332	int ret;
333
334	ret = exec_verb(regs, hda_verb(nid, HDA_VERB_GET_PARAMS,
335	GET_PARAMS_NODE_COUNT),
336	&response);
337	if (ret < 0) {
338	printf("Audio: Error reading sub-node info %d\n", nid);
339	return ret;
340	}
341
342	*num_sub_nodesp = (response & NUM_SUB_NODES_M) >> NUM_SUB_NODES_S;
343	*start_sub_node_nidp = (response & FIRST_SUB_NODE_M) >>
344	FIRST_SUB_NODE_S;
345
346	return 0;
347	}
348
349	/**
350	* find_beep_node_in_group() - Finds the beeping node
351	*
352	* Searches the audio group for a node that supports beeping
353	*
354	* @regs: HDA registers
355	* @group_nid: Group node ID to check
356	* @return 0 if OK, -ve on error
357	*/
358	static uint find_beep_node_in_group(struct hda_regs *regs, uint group_nid)
359	{
360	uint node_count = 0;
361	uint current_nid = 0;
362	uint response;
363	uint end_nid;
364	int ret;
365
366	ret = get_subnode_info(regs, group_nid, &node_count, &current_nid);
367	if (ret < 0)
368	return 0;
369
370	end_nid = current_nid + node_count;
371	while (current_nid < end_nid) {
372	ret = exec_verb(regs,
373	hda_verb(current_nid, HDA_VERB_GET_PARAMS,
374	GET_PARAMS_AUDIO_WIDGET_CAPS),
375	&response);
376	if (ret < 0) {
377	printf("Audio: Error reading widget caps\n");
378	return 0;
379	}
380
381	if ((response & AUDIO_WIDGET_TYPE_M) >> AUDIO_WIDGET_TYPE_S ==
382	AUDIO_WIDGET_TYPE_BEEP)
383	return current_nid;
384
385	current_nid++;
386	}
387
388	return 0; /* no beep node found */
389	}
390
391	/**
392	* audio_group_has_beep_node() - Check if group has a beep node
393	*
394	* Checks if the given audio group contains a beep generator
395	* @regs: HDA registers
396	* @nid: Node ID to check
397	* @return 0 if OK, -ve on error
398	*/
399	static int audio_group_has_beep_node(struct hda_regs *regs, uint nid)
400	{
401	uint response;
402	int ret;
403
404	ret = exec_verb(regs, hda_verb(nid, HDA_VERB_GET_PARAMS,
405	GET_PARAMS_AUDIO_GROUP_CAPS),
406	&response);
407	if (ret < 0) {
408	printf("Audio: Error reading audio group caps %d\n", nid);
409	return 0;
410	}
411
412	return !!(response & AUDIO_GROUP_CAPS_BEEP_GEN);
413	}
414
415	/**
416	* get_hda_beep_nid() - Finds the node ID of the beep node
417	*
418	* Finds the nid of the beep node if it exists. Starts at the root node, for
419	* each sub-node checks if the group contains a beep node. If the group
420	* contains a beep node, polls each node in the group until it is found.
421	*
422	* If the device has a intel,beep-nid property, the value of that is used
423	* instead.
424	*
425	* @dev: Sound device
426	* @return Node ID >0 if found, -ve error code otherwise
427	*/
428	static int get_hda_beep_nid(struct udevice *dev)
429	{
430	struct hda_codec_priv *priv = dev_get_priv(dev);
431	uint current_nid = 0;
432	uint node_count = 0;
433	uint end_nid;
434	int ret;
435
436	/* If the field exists, use the beep nid set in the fdt */
437	ret = dev_read_u32(dev, "intel,beep-nid", &current_nid);
438	if (!ret)
439	return current_nid;
440
441	ret = get_subnode_info(priv->regs, HDA_ROOT_NODE, &node_count,
442	&current_nid);
443	if (ret < 0)
444	return ret;
445
446	end_nid = current_nid + node_count;
447	while (current_nid < end_nid) {
448	if (audio_group_has_beep_node(priv->regs, current_nid))
449	return find_beep_node_in_group(priv->regs,
450	current_nid);
451	current_nid++;
452	}
453	/* no beep node found */
454
455	return -ENOENT;
456	}
457
458	/**
459	* set_beep_divisor() - Sets the beep divisor to set the pitch
460	*
461	* @priv: Device's private data
462	* @divider: Divider value (0 to disable the beep)
463	* @return 0 if OK, -ve on error
464	*/
465	static int set_beep_divisor(struct hda_codec_priv *priv, uint divider)
466	{
467	return exec_verb(priv->regs,
468	hda_verb(priv->beep_nid, HDA_VERB_SET_BEEP, divider),
469	NULL);
470	}
471
472	int hda_codec_init(struct udevice *dev)
473	{
474	struct hda_codec_priv *priv = dev_get_priv(dev);
475	ulong base_addr;
476
477	base_addr = dm_pci_read_bar32(dev, 0);
478	log_debug("base = %08lx\n", base_addr);
479	if (!base_addr)
480	return -EINVAL;
481
482	priv->regs = (struct hda_regs *)base_addr;
483
484	return 0;
485	}
486
487	int hda_codec_finish_init(struct udevice *dev)
488	{
489	struct hda_codec_priv *priv = dev_get_priv(dev);
490	int ret;
491
492	ret = get_hda_beep_nid(dev);
493	if (ret <= 0) {
494	log_warning("Could not find beep NID (err=%d)\n", ret);
495	return ret ? ret : -ENOENT;
496	}
497	priv->beep_nid = ret;
498
499	return 0;
500	}
501
502	int hda_codec_start_beep(struct udevice *dev, int frequency_hz)
503	{
504	struct hda_codec_priv *priv = dev_get_priv(dev);
505	uint divider_val;
506
507	if (!priv->beep_nid) {
508	log_err("Failed to find a beep-capable node\n");
509	return -ENOENT;
510	}
511
512	if (!frequency_hz)
513	divider_val = 0; /* off */
514	else if (frequency_hz > BEEP_FREQ_BASE)
515	divider_val = 1;
516	else if (frequency_hz < BEEP_FREQ_BASE / 0xff)
517	divider_val = 0xff;
518	else
519	divider_val = 0xff & (BEEP_FREQ_BASE / frequency_hz);
520
521	return set_beep_divisor(priv, divider_val);
522	}
523
524	int hda_codec_stop_beep(struct udevice *dev)
525	{
526	struct hda_codec_priv *priv = dev_get_priv(dev);
527
528	return set_beep_divisor(priv, 0);
529	}
530
531	static const struct sound_ops hda_codec_ops = {
532	.setup = hda_codec_finish_init,
533	.start_beep = hda_codec_start_beep,
534	.stop_beep = hda_codec_stop_beep,
535	};
536
537	U_BOOT_DRIVER(hda_codec) = {
538	.name = "hda_codec",
539	.id = UCLASS_SOUND,
540	.ops = &hda_codec_ops,
541	.priv_auto_alloc_size = sizeof(struct hda_codec_priv),
542	.probe = hda_codec_init,
543	};
544
545	static struct pci_device_id hda_supported[] = {
546	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COUGARPOINT_HDA},
547	{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PANTHERPOINT_HDA},
548	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL,
549	PCI_DEVICE_ID_INTEL_WILDCATPOINT_HDA) },
550
551	/*
552	* Note this driver is not necessarily generic, but it attempts to
553	* support any codec in the hd-audio class
554	*/
555	{ PCI_DEVICE_CLASS(PCI_CLASS_MULTIMEDIA_HD_AUDIO, 0xffffff) },
556	};
557
558	U_BOOT_PCI_DEVICE(hda_codec, hda_supported);