/* * 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/moduleparam.h>#include <sound/core.h>#include "hda_codec.h"#include <sound/asoundef.h>#include <sound/initval.h>#include "hda_local.h"MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");MODULE_DESCRIPTION("Universal interface for High Definition Audio Codec");MODULE_LICENSE("GPL");/* * 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" },	{ 0x11d4, "Analog Devices" },	{ 0x13f6, "C-Media" },	{ 0x434d, "C-Media" },	{ 0x8384, "SigmaTel" },	{ 0x14f1, "Conexant" },	{} /* terminator */};/* codec presets */#include "hda_patch.h"/** * snd_hda_codec_wallclock - get the wallclock counter * @codec: the HDA codec * * Get the wallclock counter * * Returns the obtained value, or -1 for an error. */unsigned int snd_hda_codec_wallclock(struct hda_codec *codec){	u32 res;	if(codec->bus->ops.get_wallclock)		res = codec->bus->ops.get_wallclock(codec);	else		res = (u32)-1;	return res;}/** * 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;	down(&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;	up(&codec->bus->cmd_mutex);	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;	down(&codec->bus->cmd_mutex);	err = codec->bus->ops.command(codec, nid, direct, verb, parm);	up(&codec->bus->cmd_mutex);	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);	*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, j, conn_len, num_tupples, conns;	unsigned int shift, num_elems, mask;	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;	num_tupples = num_elems / 2;	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;	for (i = 0; i < conn_len; i += num_elems) {		parm = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_LIST, i);		for (j = 0; j < num_tupples; j++) {			int range_val;			hda_nid_t val1, val2, n;			range_val = parm & (1 << (shift-1)); /* ranges */			val1 = parm & mask;			parm >>= shift;			val2 = parm & mask;			parm >>= shift;			if (range_val) {				/* ranges between val1 and val2 */				if (val1 > val2) {					snd_printk(KERN_WARNING "hda_codec: invalid dep_range_val %x:%x\n", val1, val2);					continue;				}				for (n = val1; n <= val2; n++) {					if (conns >= max_conns)						return -EINVAL;					conn_list[conns++] = n;				}			} else {				if (! val1)					break;				if (conns >= max_conns)					return -EINVAL;				conn_list[conns++] = val1;				if (! val2)					break;				if (conns >= max_conns)					return -EINVAL;				conn_list[conns++] = val2;			}		}	}	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;	if ((unsol = bus->unsol) == NULL)		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;	queue_work(unsol->workq, &unsol->work);	return 0;}void snd_hda_codec_remove_notify_all(struct hda_bus *bus){	struct list_head *p, *n;//printk("%s: %p\n", __FUNCTION__, bus);	if (! bus)		return;	list_for_each_safe(p, n, &bus->codec_list) {		struct hda_codec *codec = list_entry(p, struct hda_codec, list);		if (codec && codec->patch_ops.exit) {//printk("%s: %p calling codec->patch_ops.exit for codec %p\n", __FUNCTION__, bus, codec);			codec->patch_ops.exit(codec);		}	}}/* * process queueud unsolicited events */static void process_unsol_events(void *data){	struct hda_bus *bus = data;	struct hda_bus_unsolicited *unsol = bus->unsol;	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 init_unsol_queue(struct hda_bus *bus){	struct hda_bus_unsolicited *unsol;	unsol = kzalloc(sizeof(*unsol), GFP_KERNEL);	if (! unsol) {		snd_printk(KERN_ERR "hda_codec: can't allocate unsolicited queue\n");		return -ENOMEM;	}	unsol->workq = create_workqueue("hda_codec");	if (! unsol->workq) {		snd_printk(KERN_ERR "hda_codec: can't create workqueue\n");		kfree(unsol);		return -ENOMEM;	}	INIT_WORK(&unsol->work, process_unsol_events, 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 list_head *p, *n;//printk("%s: %p\n", __FUNCTION__, bus);	if (! bus)		return 0;	if (bus->unsol) {		destroy_workqueue(bus->unsol->workq);		kfree(bus->unsol);	}	list_for_each_safe(p, n, &bus->codec_list) {		struct hda_codec *codec = list_entry(p, struct hda_codec, 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(snd_device_t *device){	struct hda_bus *bus = device->device_data;//printk("%s: %p\n", __FUNCTION__, device);	return snd_hda_bus_free(bus);}#if 0static int snd_hda_bus_dev_disconnect(snd_device_t *device){	printk("%s: %p\n", __FUNCTION__, device);	return 0;}static int snd_hda_bus_dev_unregister(snd_device_t *device){	printk("%s: %p\n", __FUNCTION__, device);	return 0;}#endif/** * 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 snd_hda_bus_new(snd_card_t *card, const struct hda_bus_template *temp,		    struct hda_bus **busp){	struct hda_bus *bus;	int err;	static snd_device_ops_t dev_ops = {		.dev_free = snd_hda_bus_dev_free,#if 0		.dev_unregister = snd_hda_bus_dev_unregister,		.dev_disconnect = snd_hda_bus_dev_disconnect,#endif	};//printk(KERN_ERR"%s: card=%p\n", __FUNCTION__, card);	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;	init_MUTEX(&bus->cmd_mutex);	INIT_LIST_HEAD(&bus->codec_list);	init_unsol_queue(bus);	if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) {		snd_hda_bus_free(bus);		return err;	}	if (busp)		*busp = bus;	return 0;}/* * find a matching codec preset */static const struct hda_codec_preset *find_codec_preset(struct hda_codec *codec){	const struct hda_codec_preset **tbl, *preset;	for (tbl = hda_preset_tables; *tbl; tbl++) {		for (preset = *tbl; preset->id; preset++) {			u32 mask = preset->mask;			if (preset->afg && (preset->afg != codec->afg))				continue;			if (preset->mfg && (preset->mfg != codec->mfg))				continue;			if (! mask)				mask = ~0;			if (preset->id == (codec->vendor_id & mask))				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 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++) {		switch((snd_hda_param_read(codec, nid, AC_PAR_FUNCTION_TYPE) & 0xff)) {		case AC_GRP_AUDIO_FUNCTION:			codec->afg = nid;			break;		case AC_GRP_MODEM_FUNCTION:			codec->mfg = nid;			break;		default:			break;		}	}}/* * codec destructor */static void snd_hda_codec_free(struct hda_codec *codec){//printk("%s: %p\n", __FUNCTION__, codec);	if (! codec)		return;	list_del(&codec->list);	codec->bus->caddr_tbl[codec->addr] = NULL;	if (codec->patch_ops.free)