litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Takashi Iwai <tiwai@suse.de>	2008-05-23 11:50:27 -0400
committer	Takashi Iwai <tiwai@suse.de>	2008-05-24 12:23:35 -0400
commit	bc9b56238eedda865070dcaed6694d65b517c8d6 (patch)
tree	b8bc9876c4f1ad588439f585f2253a1b09d42410 /sound
parent	b9e16bc548600124da9d24186364ee8d06040569 (diff)

[ALSA] hda - Fix noise on VT1708 codec

We get quite noisy output on the right channel on VT1708 codec when 24bit samples are used. Suppress the 24bit support until any real fix is found. https://bugzilla.novell.com/show_bug.cgi?id=390473 Signed-off-by: Takashi Iwai <tiwai@suse.de>

Diffstat (limited to 'sound')

-rw-r--r--

sound/pci/hda/patch_via.c

1 files changed, 20 insertions, 0 deletions


diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index 52b1d81a26f7..e7e43524f8c7 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c
@@ -447,6 +447,23 @@ static struct hda_pcm_stream vt1708_pcm_analog_playback = {
447	},	447	},
448	};	448	};
449		449
		450	static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
		451	.substreams = 1,
		452	.channels_min = 2,
		453	.channels_max = 8,
		454	.nid = 0x10, /* NID to query formats and rates */
		455	/* We got noisy outputs on the right channel on VT1708 when
		456	* 24bit samples are used. Until any workaround is found,
		457	* disable the 24bit format, so far.
		458	*/
		459	.formats = SNDRV_PCM_FMTBIT_S16_LE,
		460	.ops = {
		461	.open = via_playback_pcm_open,
		462	.prepare = via_playback_pcm_prepare,
		463	.cleanup = via_playback_pcm_cleanup
		464	},
		465	};
		466
450	static struct hda_pcm_stream vt1708_pcm_analog_capture = {	467	static struct hda_pcm_stream vt1708_pcm_analog_capture = {
451	.substreams = 2,	468	.substreams = 2,
452	.channels_min = 2,	469	.channels_min = 2,
@@ -899,6 +916,9 @@ static int patch_vt1708(struct hda_codec *codec)
899		916
900	spec->stream_name_analog = "VT1708 Analog";	917	spec->stream_name_analog = "VT1708 Analog";
901	spec->stream_analog_playback = &vt1708_pcm_analog_playback;	918	spec->stream_analog_playback = &vt1708_pcm_analog_playback;
		919	/* disable 32bit format on VT1708 */
		920	if (codec->vendor_id == 0x11061708)
		921	spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
902	spec->stream_analog_capture = &vt1708_pcm_analog_capture;	922	spec->stream_analog_capture = &vt1708_pcm_analog_capture;
903		923
904	spec->stream_name_digital = "VT1708 Digital";	924	spec->stream_name_digital = "VT1708 Digital";

/* * Copyright (C) 2011 STRATO. All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License v2 as published by the Free Software Foundation. * * This program 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 021110-1307, USA. */ #include "ctree.h" #include "disk-io.h" #include "backref.h" #include "ulist.h" #include "transaction.h" #include "delayed-ref.h" /* * this structure records all encountered refs on the way up to the root */ struct __prelim_ref { struct list_head list; u64 root_id; struct btrfs_key key; int level; int count; u64 parent; u64 wanted_disk_byte; }; static int __add_prelim_ref(struct list_head *head, u64 root_id, struct btrfs_key *key, int level, u64 parent, u64 wanted_disk_byte, int count) { struct __prelim_ref *ref; /* in case we're adding delayed refs, we're holding the refs spinlock */ ref = kmalloc(sizeof(*ref), GFP_ATOMIC); if (!ref) return -ENOMEM; ref->root_id = root_id; if (key) ref->key = *key; else memset(&ref->key, 0, sizeof(ref->key)); ref->level = level; ref->count = count; ref->parent = parent; ref->wanted_disk_byte = wanted_disk_byte; list_add_tail(&ref->list, head); return 0; } static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path, struct ulist *parents, struct extent_buffer *eb, int level, u64 wanted_objectid, u64 wanted_disk_byte) { int ret; int slot; struct btrfs_file_extent_item *fi; struct btrfs_key key; u64 disk_byte; add_parent: ret = ulist_add(parents, eb->start, 0, GFP_NOFS); if (ret < 0) return ret; if (level != 0) return 0; /* * if the current leaf is full with EXTENT_DATA items, we must * check the next one if that holds a reference as well. * ref->count cannot be used to skip this check. * repeat this until we don't find any additional EXTENT_DATA items. */ while (1) { ret = btrfs_next_leaf(root, path); if (ret < 0) return ret; if (ret) return 0; eb = path->nodes[0]; for (slot = 0; slot < btrfs_header_nritems(eb); ++slot) { btrfs_item_key_to_cpu(eb, &key, slot); if (key.objectid != wanted_objectid || key.type != BTRFS_EXTENT_DATA_KEY) return 0; fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); disk_byte = btrfs_file_extent_disk_bytenr(eb, fi); if (disk_byte == wanted_disk_byte) goto add_parent; } } return 0; } /* * resolve an indirect backref in the form (root_id, key, level) * to a logical address */ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info, int search_commit_root, struct __prelim_ref *ref, struct ulist *parents) { struct btrfs_path *path; struct btrfs_root *root; struct btrfs_key root_key; struct btrfs_key key = {0}; struct extent_buffer *eb; int ret = 0; int root_level; int level = ref->level; path = btrfs_alloc_path(); if (!path) return -ENOMEM; path->search_commit_root = !!search_commit_root; root_key.objectid = ref->root_id; root_key.type = BTRFS_ROOT_ITEM_KEY; root_key.offset = (u64)-1; root = btrfs_read_fs_root_no_name(fs_info, &root_key); if (IS_ERR(root)) { ret = PTR_ERR(root); goto out; } rcu_read_lock(); root_level = btrfs_header_level(root->node); rcu_read_unlock(); if (root_level + 1 == level) goto out; path->lowest_level = level; ret = btrfs_search_slot(NULL, root, &ref->key, path, 0, 0); pr_debug("search slot in root %llu (level %d, ref count %d) returned " "%d for key (%llu %u %llu)\n", (unsigned long long)ref->root_id, level, ref->count, ret, (unsigned long long)ref->key.objectid, ref->key.type, (unsigned long long)ref->key.offset); if (ret < 0) goto out; eb = path->nodes[level]; if (!eb) { WARN_ON(1); ret = 1; goto out; } if (level == 0) { if (ret == 1 && path->slots[0] >= btrfs_header_nritems(eb)) { ret = btrfs_next_leaf(root, path); if (ret) goto out; eb = path->nodes[0]; } btrfs_item_key_to_cpu(eb, &key, path->slots[0]); } /* the last two parameters will only be used for level == 0 */ ret = add_all_parents(root, path, parents, eb, level, key.objectid, ref->wanted_disk_byte); out: btrfs_free_path(path); return ret; } /* * resolve all indirect backrefs from the list */ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info, int search_commit_root, struct list_head *head) { int err; int ret = 0; struct __prelim_ref *ref; struct __prelim_ref *ref_safe; struct __prelim_ref *new_ref; struct ulist *parents; struct ulist_node *node; parents = ulist_alloc(GFP_NOFS); if (!parents) return -ENOMEM; /* * _safe allows us to insert directly after the current item without * iterating over the newly inserted items. * we're also allowed to re-assign ref during iteration. */ list_for_each_entry_safe(ref, ref_safe, head, list) { if (ref->parent) /* already direct */ continue; if (ref->count == 0) continue; err = __resolve_indirect_ref(fs_info, search_commit_root, ref, parents); if (err) { if (ret == 0) ret = err; continue; } /* we put the first parent into the ref at hand */ node = ulist_next(parents, NULL); ref->parent = node ? node->val : 0; /* additional parents require new refs being added here */ while ((node = ulist_next(parents, node))) { new_ref = kmalloc(sizeof(*new_ref), GFP_NOFS); if (!new_ref) { ret = -ENOMEM; break; } memcpy(new_ref, ref, sizeof(*ref)); new_ref->parent = node->val; list_add(&new_ref->list, &ref->list); } ulist_reinit(parents); } ulist_free(parents); return ret; } /* * merge two lists of backrefs and adjust counts accordingly * * mode = 1: merge identical keys, if key is set * mode = 2: merge identical parents */ static int __merge_refs(struct list_head *head, int mode) { struct list_head *pos1; list_for_each(pos1, head) { struct list_head *n2; struct list_head *pos2; struct __prelim_ref *ref1; ref1 = list_entry(pos1, struct __prelim_ref, list); if (mode == 1 && ref1->key.type == 0) continue; for (pos2 = pos1->next, n2 = pos2->next; pos2 != head; pos2 = n2, n2 = pos2->next) { struct __prelim_ref *ref2; ref2 = list_entry(pos2, struct __prelim_ref, list); if (mode == 1) { if (memcmp(&ref1->key, &ref2->key, sizeof(ref1->key)) || ref1->level != ref2->level || ref1->root_id != ref2->root_id) continue; ref1->count += ref2->count; } else { if (ref1->parent != ref2->parent) continue; ref1->count += ref2->count; } list_del(&ref2->list); kfree(ref2); } } return 0; } /* * add all currently queued delayed refs from this head whose seq nr is * smaller or equal that seq to the list */ static int __add_delayed_refs(struct btrfs_delayed_ref_head *head, u64 seq, struct btrfs_key *info_key, struct list_head *prefs) { struct btrfs_delayed_extent_op *extent_op = head->extent_op; struct rb_node *n = &head->node.rb_node; int sgn; int ret = 0; if (extent_op && extent_op->update_key) btrfs_disk_key_to_cpu(info_key, &extent_op->key); while ((n = rb_prev(n))) { struct btrfs_delayed_ref_node *node; node = rb_entry(n, struct btrfs_delayed_ref_node, rb_node); if (node->bytenr != head->node.bytenr) break; WARN_ON(node->is_head); if (node->seq > seq) continue; switch (node->action) { case BTRFS_ADD_DELAYED_EXTENT: case BTRFS_UPDATE_DELAYED_HEAD: WARN_ON(1); continue; case BTRFS_ADD_DELAYED_REF: sgn = 1; break; case BTRFS_DROP_DELAYED_REF: sgn = -1; break; default: BUG_ON(1); } switch (node->type) { case BTRFS_TREE_BLOCK_REF_KEY: { struct btrfs_delayed_tree_ref *ref; ref = btrfs_delayed_node_to_tree_ref(node); ret = __add_prelim_ref(prefs, ref->root, info_key, ref->level + 1, 0, node->bytenr, node->ref_mod * sgn); break; } case BTRFS_SHARED_BLOCK_REF_KEY: { struct btrfs_delayed_tree_ref *ref; ref = btrfs_delayed_node_to_tree_ref(node); ret = __add_prelim_ref(prefs, ref->root, info_key, ref->level + 1, ref->parent, node->bytenr, node->ref_mod * sgn); break; } case BTRFS_EXTENT_DATA_REF_KEY: { struct btrfs_delayed_data_ref *ref; struct btrfs_key key; ref = btrfs_delayed_node_to_data_ref(node); key.objectid = ref->objectid; key.type = BTRFS_EXTENT_DATA_KEY; key.offset = ref->offset; ret = __add_prelim_ref(prefs, ref->root, &key, 0, 0, node->bytenr, node->ref_mod * sgn); break; } case BTRFS_SHARED_DATA_REF_KEY: { struct btrfs_delayed_data_ref *ref; struct btrfs_key key;


context:
space:
mode: