mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-03 02:49:09 +08:00
sound fixes for 5.16-rc1
A collection of fixes for 5.16-rc1, notably for a few regressions
that were found in 5.15 and pre-rc1.
- The revert of the unification of SG-buffer helper functions on
x86 and the relevant fix
- Regression fixes for mmap after the recent code refactoring
- Two NULL dereference fixes in HD-audio controller driver
- UAF fixes in ALSA timer core
- A few usual HD-audio and FireWire quirks
-----BEGIN PGP SIGNATURE-----
iQJBBAABCAAsFiEEIXTw5fNLNI7mMiVaLtJE4w1nLE8FAmGOJRoOHHRpd2FpQHN1
c2UuZGUACgkQLtJE4w1nLE9ntg/2PGj/jGjW8ctdxGqri0LAS2w+bzdV59CTkLjL
OHjXjjP2gLt13ES42V7k3j3qPHPxv2gR6txxSRc1GuLDvTHBjBrConckTm3NWjCn
eXTAINwe/JpeRdiXfn/ddd78LgdzoyTGZgQ+8y8lEY2wijy9HAueKpxhKXHva9wT
KzQmOKonHnwp2Whz7dGjMj7Rsn2Nr+OCfcJszYtri8bHso0ixFQ/8uyRopqZsFQb
nMXUdeAbWOz4jyTDWqtgaFaJiAOMV0PsnaiFl8GtIfoG3/el+L9kg1Hh4BI3Rff6
kTOP5gbwge/Ce1rSbrGJ+o4LbG3H+8y7UMt1d9sQZwIHc/eRG+8xVNPAUfIDB7Bc
OgstqWpTAREkzPwOwfQ00mXUkhPpAQK+2ZLubWHG6qO4PYisUieLpyM1vN0/Lc47
zsxJkRnxcyPxhSuqG0UPagqv/FMfUpDamVB/RsIzdnPr+t0mKIJIlnqzD1RHWcVR
wsMwzdBjXDXf9SXNPgR/Q5s5njmQAtK7yJkR3RR4+sM2SrXF5YtBPrbLu++WYMKX
2GnqS5Vd88eFWxvjOhex56jHLi8URFeCxPmTPZaFx3QJ4Maa+N9WoAFw7Gwyi3TE
wiciUfIgB/cA1y2Hy/AE1l/3qS//2hup/lMc/ON16hOU6qcSPzk29RKMGU+jknhx
zNnh+A==
=pHAV
-----END PGP SIGNATURE-----
Merge tag 'sound-fix-5.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
Pull sound fixes from Takashi Iwai:
"A collection of fixes for 5.16-rc1, notably for a few regressions that
were found in 5.15 and pre-rc1:
- revert of the unification of SG-buffer helper functions on x86 and
the relevant fix
- regression fixes for mmap after the recent code refactoring
- two NULL dereference fixes in HD-audio controller driver
- UAF fixes in ALSA timer core
- a few usual HD-audio and FireWire quirks"
* tag 'sound-fix-5.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound:
ALSA: fireworks: add support for Loud Onyx 1200f quirk
ALSA: hda: fix general protection fault in azx_runtime_idle
ALSA: hda: Free card instance properly at probe errors
ALSA: hda/realtek: Add quirk for HP EliteBook 840 G7 mute LED
ALSA: memalloc: Remove a stale comment
ALSA: synth: missing check for possible NULL after the call to kstrdup
ALSA: memalloc: Use proper SG helpers for noncontig allocations
ALSA: pci: rme: Fix unaligned buffer addresses
ALSA: firewire-motu: add support for MOTU Track 16
ALSA: PCM: Fix NULL dereference at mmap checks
ALSA: hda/realtek: Add quirk for ASUS UX550VE
ALSA: timer: Unconditionally unlink slave instances, too
ALSA: memalloc: Catch call with NULL snd_dma_buffer pointer
Revert "ALSA: memalloc: Convert x86 SG-buffer handling with non-contiguous type"
ALSA: hda/realtek: Add a quirk for Acer Spin SP513-54N
ALSA: firewire-motu: add support for MOTU Traveler mk3
ALSA: hda/realtek: Headset fixup for Clevo NH77HJQ
ALSA: timer: Fix use-after-free problem
This commit is contained in:
Linus Torvalds
commit
0d5d74634f
@ -36,6 +36,13 @@ struct snd_dma_device {
|
||||
#define SNDRV_DMA_TYPE_CONTINUOUS 1 /* continuous no-DMA memory */
|
||||
#define SNDRV_DMA_TYPE_DEV 2 /* generic device continuous */
|
||||
#define SNDRV_DMA_TYPE_DEV_WC 5 /* continuous write-combined */
|
||||
#ifdef CONFIG_SND_DMA_SGBUF
|
||||
#define SNDRV_DMA_TYPE_DEV_SG 3 /* generic device SG-buffer */
|
||||
#define SNDRV_DMA_TYPE_DEV_WC_SG 6 /* SG write-combined */
|
||||
#else
|
||||
#define SNDRV_DMA_TYPE_DEV_SG SNDRV_DMA_TYPE_DEV /* no SG-buf support */
|
||||
#define SNDRV_DMA_TYPE_DEV_WC_SG SNDRV_DMA_TYPE_DEV_WC
|
||||
#endif
|
||||
#ifdef CONFIG_GENERIC_ALLOCATOR
|
||||
#define SNDRV_DMA_TYPE_DEV_IRAM 4 /* generic device iram-buffer */
|
||||
#else
|
||||
@ -44,13 +51,6 @@ struct snd_dma_device {
|
||||
#define SNDRV_DMA_TYPE_VMALLOC 7 /* vmalloc'ed buffer */
|
||||
#define SNDRV_DMA_TYPE_NONCONTIG 8 /* non-coherent SG buffer */
|
||||
#define SNDRV_DMA_TYPE_NONCOHERENT 9 /* non-coherent buffer */
|
||||
#ifdef CONFIG_SND_DMA_SGBUF
|
||||
#define SNDRV_DMA_TYPE_DEV_SG SNDRV_DMA_TYPE_NONCONTIG
|
||||
#define SNDRV_DMA_TYPE_DEV_WC_SG 6 /* SG write-combined */
|
||||
#else
|
||||
#define SNDRV_DMA_TYPE_DEV_SG SNDRV_DMA_TYPE_DEV /* no SG-buf support */
|
||||
#define SNDRV_DMA_TYPE_DEV_WC_SG SNDRV_DMA_TYPE_DEV_WC
|
||||
#endif
|
||||
|
||||
/*
|
||||
* info for buffer allocation
|
||||
|
||||
@ -19,6 +19,7 @@ snd-$(CONFIG_SND_JACK) += ctljack.o jack.o
|
||||
snd-pcm-y := pcm.o pcm_native.o pcm_lib.o pcm_misc.o \
|
||||
pcm_memory.o memalloc.o
|
||||
snd-pcm-$(CONFIG_SND_PCM_TIMER) += pcm_timer.o
|
||||
snd-pcm-$(CONFIG_SND_DMA_SGBUF) += sgbuf.o
|
||||
snd-pcm-$(CONFIG_SND_PCM_ELD) += pcm_drm_eld.o
|
||||
snd-pcm-$(CONFIG_SND_PCM_IEC958) += pcm_iec958.o
|
||||
|
||||
|
||||
@ -183,8 +183,11 @@ EXPORT_SYMBOL_GPL(snd_devm_alloc_dir_pages);
|
||||
int snd_dma_buffer_mmap(struct snd_dma_buffer *dmab,
|
||||
struct vm_area_struct *area)
|
||||
{
|
||||
const struct snd_malloc_ops *ops = snd_dma_get_ops(dmab);
|
||||
const struct snd_malloc_ops *ops;
|
||||
|
||||
if (!dmab)
|
||||
return -ENOENT;
|
||||
ops = snd_dma_get_ops(dmab);
|
||||
if (ops && ops->mmap)
|
||||
return ops->mmap(dmab, area);
|
||||
else
|
||||
@ -549,61 +552,74 @@ static void snd_dma_noncontig_sync(struct snd_dma_buffer *dmab,
|
||||
}
|
||||
}
|
||||
|
||||
static inline void snd_dma_noncontig_iter_set(struct snd_dma_buffer *dmab,
|
||||
struct sg_page_iter *piter,
|
||||
size_t offset)
|
||||
{
|
||||
struct sg_table *sgt = dmab->private_data;
|
||||
|
||||
__sg_page_iter_start(piter, sgt->sgl, sgt->orig_nents,
|
||||
offset >> PAGE_SHIFT);
|
||||
}
|
||||
|
||||
static dma_addr_t snd_dma_noncontig_get_addr(struct snd_dma_buffer *dmab,
|
||||
size_t offset)
|
||||
{
|
||||
struct sg_dma_page_iter iter;
|
||||
|
||||
snd_dma_noncontig_iter_set(dmab, &iter.base, offset);
|
||||
__sg_page_iter_dma_next(&iter);
|
||||
return sg_page_iter_dma_address(&iter) + offset % PAGE_SIZE;
|
||||
}
|
||||
|
||||
static struct page *snd_dma_noncontig_get_page(struct snd_dma_buffer *dmab,
|
||||
size_t offset)
|
||||
{
|
||||
struct sg_page_iter iter;
|
||||
|
||||
snd_dma_noncontig_iter_set(dmab, &iter, offset);
|
||||
__sg_page_iter_next(&iter);
|
||||
return sg_page_iter_page(&iter);
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
snd_dma_noncontig_get_chunk_size(struct snd_dma_buffer *dmab,
|
||||
unsigned int ofs, unsigned int size)
|
||||
{
|
||||
struct sg_dma_page_iter iter;
|
||||
unsigned int start, end;
|
||||
unsigned long addr;
|
||||
|
||||
start = ALIGN_DOWN(ofs, PAGE_SIZE);
|
||||
end = ofs + size - 1; /* the last byte address */
|
||||
snd_dma_noncontig_iter_set(dmab, &iter.base, start);
|
||||
if (!__sg_page_iter_dma_next(&iter))
|
||||
return 0;
|
||||
/* check page continuity */
|
||||
addr = sg_page_iter_dma_address(&iter);
|
||||
for (;;) {
|
||||
start += PAGE_SIZE;
|
||||
if (start > end)
|
||||
break;
|
||||
addr += PAGE_SIZE;
|
||||
if (!__sg_page_iter_dma_next(&iter) ||
|
||||
sg_page_iter_dma_address(&iter) != addr)
|
||||
return start - ofs;
|
||||
}
|
||||
/* ok, all on continuous pages */
|
||||
return size;
|
||||
}
|
||||
|
||||
static const struct snd_malloc_ops snd_dma_noncontig_ops = {
|
||||
.alloc = snd_dma_noncontig_alloc,
|
||||
.free = snd_dma_noncontig_free,
|
||||
.mmap = snd_dma_noncontig_mmap,
|
||||
.sync = snd_dma_noncontig_sync,
|
||||
/* re-use vmalloc helpers for get_* ops */
|
||||
.get_addr = snd_dma_vmalloc_get_addr,
|
||||
.get_page = snd_dma_vmalloc_get_page,
|
||||
.get_chunk_size = snd_dma_vmalloc_get_chunk_size,
|
||||
.get_addr = snd_dma_noncontig_get_addr,
|
||||
.get_page = snd_dma_noncontig_get_page,
|
||||
.get_chunk_size = snd_dma_noncontig_get_chunk_size,
|
||||
};
|
||||
|
||||
/* x86-specific SG-buffer with WC pages */
|
||||
#ifdef CONFIG_SND_DMA_SGBUF
|
||||
#define vmalloc_to_virt(v) (unsigned long)page_to_virt(vmalloc_to_page(v))
|
||||
|
||||
static void *snd_dma_sg_wc_alloc(struct snd_dma_buffer *dmab, size_t size)
|
||||
{
|
||||
void *p = snd_dma_noncontig_alloc(dmab, size);
|
||||
size_t ofs;
|
||||
|
||||
if (!p)
|
||||
return NULL;
|
||||
for (ofs = 0; ofs < size; ofs += PAGE_SIZE)
|
||||
set_memory_uc(vmalloc_to_virt(p + ofs), 1);
|
||||
return p;
|
||||
}
|
||||
|
||||
static void snd_dma_sg_wc_free(struct snd_dma_buffer *dmab)
|
||||
{
|
||||
size_t ofs;
|
||||
|
||||
for (ofs = 0; ofs < dmab->bytes; ofs += PAGE_SIZE)
|
||||
set_memory_wb(vmalloc_to_virt(dmab->area + ofs), 1);
|
||||
snd_dma_noncontig_free(dmab);
|
||||
}
|
||||
|
||||
static int snd_dma_sg_wc_mmap(struct snd_dma_buffer *dmab,
|
||||
struct vm_area_struct *area)
|
||||
{
|
||||
area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
|
||||
/* FIXME: dma_mmap_noncontiguous() works? */
|
||||
return -ENOENT; /* continue with the default mmap handler */
|
||||
}
|
||||
|
||||
const struct snd_malloc_ops snd_dma_sg_wc_ops = {
|
||||
.alloc = snd_dma_sg_wc_alloc,
|
||||
.free = snd_dma_sg_wc_free,
|
||||
.mmap = snd_dma_sg_wc_mmap,
|
||||
.sync = snd_dma_noncontig_sync,
|
||||
.get_addr = snd_dma_vmalloc_get_addr,
|
||||
.get_page = snd_dma_vmalloc_get_page,
|
||||
.get_chunk_size = snd_dma_vmalloc_get_chunk_size,
|
||||
};
|
||||
#endif /* CONFIG_SND_DMA_SGBUF */
|
||||
|
||||
/*
|
||||
* Non-coherent pages allocator
|
||||
*/
|
||||
@ -663,17 +679,20 @@ static const struct snd_malloc_ops *dma_ops[] = {
|
||||
[SNDRV_DMA_TYPE_DEV_WC] = &snd_dma_wc_ops,
|
||||
[SNDRV_DMA_TYPE_NONCONTIG] = &snd_dma_noncontig_ops,
|
||||
[SNDRV_DMA_TYPE_NONCOHERENT] = &snd_dma_noncoherent_ops,
|
||||
#ifdef CONFIG_SND_DMA_SGBUF
|
||||
[SNDRV_DMA_TYPE_DEV_WC_SG] = &snd_dma_sg_wc_ops,
|
||||
#endif
|
||||
#ifdef CONFIG_GENERIC_ALLOCATOR
|
||||
[SNDRV_DMA_TYPE_DEV_IRAM] = &snd_dma_iram_ops,
|
||||
#endif /* CONFIG_GENERIC_ALLOCATOR */
|
||||
#endif /* CONFIG_HAS_DMA */
|
||||
#ifdef CONFIG_SND_DMA_SGBUF
|
||||
[SNDRV_DMA_TYPE_DEV_SG] = &snd_dma_sg_ops,
|
||||
[SNDRV_DMA_TYPE_DEV_WC_SG] = &snd_dma_sg_ops,
|
||||
#endif
|
||||
};
|
||||
|
||||
static const struct snd_malloc_ops *snd_dma_get_ops(struct snd_dma_buffer *dmab)
|
||||
{
|
||||
if (WARN_ON_ONCE(!dmab))
|
||||
return NULL;
|
||||
if (WARN_ON_ONCE(dmab->dev.type <= SNDRV_DMA_TYPE_UNKNOWN ||
|
||||
dmab->dev.type >= ARRAY_SIZE(dma_ops)))
|
||||
return NULL;
|
||||
|
||||
201
sound/core/sgbuf.c
Normal file
201
sound/core/sgbuf.c
Normal file
@ -0,0 +1,201 @@
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
/*
|
||||
* Scatter-Gather buffer
|
||||
*
|
||||
* Copyright (c) by Takashi Iwai <tiwai@suse.de>
|
||||
*/
|
||||
|
||||
#include <linux/slab.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/export.h>
|
||||
#include <sound/memalloc.h>
|
||||
#include "memalloc_local.h"
|
||||
|
||||
struct snd_sg_page {
|
||||
void *buf;
|
||||
dma_addr_t addr;
|
||||
};
|
||||
|
||||
struct snd_sg_buf {
|
||||
int size; /* allocated byte size */
|
||||
int pages; /* allocated pages */
|
||||
int tblsize; /* allocated table size */
|
||||
struct snd_sg_page *table; /* address table */
|
||||
struct page **page_table; /* page table (for vmap/vunmap) */
|
||||
struct device *dev;
|
||||
};
|
||||
|
||||
/* table entries are align to 32 */
|
||||
#define SGBUF_TBL_ALIGN 32
|
||||
#define sgbuf_align_table(tbl) ALIGN((tbl), SGBUF_TBL_ALIGN)
|
||||
|
||||
static void snd_dma_sg_free(struct snd_dma_buffer *dmab)
|
||||
{
|
||||
struct snd_sg_buf *sgbuf = dmab->private_data;
|
||||
struct snd_dma_buffer tmpb;
|
||||
int i;
|
||||
|
||||
if (!sgbuf)
|
||||
return;
|
||||
|
||||
vunmap(dmab->area);
|
||||
dmab->area = NULL;
|
||||
|
||||
tmpb.dev.type = SNDRV_DMA_TYPE_DEV;
|
||||
if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
|
||||
tmpb.dev.type = SNDRV_DMA_TYPE_DEV_WC;
|
||||
tmpb.dev.dev = sgbuf->dev;
|
||||
for (i = 0; i < sgbuf->pages; i++) {
|
||||
if (!(sgbuf->table[i].addr & ~PAGE_MASK))
|
||||
continue; /* continuous pages */
|
||||
tmpb.area = sgbuf->table[i].buf;
|
||||
tmpb.addr = sgbuf->table[i].addr & PAGE_MASK;
|
||||
tmpb.bytes = (sgbuf->table[i].addr & ~PAGE_MASK) << PAGE_SHIFT;
|
||||
snd_dma_free_pages(&tmpb);
|
||||
}
|
||||
|
||||
kfree(sgbuf->table);
|
||||
kfree(sgbuf->page_table);
|
||||
kfree(sgbuf);
|
||||
dmab->private_data = NULL;
|
||||
}
|
||||
|
||||
#define MAX_ALLOC_PAGES 32
|
||||
|
||||
static void *snd_dma_sg_alloc(struct snd_dma_buffer *dmab, size_t size)
|
||||
{
|
||||
struct snd_sg_buf *sgbuf;
|
||||
unsigned int i, pages, chunk, maxpages;
|
||||
struct snd_dma_buffer tmpb;
|
||||
struct snd_sg_page *table;
|
||||
struct page **pgtable;
|
||||
int type = SNDRV_DMA_TYPE_DEV;
|
||||
pgprot_t prot = PAGE_KERNEL;
|
||||
void *area;
|
||||
|
||||
dmab->private_data = sgbuf = kzalloc(sizeof(*sgbuf), GFP_KERNEL);
|
||||
if (!sgbuf)
|
||||
return NULL;
|
||||
if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG) {
|
||||
type = SNDRV_DMA_TYPE_DEV_WC;
|
||||
#ifdef pgprot_noncached
|
||||
prot = pgprot_noncached(PAGE_KERNEL);
|
||||
#endif
|
||||
}
|
||||
sgbuf->dev = dmab->dev.dev;
|
||||
pages = snd_sgbuf_aligned_pages(size);
|
||||
sgbuf->tblsize = sgbuf_align_table(pages);
|
||||
table = kcalloc(sgbuf->tblsize, sizeof(*table), GFP_KERNEL);
|
||||
if (!table)
|
||||
goto _failed;
|
||||
sgbuf->table = table;
|
||||
pgtable = kcalloc(sgbuf->tblsize, sizeof(*pgtable), GFP_KERNEL);
|
||||
if (!pgtable)
|
||||
goto _failed;
|
||||
sgbuf->page_table = pgtable;
|
||||
|
||||
/* allocate pages */
|
||||
maxpages = MAX_ALLOC_PAGES;
|
||||
while (pages > 0) {
|
||||
chunk = pages;
|
||||
/* don't be too eager to take a huge chunk */
|
||||
if (chunk > maxpages)
|
||||
chunk = maxpages;
|
||||
chunk <<= PAGE_SHIFT;
|
||||
if (snd_dma_alloc_pages_fallback(type, dmab->dev.dev,
|
||||
chunk, &tmpb) < 0) {
|
||||
if (!sgbuf->pages)
|
||||
goto _failed;
|
||||
size = sgbuf->pages * PAGE_SIZE;
|
||||
break;
|
||||
}
|
||||
chunk = tmpb.bytes >> PAGE_SHIFT;
|
||||
for (i = 0; i < chunk; i++) {
|
||||
table->buf = tmpb.area;
|
||||
table->addr = tmpb.addr;
|
||||
if (!i)
|
||||
table->addr |= chunk; /* mark head */
|
||||
table++;
|
||||
*pgtable++ = virt_to_page(tmpb.area);
|
||||
tmpb.area += PAGE_SIZE;
|
||||
tmpb.addr += PAGE_SIZE;
|
||||
}
|
||||
sgbuf->pages += chunk;
|
||||
pages -= chunk;
|
||||
if (chunk < maxpages)
|
||||
maxpages = chunk;
|
||||
}
|
||||
|
||||
sgbuf->size = size;
|
||||
area = vmap(sgbuf->page_table, sgbuf->pages, VM_MAP, prot);
|
||||
if (!area)
|
||||
goto _failed;
|
||||
return area;
|
||||
|
||||
_failed:
|
||||
snd_dma_sg_free(dmab); /* free the table */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static dma_addr_t snd_dma_sg_get_addr(struct snd_dma_buffer *dmab,
|
||||
size_t offset)
|
||||
{
|
||||
struct snd_sg_buf *sgbuf = dmab->private_data;
|
||||
dma_addr_t addr;
|
||||
|
||||
addr = sgbuf->table[offset >> PAGE_SHIFT].addr;
|
||||
addr &= ~((dma_addr_t)PAGE_SIZE - 1);
|
||||
return addr + offset % PAGE_SIZE;
|
||||
}
|
||||
|
||||
static struct page *snd_dma_sg_get_page(struct snd_dma_buffer *dmab,
|
||||
size_t offset)
|
||||
{
|
||||
struct snd_sg_buf *sgbuf = dmab->private_data;
|
||||
unsigned int idx = offset >> PAGE_SHIFT;
|
||||
|
||||
if (idx >= (unsigned int)sgbuf->pages)
|
||||
return NULL;
|
||||
return sgbuf->page_table[idx];
|
||||
}
|
||||
|
||||
static unsigned int snd_dma_sg_get_chunk_size(struct snd_dma_buffer *dmab,
|
||||
unsigned int ofs,
|
||||
unsigned int size)
|
||||
{
|
||||
struct snd_sg_buf *sg = dmab->private_data;
|
||||
unsigned int start, end, pg;
|
||||
|
||||
start = ofs >> PAGE_SHIFT;
|
||||
end = (ofs + size - 1) >> PAGE_SHIFT;
|
||||
/* check page continuity */
|
||||
pg = sg->table[start].addr >> PAGE_SHIFT;
|
||||
for (;;) {
|
||||
start++;
|
||||
if (start > end)
|
||||
break;
|
||||
pg++;
|
||||
if ((sg->table[start].addr >> PAGE_SHIFT) != pg)
|
||||
return (start << PAGE_SHIFT) - ofs;
|
||||
}
|
||||
/* ok, all on continuous pages */
|
||||
return size;
|
||||
}
|
||||
|
||||
static int snd_dma_sg_mmap(struct snd_dma_buffer *dmab,
|
||||
struct vm_area_struct *area)
|
||||
{
|
||||
if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
|
||||
area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
|
||||
return -ENOENT; /* continue with the default mmap handler */
|
||||
}
|
||||
|
||||
const struct snd_malloc_ops snd_dma_sg_ops = {
|
||||
.alloc = snd_dma_sg_alloc,
|
||||
.free = snd_dma_sg_free,
|
||||
.get_addr = snd_dma_sg_get_addr,
|
||||
.get_page = snd_dma_sg_get_page,
|
||||
.get_chunk_size = snd_dma_sg_get_chunk_size,
|
||||
.mmap = snd_dma_sg_mmap,
|
||||
};
|
||||
@ -624,13 +624,13 @@ static int snd_timer_stop1(struct snd_timer_instance *timeri, bool stop)
|
||||
if (!timer)
|
||||
return -EINVAL;
|
||||
spin_lock_irqsave(&timer->lock, flags);
|
||||
list_del_init(&timeri->ack_list);
|
||||
list_del_init(&timeri->active_list);
|
||||
if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
|
||||
SNDRV_TIMER_IFLG_START))) {
|
||||
result = -EBUSY;
|
||||
goto unlock;
|
||||
}
|
||||
list_del_init(&timeri->ack_list);
|
||||
list_del_init(&timeri->active_list);
|
||||
if (timer->card && timer->card->shutdown)
|
||||
goto unlock;
|
||||
if (stop) {
|
||||
@ -665,23 +665,22 @@ static int snd_timer_stop1(struct snd_timer_instance *timeri, bool stop)
|
||||
static int snd_timer_stop_slave(struct snd_timer_instance *timeri, bool stop)
|
||||
{
|
||||
unsigned long flags;
|
||||
bool running;
|
||||
|
||||
spin_lock_irqsave(&slave_active_lock, flags);
|
||||
if (!(timeri->flags & SNDRV_TIMER_IFLG_RUNNING)) {
|
||||
spin_unlock_irqrestore(&slave_active_lock, flags);
|
||||
return -EBUSY;
|
||||
}
|
||||
running = timeri->flags & SNDRV_TIMER_IFLG_RUNNING;
|
||||
timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
|
||||
if (timeri->timer) {
|
||||
spin_lock(&timeri->timer->lock);
|
||||
list_del_init(&timeri->ack_list);
|
||||
list_del_init(&timeri->active_list);
|
||||
snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
|
||||
SNDRV_TIMER_EVENT_PAUSE);
|
||||
if (running)
|
||||
snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
|
||||
SNDRV_TIMER_EVENT_PAUSE);
|
||||
spin_unlock(&timeri->timer->lock);
|
||||
}
|
||||
spin_unlock_irqrestore(&slave_active_lock, flags);
|
||||
return 0;
|
||||
return running ? 0 : -EBUSY;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -169,6 +169,7 @@ config SND_FIREWIRE_MOTU
|
||||
* 828
|
||||
* 896
|
||||
* 828mk2
|
||||
* 896hd
|
||||
* Traveler
|
||||
* Ultralite
|
||||
* 8pre
|
||||
@ -176,7 +177,9 @@ config SND_FIREWIRE_MOTU
|
||||
* 828mk3 (Hybrid)
|
||||
* Ultralite mk3 (FireWire only)
|
||||
* Ultralite mk3 (Hybrid)
|
||||
* Traveler mk3
|
||||
* Audio Express
|
||||
* Track 16
|
||||
* 4pre
|
||||
|
||||
To compile this driver as a module, choose M here: the module
|
||||
|
||||
@ -50,8 +50,9 @@ static int init_stream(struct snd_efw *efw, struct amdtp_stream *stream)
|
||||
efw->firmware_version == 0x5070300 ||
|
||||
efw->firmware_version == 0x5080000))
|
||||
efw->tx_stream.flags |= CIP_UNALIGHED_DBC;
|
||||
// AudioFire9 always reports wrong dbs.
|
||||
if (efw->is_af9)
|
||||
// AudioFire9 always reports wrong dbs. Onyx 1200F with the latest firmware (v4.6.0)
|
||||
// also report wrong dbs at 88.2 kHz or greater.
|
||||
if (efw->is_af9 || efw->firmware_version == 0x4060000)
|
||||
efw->tx_stream.flags |= CIP_WRONG_DBS;
|
||||
// Firmware version 5.5 reports fixed interval for dbc.
|
||||
if (efw->firmware_version == 0x5050000)
|
||||
|
||||
@ -16,6 +16,7 @@
|
||||
#define V3_CLOCK_SRC_INTERNAL 0x00
|
||||
#define V3_CLOCK_SRC_WORD_ON_BNC 0x01
|
||||
#define V3_CLOCK_SRC_SPH 0x02
|
||||
#define V3_CLOCK_SRC_AESEBU_ON_XLR 0x08
|
||||
#define V3_CLOCK_SRC_SPDIF_ON_COAX 0x10
|
||||
#define V3_CLOCK_SRC_OPT_IFACE_A 0x18
|
||||
#define V3_CLOCK_SRC_OPT_IFACE_B 0x19
|
||||
@ -126,6 +127,9 @@ int snd_motu_protocol_v3_get_clock_source(struct snd_motu *motu,
|
||||
case V3_CLOCK_SRC_SPH:
|
||||
*src = SND_MOTU_CLOCK_SOURCE_SPH;
|
||||
break;
|
||||
case V3_CLOCK_SRC_AESEBU_ON_XLR:
|
||||
*src = SND_MOTU_CLOCK_SOURCE_AESEBU_ON_XLR;
|
||||
break;
|
||||
case V3_CLOCK_SRC_SPDIF_ON_COAX:
|
||||
*src = SND_MOTU_CLOCK_SOURCE_SPDIF_ON_COAX;
|
||||
break;
|
||||
@ -185,7 +189,7 @@ int snd_motu_protocol_v3_switch_fetching_mode(struct snd_motu *motu,
|
||||
sizeof(reg));
|
||||
}
|
||||
|
||||
static int detect_packet_formats_828mk3(struct snd_motu *motu, u32 data)
|
||||
static int detect_packet_formats_with_opt_ifaces(struct snd_motu *motu, u32 data)
|
||||
{
|
||||
if (data & V3_ENABLE_OPT_IN_IFACE_A) {
|
||||
if (data & V3_NO_ADAT_OPT_IN_IFACE_A) {
|
||||
@ -255,8 +259,11 @@ int snd_motu_protocol_v3_cache_packet_formats(struct snd_motu *motu)
|
||||
motu->spec->rx_fixed_pcm_chunks,
|
||||
sizeof(motu->rx_packet_formats.pcm_chunks));
|
||||
|
||||
if (motu->spec == &snd_motu_spec_828mk3_fw || motu->spec == &snd_motu_spec_828mk3_hybrid)
|
||||
return detect_packet_formats_828mk3(motu, data);
|
||||
if (motu->spec == &snd_motu_spec_828mk3_fw ||
|
||||
motu->spec == &snd_motu_spec_828mk3_hybrid ||
|
||||
motu->spec == &snd_motu_spec_traveler_mk3 ||
|
||||
motu->spec == &snd_motu_spec_track16)
|
||||
return detect_packet_formats_with_opt_ifaces(motu, data);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
@ -281,6 +288,16 @@ const struct snd_motu_spec snd_motu_spec_828mk3_hybrid = {
|
||||
.rx_fixed_pcm_chunks = {14, 14, 14}, // Additional 4 dummy chunks at higher rate.
|
||||
};
|
||||
|
||||
const struct snd_motu_spec snd_motu_spec_traveler_mk3 = {
|
||||
.name = "TravelerMk3",
|
||||
.protocol_version = SND_MOTU_PROTOCOL_V3,
|
||||
.flags = SND_MOTU_SPEC_RX_MIDI_3RD_Q |
|
||||
SND_MOTU_SPEC_TX_MIDI_3RD_Q |
|
||||
SND_MOTU_SPEC_COMMAND_DSP,
|
||||
.tx_fixed_pcm_chunks = {18, 14, 10},
|
||||
.rx_fixed_pcm_chunks = {14, 14, 10},
|
||||
};
|
||||
|
||||
const struct snd_motu_spec snd_motu_spec_ultralite_mk3 = {
|
||||
.name = "UltraLiteMk3",
|
||||
.protocol_version = SND_MOTU_PROTOCOL_V3,
|
||||
@ -301,6 +318,16 @@ const struct snd_motu_spec snd_motu_spec_audio_express = {
|
||||
.rx_fixed_pcm_chunks = {10, 10, 0},
|
||||
};
|
||||
|
||||
const struct snd_motu_spec snd_motu_spec_track16 = {
|
||||
.name = "Track16",
|
||||
.protocol_version = SND_MOTU_PROTOCOL_V3,
|
||||
.flags = SND_MOTU_SPEC_RX_MIDI_3RD_Q |
|
||||
SND_MOTU_SPEC_TX_MIDI_3RD_Q |
|
||||
SND_MOTU_SPEC_COMMAND_DSP,
|
||||
.tx_fixed_pcm_chunks = {14, 14, 14},
|
||||
.rx_fixed_pcm_chunks = {6, 6, 6},
|
||||
};
|
||||
|
||||
const struct snd_motu_spec snd_motu_spec_4pre = {
|
||||
.name = "4pre",
|
||||
.protocol_version = SND_MOTU_PROTOCOL_V3,
|
||||
|
||||
@ -169,9 +169,11 @@ static const struct ieee1394_device_id motu_id_table[] = {
|
||||
SND_MOTU_DEV_ENTRY(0x00000f, &snd_motu_spec_8pre),
|
||||
SND_MOTU_DEV_ENTRY(0x000015, &snd_motu_spec_828mk3_fw), // FireWire only.
|
||||
SND_MOTU_DEV_ENTRY(0x000019, &snd_motu_spec_ultralite_mk3), // FireWire only.
|
||||
SND_MOTU_DEV_ENTRY(0x00001b, &snd_motu_spec_traveler_mk3),
|
||||
SND_MOTU_DEV_ENTRY(0x000030, &snd_motu_spec_ultralite_mk3), // Hybrid.
|
||||
SND_MOTU_DEV_ENTRY(0x000035, &snd_motu_spec_828mk3_hybrid), // Hybrid.
|
||||
SND_MOTU_DEV_ENTRY(0x000033, &snd_motu_spec_audio_express),
|
||||
SND_MOTU_DEV_ENTRY(0x000039, &snd_motu_spec_track16),
|
||||
SND_MOTU_DEV_ENTRY(0x000045, &snd_motu_spec_4pre),
|
||||
{ }
|
||||
};
|
||||
|
||||
@ -138,8 +138,10 @@ extern const struct snd_motu_spec snd_motu_spec_8pre;
|
||||
|
||||
extern const struct snd_motu_spec snd_motu_spec_828mk3_fw;
|
||||
extern const struct snd_motu_spec snd_motu_spec_828mk3_hybrid;
|
||||
extern const struct snd_motu_spec snd_motu_spec_traveler_mk3;
|
||||
extern const struct snd_motu_spec snd_motu_spec_ultralite_mk3;
|
||||
extern const struct snd_motu_spec snd_motu_spec_audio_express;
|
||||
extern const struct snd_motu_spec snd_motu_spec_track16;
|
||||
extern const struct snd_motu_spec snd_motu_spec_4pre;
|
||||
|
||||
int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
|
||||
|
||||
@ -2327,7 +2327,8 @@ static int azx_probe_continue(struct azx *chip)
|
||||
|
||||
out_free:
|
||||
if (err < 0) {
|
||||
azx_free(chip);
|
||||
pci_set_drvdata(pci, NULL);
|
||||
snd_card_free(chip->card);
|
||||
return err;
|
||||
}
|
||||
|
||||
@ -2364,6 +2365,7 @@ static void azx_remove(struct pci_dev *pci)
|
||||
cancel_delayed_work_sync(&hda->probe_work);
|
||||
device_lock(&pci->dev);
|
||||
|
||||
pci_set_drvdata(pci, NULL);
|
||||
snd_card_free(card);
|
||||
}
|
||||
}
|
||||
|
||||
@ -6739,6 +6739,7 @@ enum {
|
||||
ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
|
||||
ALC287_FIXUP_13S_GEN2_SPEAKERS,
|
||||
ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS,
|
||||
ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
|
||||
};
|
||||
|
||||
static const struct hda_fixup alc269_fixups[] = {
|
||||
@ -8450,6 +8451,15 @@ static const struct hda_fixup alc269_fixups[] = {
|
||||
.type = HDA_FIXUP_FUNC,
|
||||
.v.func = alc245_fixup_hp_gpio_led,
|
||||
},
|
||||
[ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
|
||||
.type = HDA_FIXUP_PINS,
|
||||
.v.pins = (const struct hda_pintbl[]) {
|
||||
{ 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
|
||||
{ }
|
||||
},
|
||||
.chained = true,
|
||||
.chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
|
||||
},
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc269_fixup_tbl[] = {
|
||||
@ -8486,6 +8496,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
|
||||
SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
|
||||
SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
|
||||
SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
|
||||
@ -8625,6 +8636,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
|
||||
SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
|
||||
SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
|
||||
SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
|
||||
SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
|
||||
SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
|
||||
SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
|
||||
SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
|
||||
@ -8687,6 +8699,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
|
||||
SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
|
||||
SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
|
||||
SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
|
||||
SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
|
||||
@ -8750,11 +8763,15 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
|
||||
|
||||
@ -468,8 +468,11 @@ struct hdsp {
|
||||
unsigned char ss_out_channels;
|
||||
u32 io_loopback; /* output loopback channel states*/
|
||||
|
||||
struct snd_dma_buffer *capture_dma_buf;
|
||||
struct snd_dma_buffer *playback_dma_buf;
|
||||
/* DMA buffers; those are copied instances from the original snd_dma_buf
|
||||
* objects (which are managed via devres) for the address alignments
|
||||
*/
|
||||
struct snd_dma_buffer capture_dma_buf;
|
||||
struct snd_dma_buffer playback_dma_buf;
|
||||
unsigned char *capture_buffer; /* suitably aligned address */
|
||||
unsigned char *playback_buffer; /* suitably aligned address */
|
||||
|
||||
@ -3764,30 +3767,32 @@ static void snd_hdsp_proc_init(struct hdsp *hdsp)
|
||||
|
||||
static int snd_hdsp_initialize_memory(struct hdsp *hdsp)
|
||||
{
|
||||
unsigned long pb_bus, cb_bus;
|
||||
struct snd_dma_buffer *capture_dma, *playback_dma;
|
||||
|
||||
hdsp->capture_dma_buf =
|
||||
snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
|
||||
hdsp->playback_dma_buf =
|
||||
snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
|
||||
if (!hdsp->capture_dma_buf || !hdsp->playback_dma_buf) {
|
||||
capture_dma = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
|
||||
playback_dma = snd_hammerfall_get_buffer(hdsp->pci, HDSP_DMA_AREA_BYTES);
|
||||
if (!capture_dma || !playback_dma) {
|
||||
dev_err(hdsp->card->dev,
|
||||
"%s: no buffers available\n", hdsp->card_name);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Align to bus-space 64K boundary */
|
||||
/* copy to the own data for alignment */
|
||||
hdsp->capture_dma_buf = *capture_dma;
|
||||
hdsp->playback_dma_buf = *playback_dma;
|
||||
|
||||
cb_bus = ALIGN(hdsp->capture_dma_buf->addr, 0x10000ul);
|
||||
pb_bus = ALIGN(hdsp->playback_dma_buf->addr, 0x10000ul);
|
||||
/* Align to bus-space 64K boundary */
|
||||
hdsp->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul);
|
||||
hdsp->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul);
|
||||
|
||||
/* Tell the card where it is */
|
||||
hdsp_write(hdsp, HDSP_inputBufferAddress, hdsp->capture_dma_buf.addr);
|
||||
hdsp_write(hdsp, HDSP_outputBufferAddress, hdsp->playback_dma_buf.addr);
|
||||
|
||||
hdsp_write(hdsp, HDSP_inputBufferAddress, cb_bus);
|
||||
hdsp_write(hdsp, HDSP_outputBufferAddress, pb_bus);
|
||||
|
||||
hdsp->capture_buffer = hdsp->capture_dma_buf->area + (cb_bus - hdsp->capture_dma_buf->addr);
|
||||
hdsp->playback_buffer = hdsp->playback_dma_buf->area + (pb_bus - hdsp->playback_dma_buf->addr);
|
||||
hdsp->capture_dma_buf.area += hdsp->capture_dma_buf.addr - capture_dma->addr;
|
||||
hdsp->playback_dma_buf.area += hdsp->playback_dma_buf.addr - playback_dma->addr;
|
||||
hdsp->capture_buffer = hdsp->capture_dma_buf.area;
|
||||
hdsp->playback_buffer = hdsp->playback_dma_buf.area;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -4507,7 +4512,7 @@ static int snd_hdsp_playback_open(struct snd_pcm_substream *substream)
|
||||
snd_pcm_set_sync(substream);
|
||||
|
||||
runtime->hw = snd_hdsp_playback_subinfo;
|
||||
snd_pcm_set_runtime_buffer(substream, hdsp->playback_dma_buf);
|
||||
snd_pcm_set_runtime_buffer(substream, &hdsp->playback_dma_buf);
|
||||
|
||||
hdsp->playback_pid = current->pid;
|
||||
hdsp->playback_substream = substream;
|
||||
@ -4583,7 +4588,7 @@ static int snd_hdsp_capture_open(struct snd_pcm_substream *substream)
|
||||
snd_pcm_set_sync(substream);
|
||||
|
||||
runtime->hw = snd_hdsp_capture_subinfo;
|
||||
snd_pcm_set_runtime_buffer(substream, hdsp->capture_dma_buf);
|
||||
snd_pcm_set_runtime_buffer(substream, &hdsp->capture_dma_buf);
|
||||
|
||||
hdsp->capture_pid = current->pid;
|
||||
hdsp->capture_substream = substream;
|
||||
|
||||
@ -208,8 +208,11 @@ struct snd_rme9652 {
|
||||
unsigned char ds_channels;
|
||||
unsigned char ss_channels; /* different for hammerfall/hammerfall-light */
|
||||
|
||||
struct snd_dma_buffer *playback_dma_buf;
|
||||
struct snd_dma_buffer *capture_dma_buf;
|
||||
/* DMA buffers; those are copied instances from the original snd_dma_buf
|
||||
* objects (which are managed via devres) for the address alignments
|
||||
*/
|
||||
struct snd_dma_buffer playback_dma_buf;
|
||||
struct snd_dma_buffer capture_dma_buf;
|
||||
|
||||
unsigned char *capture_buffer; /* suitably aligned address */
|
||||
unsigned char *playback_buffer; /* suitably aligned address */
|
||||
@ -1719,30 +1722,32 @@ static void snd_rme9652_card_free(struct snd_card *card)
|
||||
|
||||
static int snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652)
|
||||
{
|
||||
unsigned long pb_bus, cb_bus;
|
||||
struct snd_dma_buffer *capture_dma, *playback_dma;
|
||||
|
||||
rme9652->capture_dma_buf =
|
||||
snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
|
||||
rme9652->playback_dma_buf =
|
||||
snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
|
||||
if (!rme9652->capture_dma_buf || !rme9652->playback_dma_buf) {
|
||||
capture_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
|
||||
playback_dma = snd_hammerfall_get_buffer(rme9652->pci, RME9652_DMA_AREA_BYTES);
|
||||
if (!capture_dma || !playback_dma) {
|
||||
dev_err(rme9652->card->dev,
|
||||
"%s: no buffers available\n", rme9652->card_name);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Align to bus-space 64K boundary */
|
||||
/* copy to the own data for alignment */
|
||||
rme9652->capture_dma_buf = *capture_dma;
|
||||
rme9652->playback_dma_buf = *playback_dma;
|
||||
|
||||
cb_bus = ALIGN(rme9652->capture_dma_buf->addr, 0x10000ul);
|
||||
pb_bus = ALIGN(rme9652->playback_dma_buf->addr, 0x10000ul);
|
||||
/* Align to bus-space 64K boundary */
|
||||
rme9652->capture_dma_buf.addr = ALIGN(capture_dma->addr, 0x10000ul);
|
||||
rme9652->playback_dma_buf.addr = ALIGN(playback_dma->addr, 0x10000ul);
|
||||
|
||||
/* Tell the card where it is */
|
||||
rme9652_write(rme9652, RME9652_rec_buffer, rme9652->capture_dma_buf.addr);
|
||||
rme9652_write(rme9652, RME9652_play_buffer, rme9652->playback_dma_buf.addr);
|
||||
|
||||
rme9652_write(rme9652, RME9652_rec_buffer, cb_bus);
|
||||
rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
|
||||
|
||||
rme9652->capture_buffer = rme9652->capture_dma_buf->area + (cb_bus - rme9652->capture_dma_buf->addr);
|
||||
rme9652->playback_buffer = rme9652->playback_dma_buf->area + (pb_bus - rme9652->playback_dma_buf->addr);
|
||||
rme9652->capture_dma_buf.area += rme9652->capture_dma_buf.addr - capture_dma->addr;
|
||||
rme9652->playback_dma_buf.area += rme9652->playback_dma_buf.addr - playback_dma->addr;
|
||||
rme9652->capture_buffer = rme9652->capture_dma_buf.area;
|
||||
rme9652->playback_buffer = rme9652->playback_dma_buf.area;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -2259,7 +2264,7 @@ static int snd_rme9652_playback_open(struct snd_pcm_substream *substream)
|
||||
snd_pcm_set_sync(substream);
|
||||
|
||||
runtime->hw = snd_rme9652_playback_subinfo;
|
||||
snd_pcm_set_runtime_buffer(substream, rme9652->playback_dma_buf);
|
||||
snd_pcm_set_runtime_buffer(substream, &rme9652->playback_dma_buf);
|
||||
|
||||
if (rme9652->capture_substream == NULL) {
|
||||
rme9652_stop(rme9652);
|
||||
@ -2318,7 +2323,7 @@ static int snd_rme9652_capture_open(struct snd_pcm_substream *substream)
|
||||
snd_pcm_set_sync(substream);
|
||||
|
||||
runtime->hw = snd_rme9652_capture_subinfo;
|
||||
snd_pcm_set_runtime_buffer(substream, rme9652->capture_dma_buf);
|
||||
snd_pcm_set_runtime_buffer(substream, &rme9652->capture_dma_buf);
|
||||
|
||||
if (rme9652->playback_substream == NULL) {
|
||||
rme9652_stop(rme9652);
|
||||
|
||||
@ -88,7 +88,7 @@ int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, ch
|
||||
emu->name = kstrdup(name, GFP_KERNEL);
|
||||
emu->voices = kcalloc(emu->max_voices, sizeof(struct snd_emux_voice),
|
||||
GFP_KERNEL);
|
||||
if (emu->voices == NULL)
|
||||
if (emu->name == NULL || emu->voices == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
/* create soundfont list */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user