/* * Universal Interface for Intel High Definition Audio Codec * * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> * * *  This driver is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License as published by *  the Free Software Foundation; either version 2 of the License, or *  (at your option) any later version. * *  This driver is distributed in the hope that it will be useful, *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *  GNU General Public License for more details. * *  You should have received a copy of the GNU General Public License *  along with this program; if not, write to the Free Software *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */#include <sound/driver.h>#include <linux/init.h>#include <linux/delay.h>#include <linux/slab.h>#include <linux/pci.h>#include <linux/mutex.h>#include <sound/core.h>#include "hda_codec.h"#include <sound/asoundef.h>#include <sound/tlv.h>#include <sound/initval.h>#include "hda_local.h"#include <sound/hda_hwdep.h>#ifdef CONFIG_SND_HDA_POWER_SAVE/* define this option here to hide as static */static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;module_param(power_save, int, 0644);MODULE_PARM_DESC(power_save, "Automatic power-saving timeout "		 "(in second, 0 = disable).");#endif/* * vendor / preset table */struct hda_vendor_id {	unsigned int id;	const char *name;};/* codec vendor labels */static struct hda_vendor_id hda_vendor_ids[] = {	{ 0x10ec, "Realtek" },	{ 0x1057, "Motorola" },	{ 0x1106, "VIA" },	{ 0x11d4, "Analog Devices" },	{ 0x13f6, "C-Media" },	{ 0x14f1, "Conexant" },	{ 0x434d, "C-Media" },	{ 0x8384, "SigmaTel" },	{} /* terminator */};/* codec presets */#include "hda_patch.h"#ifdef CONFIG_SND_HDA_POWER_SAVEstatic void hda_power_work(struct work_struct *work);static void hda_keep_power_on(struct hda_codec *codec);#elsestatic inline void hda_keep_power_on(struct hda_codec *codec) {}#endif/** * snd_hda_codec_read - send a command and get the response * @codec: the HDA codec * @nid: NID to send the command * @direct: direct flag * @verb: the verb to send * @parm: the parameter for the verb * * Send a single command and read the corresponding response. * * Returns the obtained response value, or -1 for an error. */unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,				int direct,				unsigned int verb, unsigned int parm){	unsigned int res;	snd_hda_power_up(codec);	mutex_lock(&codec->bus->cmd_mutex);	if (!codec->bus->ops.command(codec, nid, direct, verb, parm))		res = codec->bus->ops.get_response(codec);	else		res = (unsigned int)-1;	mutex_unlock(&codec->bus->cmd_mutex);	snd_hda_power_down(codec);	return res;}/** * snd_hda_codec_write - send a single command without waiting for response * @codec: the HDA codec * @nid: NID to send the command * @direct: direct flag * @verb: the verb to send * @parm: the parameter for the verb * * Send a single command without waiting for response. * * Returns 0 if successful, or a negative error code. */int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,			 unsigned int verb, unsigned int parm){	int err;	snd_hda_power_up(codec);	mutex_lock(&codec->bus->cmd_mutex);	err = codec->bus->ops.command(codec, nid, direct, verb, parm);	mutex_unlock(&codec->bus->cmd_mutex);	snd_hda_power_down(codec);	return err;}/** * snd_hda_sequence_write - sequence writes * @codec: the HDA codec * @seq: VERB array to send * * Send the commands sequentially from the given array. * The array must be terminated with NID=0. */void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq){	for (; seq->nid; seq++)		snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);}/** * snd_hda_get_sub_nodes - get the range of sub nodes * @codec: the HDA codec * @nid: NID to parse * @start_id: the pointer to store the start NID * * Parse the NID and store the start NID of its sub-nodes. * Returns the number of sub-nodes. */int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,			  hda_nid_t *start_id){	unsigned int parm;	parm = snd_hda_param_read(codec, nid, AC_PAR_NODE_COUNT);	if (parm == -1)		return 0;	*start_id = (parm >> 16) & 0x7fff;	return (int)(parm & 0x7fff);}/** * snd_hda_get_connections - get connection list * @codec: the HDA codec * @nid: NID to parse * @conn_list: connection list array * @max_conns: max. number of connections to store * * Parses the connection list of the given widget and stores the list * of NIDs. * * Returns the number of connections, or a negative error code. */int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,			    hda_nid_t *conn_list, int max_conns){	unsigned int parm;	int i, conn_len, conns;	unsigned int shift, num_elems, mask;	hda_nid_t prev_nid;	snd_assert(conn_list && max_conns > 0, return -EINVAL);	parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);	if (parm & AC_CLIST_LONG) {		/* long form */		shift = 16;		num_elems = 2;	} else {		/* short form */		shift = 8;		num_elems = 4;	}	conn_len = parm & AC_CLIST_LENGTH;	mask = (1 << (shift-1)) - 1;	if (!conn_len)		return 0; /* no connection */	if (conn_len == 1) {		/* single connection */		parm = snd_hda_codec_read(codec, nid, 0,					  AC_VERB_GET_CONNECT_LIST, 0);		conn_list[0] = parm & mask;		return 1;	}	/* multi connection */	conns = 0;	prev_nid = 0;	for (i = 0; i < conn_len; i++) {		int range_val;		hda_nid_t val, n;		if (i % num_elems == 0)			parm = snd_hda_codec_read(codec, nid, 0,						  AC_VERB_GET_CONNECT_LIST, i);		range_val = !!(parm & (1 << (shift-1))); /* ranges */		val = parm & mask;		parm >>= shift;		if (range_val) {			/* ranges between the previous and this one */			if (!prev_nid || prev_nid >= val) {				snd_printk(KERN_WARNING "hda_codec: "					   "invalid dep_range_val %x:%x\n",					   prev_nid, val);				continue;			}			for (n = prev_nid + 1; n <= val; n++) {				if (conns >= max_conns) {					snd_printk(KERN_ERR						   "Too many connections\n");					return -EINVAL;				}				conn_list[conns++] = n;			}		} else {			if (conns >= max_conns) {				snd_printk(KERN_ERR "Too many connections\n");				return -EINVAL;			}			conn_list[conns++] = val;		}		prev_nid = val;	}	return conns;}/** * snd_hda_queue_unsol_event - add an unsolicited event to queue * @bus: the BUS * @res: unsolicited event (lower 32bit of RIRB entry) * @res_ex: codec addr and flags (upper 32bit or RIRB entry) * * Adds the given event to the queue.  The events are processed in * the workqueue asynchronously.  Call this function in the interrupt * hanlder when RIRB receives an unsolicited event. * * Returns 0 if successful, or a negative error code. */int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex){	struct hda_bus_unsolicited *unsol;	unsigned int wp;	unsol = bus->unsol;	if (!unsol)		return 0;	wp = (unsol->wp + 1) % HDA_UNSOL_QUEUE_SIZE;	unsol->wp = wp;	wp <<= 1;	unsol->queue[wp] = res;	unsol->queue[wp + 1] = res_ex;	schedule_work(&unsol->work);	return 0;}/* * process queueud unsolicited events */static void process_unsol_events(struct work_struct *work){	struct hda_bus_unsolicited *unsol =		container_of(work, struct hda_bus_unsolicited, work);	struct hda_bus *bus = unsol->bus;	struct hda_codec *codec;	unsigned int rp, caddr, res;	while (unsol->rp != unsol->wp) {		rp = (unsol->rp + 1) % HDA_UNSOL_QUEUE_SIZE;		unsol->rp = rp;		rp <<= 1;		res = unsol->queue[rp];		caddr = unsol->queue[rp + 1];		if (!(caddr & (1 << 4))) /* no unsolicited event? */			continue;		codec = bus->caddr_tbl[caddr & 0x0f];		if (codec && codec->patch_ops.unsol_event)			codec->patch_ops.unsol_event(codec, res);	}}/* * initialize unsolicited queue */static int __devinit init_unsol_queue(struct hda_bus *bus){	struct hda_bus_unsolicited *unsol;	if (bus->unsol) /* already initialized */		return 0;	unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);	if (!unsol) {		snd_printk(KERN_ERR "hda_codec: "			   "can't allocate unsolicited queue\n");		return -ENOMEM;	}	INIT_WORK(&unsol->work, process_unsol_events);	unsol->bus = bus;	bus->unsol = unsol;	return 0;}/* * destructor */static void snd_hda_codec_free(struct hda_codec *codec);static int snd_hda_bus_free(struct hda_bus *bus){	struct hda_codec *codec, *n;	if (!bus)		return 0;	if (bus->unsol) {		flush_scheduled_work();		kfree(bus->unsol);	}	list_for_each_entry_safe(codec, n, &bus->codec_list, list) {		snd_hda_codec_free(codec);	}	if (bus->ops.private_free)		bus->ops.private_free(bus);	kfree(bus);	return 0;}static int snd_hda_bus_dev_free(struct snd_device *device){	struct hda_bus *bus = device->device_data;	return snd_hda_bus_free(bus);}/** * snd_hda_bus_new - create a HDA bus * @card: the card entry * @temp: the template for hda_bus information * @busp: the pointer to store the created bus instance * * Returns 0 if successful, or a negative error code. */int __devinit snd_hda_bus_new(struct snd_card *card,			      const struct hda_bus_template *temp,			      struct hda_bus **busp){	struct hda_bus *bus;	int err;	static struct snd_device_ops dev_ops = {		.dev_free = snd_hda_bus_dev_free,	};	snd_assert(temp, return -EINVAL);	snd_assert(temp->ops.command && temp->ops.get_response, return -EINVAL);	if (busp)		*busp = NULL;	bus = kzalloc(sizeof(*bus), GFP_KERNEL);	if (bus == NULL) {		snd_printk(KERN_ERR "can't allocate struct hda_bus\n");		return -ENOMEM;	}	bus->card = card;	bus->private_data = temp->private_data;	bus->pci = temp->pci;	bus->modelname = temp->modelname;	bus->ops = temp->ops;	mutex_init(&bus->cmd_mutex);	INIT_LIST_HEAD(&bus->codec_list);	err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops);	if (err < 0) {		snd_hda_bus_free(bus);		return err;	}	if (busp)		*busp = bus;	return 0;}#ifdef CONFIG_SND_HDA_GENERIC#define is_generic_config(codec) \	(codec->bus->modelname && !strcmp(codec->bus->modelname, "generic"))#else#define is_generic_config(codec)	0#endif/* * find a matching codec preset */static const struct hda_codec_preset __devinit *find_codec_preset(struct hda_codec *codec){	const struct hda_codec_preset **tbl, *preset;	if (is_generic_config(codec))		return NULL; /* use the generic parser */	for (tbl = hda_preset_tables; *tbl; tbl++) {		for (preset = *tbl; preset->id; preset++) {			u32 mask = preset->mask;			if (!mask)				mask = ~0;			if (preset->id == (codec->vendor_id & mask) &&			    (!preset->rev ||			     preset->rev == codec->revision_id))				return preset;		}	}	return NULL;}/* * snd_hda_get_codec_name - store the codec name */void snd_hda_get_codec_name(struct hda_codec *codec,			    char *name, int namelen){	const struct hda_vendor_id *c;	const char *vendor = NULL;	u16 vendor_id = codec->vendor_id >> 16;	char tmp[16];	for (c = hda_vendor_ids; c->id; c++) {		if (c->id == vendor_id) {			vendor = c->name;			break;		}	}	if (!vendor) {		sprintf(tmp, "Generic %04x", vendor_id);		vendor = tmp;	}	if (codec->preset && codec->preset->name)		snprintf(name, namelen, "%s %s", vendor, codec->preset->name);	else		snprintf(name, namelen, "%s ID %x", vendor,			 codec->vendor_id & 0xffff);}/* * look for an AFG and MFG nodes */static void __devinit setup_fg_nodes(struct hda_codec *codec){	int i, total_nodes;	hda_nid_t nid;	total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);	for (i = 0; i < total_nodes; i++, nid++) {		unsigned int func;		func = snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE);		switch (func & 0xff) {		case AC_GRP_AUDIO_FUNCTION:			codec->afg = nid;			break;		case AC_GRP_MODEM_FUNCTION:			codec->mfg = nid;			break;		default:			break;		}	}}/*