Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7639a06c authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: hda - Move a part of hda_codec stuff into hdac_device 



Now some codes and functionalities of hda_codec struct are moved to
hdac_device struct.  A few basic attributes like the codec address,
vendor ID number, FG numbers, etc are moved to hdac_device, and they
are accessed like codec->core.addr.  The basic verb exec functions are
moved, too.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent d068ebc2

include/sound/hdaudio.h

+66 −0
Original line number Diff line number Diff line
@@ -8,6 +8,9 @@ 
#include <linux/device.h>

#include <sound/hda_verbs.h>



/* codec node id */

typedef u16 hda_nid_t;



struct hdac_bus;

struct hdac_device;

struct hdac_driver;
@@ -26,6 +29,30 @@ struct hdac_device { 
	struct hdac_bus *bus;

	unsigned int addr;		/* codec address */

	struct list_head list;		/* list point for bus codec_list */



	hda_nid_t afg;			/* AFG node id */

	hda_nid_t mfg;			/* MFG node id */



	/* ids */

	unsigned int vendor_id;

	unsigned int subsystem_id;

	unsigned int revision_id;

	unsigned int afg_function_id;

	unsigned int mfg_function_id;

	unsigned int afg_unsol:1;

	unsigned int mfg_unsol:1;



	unsigned int power_caps;	/* FG power caps */



	const char *vendor_name;	/* codec vendor name */

	const char *chip_name;		/* codec chip name */



	/* widgets */

	unsigned int num_nodes;

	hda_nid_t start_nid, end_nid;



	/* misc flags */

	atomic_t in_pm;		/* suspend/resume being performed */

};



/* device/driver type used for matching */
@@ -34,8 +61,37 @@ enum { 
	HDA_DEV_LEGACY,

};



/* direction */

enum {

	HDA_INPUT, HDA_OUTPUT

};



#define dev_to_hdac_dev(_dev)	container_of(_dev, struct hdac_device, dev)



int snd_hdac_device_init(struct hdac_device *dev, struct hdac_bus *bus,

			 const char *name, unsigned int addr);

void snd_hdac_device_exit(struct hdac_device *dev);



int snd_hdac_refresh_widgets(struct hdac_device *codec);



unsigned int snd_hdac_make_cmd(struct hdac_device *codec, hda_nid_t nid,

			       unsigned int verb, unsigned int parm);

int snd_hdac_read(struct hdac_device *codec, hda_nid_t nid,

		  unsigned int verb, unsigned int parm, unsigned int *res);

int snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm);

int snd_hdac_get_connections(struct hdac_device *codec, hda_nid_t nid,

			     hda_nid_t *conn_list, int max_conns);

int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,

			   hda_nid_t *start_id);



#ifdef CONFIG_PM

void snd_hdac_power_up(struct hdac_device *codec);

void snd_hdac_power_down(struct hdac_device *codec);

#else

static inline void snd_hdac_power_up(struct hdac_device *codec) {}

static inline void snd_hdac_power_down(struct hdac_device *codec) {}

#endif



/*

 * HD-audio codec base driver

 */
@@ -100,4 +156,14 @@ int snd_hdac_bus_add_device(struct hdac_bus *bus, struct hdac_device *codec); 
void snd_hdac_bus_remove_device(struct hdac_bus *bus,

				struct hdac_device *codec);



static inline void snd_hdac_codec_link_up(struct hdac_device *codec)

{

	set_bit(codec->addr, &codec->bus->codec_powered);

}



static inline void snd_hdac_codec_link_down(struct hdac_device *codec)

{

	clear_bit(codec->addr, &codec->bus->codec_powered);

}



#endif /* __SOUND_HDAUDIO_H */

sound/hda/Makefile

+1 −1
Original line number Diff line number Diff line 
snd-hda-core-objs := hda_bus_type.o hdac_bus.o

snd-hda-core-objs := hda_bus_type.o hdac_bus.o hdac_device.o



obj-$(CONFIG_SND_HDA_CORE) += snd-hda-core.o

sound/hda/hdac_device.c

0 → 100644
+471 −0
Original line number Diff line number Diff line 
/*

 * HD-audio codec core device

 */



#include <linux/init.h>

#include <linux/device.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/export.h>

#include <linux/pm_runtime.h>

#include <sound/hdaudio.h>

#include "local.h"



static void setup_fg_nodes(struct hdac_device *codec);

static int get_codec_vendor_name(struct hdac_device *codec);



static void default_release(struct device *dev)

{

	snd_hdac_device_exit(container_of(dev, struct hdac_device, dev));

}



/**

 * snd_hdac_device_init - initialize the HD-audio codec base device

 * @codec: device to initialize

 * @bus: but to attach

 * @name: device name string

 * @addr: codec address

 *

 * Returns zero for success or a negative error code.

 *

 * This function increments the runtime PM counter and marks it active.

 * The caller needs to turn it off appropriately later.

 *

 * The caller needs to set the device's release op properly by itself.

 */

int snd_hdac_device_init(struct hdac_device *codec, struct hdac_bus *bus,

			 const char *name, unsigned int addr)

{

	struct device *dev;

	hda_nid_t fg;

	int err;



	dev = &codec->dev;

	device_initialize(dev);

	dev->parent = bus->dev;

	dev->bus = &snd_hda_bus_type;

	dev->release = default_release;

	dev_set_name(dev, "%s", name);

	device_enable_async_suspend(dev);



	codec->bus = bus;

	codec->addr = addr;

	codec->type = HDA_DEV_CORE;

	pm_runtime_set_active(&codec->dev);

	pm_runtime_get_noresume(&codec->dev);

	atomic_set(&codec->in_pm, 0);



	err = snd_hdac_bus_add_device(bus, codec);

	if (err < 0)

		goto error;



	/* fill parameters */

	codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,

					      AC_PAR_VENDOR_ID);

	if (codec->vendor_id == -1) {

		/* read again, hopefully the access method was corrected

		 * in the last read...

		 */

		codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,

						      AC_PAR_VENDOR_ID);

	}



	codec->subsystem_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,

						 AC_PAR_SUBSYSTEM_ID);

	codec->revision_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,

						AC_PAR_REV_ID);



	setup_fg_nodes(codec);

	if (!codec->afg && !codec->mfg) {

		dev_err(dev, "no AFG or MFG node found\n");

		err = -ENODEV;

		goto error;

	}



	fg = codec->afg ? codec->afg : codec->mfg;



	err = snd_hdac_refresh_widgets(codec);

	if (err < 0)

		goto error;



	codec->power_caps = snd_hdac_read_parm(codec, fg, AC_PAR_POWER_STATE);

	/* reread ssid if not set by parameter */

	if (codec->subsystem_id == -1)

		snd_hdac_read(codec, fg, AC_VERB_GET_SUBSYSTEM_ID, 0,

			      &codec->subsystem_id);



	err = get_codec_vendor_name(codec);

	if (err < 0)

		goto error;



	codec->chip_name = kasprintf(GFP_KERNEL, "ID %x",

				     codec->vendor_id & 0xffff);

	if (!codec->chip_name) {

		err = -ENOMEM;

		goto error;

	}



	return 0;



 error:

	pm_runtime_put_noidle(&codec->dev);

	put_device(&codec->dev);

	return err;

}

EXPORT_SYMBOL_GPL(snd_hdac_device_init);



/**

 * snd_hdac_device_exit - clean up the HD-audio codec base device

 * @codec: device to clean up

 */

void snd_hdac_device_exit(struct hdac_device *codec)

{

	/* pm_runtime_put_noidle(&codec->dev); */

	snd_hdac_bus_remove_device(codec->bus, codec);

	kfree(codec->vendor_name);

	kfree(codec->chip_name);

}

EXPORT_SYMBOL_GPL(snd_hdac_device_exit);



/**

 * snd_hdac_make_cmd - compose a 32bit command word to be sent to the

 *	HD-audio controller

 * @codec: the codec object

 * @nid: NID to encode

 * @verb: verb to encode

 * @parm: parameter to encode

 *

 * Return an encoded command verb or -1 for error.

 */

unsigned int snd_hdac_make_cmd(struct hdac_device *codec, hda_nid_t nid,

			       unsigned int verb, unsigned int parm)

{

	u32 val, addr;



	addr = codec->addr;

	if ((addr & ~0xf) || (nid & ~0x7f) ||

	    (verb & ~0xfff) || (parm & ~0xffff)) {

		dev_err(&codec->dev, "out of range cmd %x:%x:%x:%x\n",

			addr, nid, verb, parm);

		return -1;

	}



	val = addr << 28;

	val |= (u32)nid << 20;

	val |= verb << 8;

	val |= parm;

	return val;

}

EXPORT_SYMBOL_GPL(snd_hdac_make_cmd);



/**

 * snd_hdac_read - execute a verb

 * @codec: the codec object

 * @nid: NID to execute a verb

 * @verb: verb to execute

 * @parm: parameter for a verb

 * @res: the pointer to store the result, NULL if running async

 *

 * Returns zero if successful, or a negative error code.

 */

int snd_hdac_read(struct hdac_device *codec, hda_nid_t nid,

		  unsigned int verb, unsigned int parm, unsigned int *res)

{

	unsigned int cmd = snd_hdac_make_cmd(codec, nid, verb, parm);



	return snd_hdac_bus_exec_verb(codec->bus, codec->addr, cmd, res);

}

EXPORT_SYMBOL_GPL(snd_hdac_read);



/**

 * snd_hdac_read_parm - read a codec parameter

 * @codec: the codec object

 * @nid: NID to read a parameter

 * @parm: parameter to read

 *

 * Returns -1 for error.  If you need to distinguish the error more

 * strictly, use snd_hdac_read() directly.

 */

int snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm)

{

	int val;



	if (snd_hdac_read(codec, nid, AC_VERB_PARAMETERS, parm, &val))

		return -1;

	return val;

}

EXPORT_SYMBOL_GPL(snd_hdac_read_parm);



/**

 * snd_hdac_get_sub_nodes - get start NID and number of subtree nodes

 * @codec: the codec object

 * @nid: NID to inspect

 * @start_id: the pointer to store the starting NID

 *

 * Returns the number of subtree nodes or zero if not found.

 */

int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,

			   hda_nid_t *start_id)

{

	unsigned int parm;



	parm = snd_hdac_read_parm(codec, nid, AC_PAR_NODE_COUNT);

	if (parm == -1) {

		*start_id = 0;

		return 0;

	}

	*start_id = (parm >> 16) & 0x7fff;

	return (int)(parm & 0x7fff);

}

EXPORT_SYMBOL_GPL(snd_hdac_get_sub_nodes);



/*

 * look for an AFG and MFG nodes

 */

static void setup_fg_nodes(struct hdac_device *codec)

{

	int i, total_nodes, function_id;

	hda_nid_t nid;



	total_nodes = snd_hdac_get_sub_nodes(codec, AC_NODE_ROOT, &nid);

	for (i = 0; i < total_nodes; i++, nid++) {

		function_id = snd_hdac_read_parm(codec, nid,

						 AC_PAR_FUNCTION_TYPE);

		switch (function_id & 0xff) {

		case AC_GRP_AUDIO_FUNCTION:

			codec->afg = nid;

			codec->afg_function_id = function_id & 0xff;

			codec->afg_unsol = (function_id >> 8) & 1;

			break;

		case AC_GRP_MODEM_FUNCTION:

			codec->mfg = nid;

			codec->mfg_function_id = function_id & 0xff;

			codec->mfg_unsol = (function_id >> 8) & 1;

			break;

		default:

			break;

		}

	}

}



/**

 * snd_hdac_refresh_widgets - Reset the widget start/end nodes

 * @codec: the codec object

 */

int snd_hdac_refresh_widgets(struct hdac_device *codec)

{

	hda_nid_t start_nid;

	int nums;



	nums = snd_hdac_get_sub_nodes(codec, codec->afg, &start_nid);

	if (!start_nid || nums <= 0 || nums >= 0xff) {

		dev_err(&codec->dev, "cannot read sub nodes for FG 0x%02x\n",

			codec->afg);

		return -EINVAL;

	}



	codec->num_nodes = nums;

	codec->start_nid = start_nid;

	codec->end_nid = start_nid + nums;

	return 0;

}

EXPORT_SYMBOL_GPL(snd_hdac_refresh_widgets);



/* return CONNLIST_LEN parameter of the given widget */

static unsigned int get_num_conns(struct hdac_device *codec, hda_nid_t nid)

{

	unsigned int wcaps = get_wcaps(codec, nid);

	unsigned int parm;



	if (!(wcaps & AC_WCAP_CONN_LIST) &&

	    get_wcaps_type(wcaps) != AC_WID_VOL_KNB)

		return 0;



	parm = snd_hdac_read_parm(codec, nid, AC_PAR_CONNLIST_LEN);

	if (parm == -1)

		parm = 0;

	return parm;

}



/**

 * snd_hdac_get_connections - get a widget connection list

 * @codec: the codec object

 * @nid: NID

 * @conn_list: the array to store the results, can be NULL

 * @max_conns: the max size of the given array

 *

 * Returns the number of connected widgets, zero for no connection, or a

 * negative error code.  When the number of elements don't fit with the

 * given array size, it returns -ENOSPC.

 *

 * When @conn_list is NULL, it just checks the number of connections.

 */

int snd_hdac_get_connections(struct hdac_device *codec, hda_nid_t nid,

			     hda_nid_t *conn_list, int max_conns)

{

	unsigned int parm;

	int i, conn_len, conns, err;

	unsigned int shift, num_elems, mask;

	hda_nid_t prev_nid;

	int null_count = 0;



	parm = get_num_conns(codec, nid);

	if (!parm)

		return 0;



	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 */

		err = snd_hdac_read(codec, nid, AC_VERB_GET_CONNECT_LIST, 0,

				    &parm);

		if (err < 0)

			return err;

		if (conn_list)

			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) {

			err = snd_hdac_read(codec, nid,

					    AC_VERB_GET_CONNECT_LIST, i,

					    &parm);

			if (err < 0)

				return -EIO;

		}

		range_val = !!(parm & (1 << (shift-1))); /* ranges */

		val = parm & mask;

		if (val == 0 && null_count++) {  /* no second chance */

			dev_dbg(&codec->dev,

				"invalid CONNECT_LIST verb %x[%i]:%x\n",

				nid, i, parm);

			return 0;

		}

		parm >>= shift;

		if (range_val) {

			/* ranges between the previous and this one */

			if (!prev_nid || prev_nid >= val) {

				dev_warn(&codec->dev,

					 "invalid dep_range_val %x:%x\n",

					 prev_nid, val);

				continue;

			}

			for (n = prev_nid + 1; n <= val; n++) {

				if (conn_list) {

					if (conns >= max_conns)

						return -ENOSPC;

					conn_list[conns] = n;

				}

				conns++;

			}

		} else {

			if (conn_list) {

				if (conns >= max_conns)

					return -ENOSPC;

				conn_list[conns] = val;

			}

			conns++;

		}

		prev_nid = val;

	}

	return conns;

}

EXPORT_SYMBOL_GPL(snd_hdac_get_connections);



#ifdef CONFIG_PM

/**

 * snd_hdac_power_up - increment the runtime pm counter

 * @codec: the codec object

 */

void snd_hdac_power_up(struct hdac_device *codec)

{

	struct device *dev = &codec->dev;



	if (atomic_read(&codec->in_pm))

		return;

	pm_runtime_get_sync(dev);

}

EXPORT_SYMBOL_GPL(snd_hdac_power_up);



/**

 * snd_hdac_power_up - decrement the runtime pm counter

 * @codec: the codec object

 */

void snd_hdac_power_down(struct hdac_device *codec)

{

	struct device *dev = &codec->dev;



	if (atomic_read(&codec->in_pm))

		return;

	pm_runtime_mark_last_busy(dev);

	pm_runtime_put_autosuspend(dev);

}

EXPORT_SYMBOL_GPL(snd_hdac_power_down);

#endif



/* codec vendor labels */

struct hda_vendor_id {

	unsigned int id;

	const char *name;

};



static struct hda_vendor_id hda_vendor_ids[] = {

	{ 0x1002, "ATI" },

	{ 0x1013, "Cirrus Logic" },

	{ 0x1057, "Motorola" },

	{ 0x1095, "Silicon Image" },

	{ 0x10de, "Nvidia" },

	{ 0x10ec, "Realtek" },

	{ 0x1102, "Creative" },

	{ 0x1106, "VIA" },

	{ 0x111d, "IDT" },

	{ 0x11c1, "LSI" },

	{ 0x11d4, "Analog Devices" },

	{ 0x13f6, "C-Media" },

	{ 0x14f1, "Conexant" },

	{ 0x17e8, "Chrontel" },

	{ 0x1854, "LG" },

	{ 0x1aec, "Wolfson Microelectronics" },

	{ 0x1af4, "QEMU" },

	{ 0x434d, "C-Media" },

	{ 0x8086, "Intel" },

	{ 0x8384, "SigmaTel" },

	{} /* terminator */

};



/* store the codec vendor name */

static int get_codec_vendor_name(struct hdac_device *codec)

{

	const struct hda_vendor_id *c;

	u16 vendor_id = codec->vendor_id >> 16;



	for (c = hda_vendor_ids; c->id; c++) {

		if (c->id == vendor_id) {

			codec->vendor_name = kstrdup(c->name, GFP_KERNEL);

			return codec->vendor_name ? 0 : -ENOMEM;

		}

	}



	codec->vendor_name = kasprintf(GFP_KERNEL, "Generic %04x", vendor_id);

	return codec->vendor_name ? 0 : -ENOMEM;

}

sound/hda/local.h

0 → 100644
+19 −0
Original line number Diff line number Diff line 
/*

 * Local helper macros and functions for HD-audio core drivers

 */



#ifndef __HDAC_LOCAL_H

#define __HDAC_LOCAL_H



#define get_wcaps(codec, nid) \

	snd_hdac_read_parm(codec, nid, AC_PAR_AUDIO_WIDGET_CAP)



/* get the widget type from widget capability bits */

static inline int get_wcaps_type(unsigned int wcaps)

{

	if (!wcaps)

		return -1; /* invalid type */

	return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;

}



#endif /* __HDAC_LOCAL_H */

sound/pci/hda/hda_auto_parser.c

+16 −17
Original line number Diff line number Diff line
@@ -172,7 +172,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec, 
			     const hda_nid_t *ignore_nids,

			     unsigned int cond_flags)

{

	hda_nid_t nid, end_nid;

	hda_nid_t nid;

	short seq, assoc_line_out;

	struct auto_out_pin line_out[ARRAY_SIZE(cfg->line_out_pins)];

	struct auto_out_pin speaker_out[ARRAY_SIZE(cfg->speaker_pins)];
@@ -189,8 +189,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec, 
	memset(hp_out, 0, sizeof(hp_out));

	assoc_line_out = 0;



	end_nid = codec->start_nid + codec->num_nodes;

	for (nid = codec->start_nid; nid < end_nid; nid++) {

	for_each_hda_codec_node(nid, codec) {

		unsigned int wid_caps = get_wcaps(codec, nid);

		unsigned int wid_type = get_wcaps_type(wid_caps);

		unsigned int def_conf;
@@ -410,7 +409,7 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec, 
	 * debug prints of the parsed results

	 */

	codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",

		   codec->chip_name, cfg->line_outs, cfg->line_out_pins[0],

		   codec->core.chip_name, cfg->line_outs, cfg->line_out_pins[0],

		   cfg->line_out_pins[1], cfg->line_out_pins[2],

		   cfg->line_out_pins[3], cfg->line_out_pins[4],

		   cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
@@ -836,33 +835,33 @@ static void apply_fixup(struct hda_codec *codec, int id, int action, int depth) 
			if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins)

				break;

			codec_dbg(codec, "%s: Apply pincfg for %s\n",

				    codec->chip_name, modelname);

				    codec->core.chip_name, modelname);

			snd_hda_apply_pincfgs(codec, fix->v.pins);

			break;

		case HDA_FIXUP_VERBS:

			if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs)

				break;

			codec_dbg(codec, "%s: Apply fix-verbs for %s\n",

				    codec->chip_name, modelname);

				    codec->core.chip_name, modelname);

			snd_hda_add_verbs(codec, fix->v.verbs);

			break;

		case HDA_FIXUP_FUNC:

			if (!fix->v.func)

				break;

			codec_dbg(codec, "%s: Apply fix-func for %s\n",

				    codec->chip_name, modelname);

				    codec->core.chip_name, modelname);

			fix->v.func(codec, fix, action);

			break;

		case HDA_FIXUP_PINCTLS:

			if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins)

				break;

			codec_dbg(codec, "%s: Apply pinctl for %s\n",

				    codec->chip_name, modelname);

				    codec->core.chip_name, modelname);

			set_pin_targets(codec, fix->v.pins);

			break;

		default:

			codec_err(codec, "%s: Invalid fixup type %d\n",

				   codec->chip_name, fix->type);

				   codec->core.chip_name, fix->type);

			break;

		}

		if (!fix->chained || fix->chained_before)
@@ -912,16 +911,16 @@ void snd_hda_pick_pin_fixup(struct hda_codec *codec, 
		return;



	for (pq = pin_quirk; pq->subvendor; pq++) {

		if ((codec->subsystem_id & 0xffff0000) != (pq->subvendor << 16))

		if ((codec->core.subsystem_id & 0xffff0000) != (pq->subvendor << 16))

			continue;

		if (codec->vendor_id != pq->codec)

		if (codec->core.vendor_id != pq->codec)

			continue;

		if (pin_config_match(codec, pq->pins)) {

			codec->fixup_id = pq->value;

#ifdef CONFIG_SND_DEBUG_VERBOSE

			codec->fixup_name = pq->name;

			codec_dbg(codec, "%s: picked fixup %s (pin match)\n",

				  codec->chip_name, codec->fixup_name);

				  codec->core.chip_name, codec->fixup_name);

#endif

			codec->fixup_list = fixlist;

			return;
@@ -963,7 +962,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec, 
		codec->fixup_name = NULL;

		codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;

		codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",

			  codec->chip_name);

			  codec->core.chip_name);

		return;

	}
@@ -974,7 +973,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec, 
				codec->fixup_name = models->name;

				codec->fixup_list = fixlist;

				codec_dbg(codec, "%s: picked fixup %s (model specified)\n",

					  codec->chip_name, codec->fixup_name);

					  codec->core.chip_name, codec->fixup_name);

				return;

			}

			models++;
@@ -987,7 +986,7 @@ void snd_hda_pick_fixup(struct hda_codec *codec, 
#ifdef CONFIG_SND_DEBUG_VERBOSE

			name = q->name;

			codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",

				  codec->chip_name, name, q->subdevice_mask ? "" : " - vendor generic");

				  codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic");

#endif

		}

	}
@@ -996,12 +995,12 @@ void snd_hda_pick_fixup(struct hda_codec *codec, 
			unsigned int vendorid =

				q->subdevice | (q->subvendor << 16);

			unsigned int mask = 0xffff0000 | q->subdevice_mask;

			if ((codec->subsystem_id & mask) == (vendorid & mask)) {

			if ((codec->core.subsystem_id & mask) == (vendorid & mask)) {

				id = q->value;

#ifdef CONFIG_SND_DEBUG_VERBOSE

				name = q->name;

				codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",

					  codec->chip_name, name);

					  codec->core.chip_name, name);

#endif

				break;

			}