leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ALSA: Clean up SG-buffer helper functions and macros

Browse Source 
Clean up SG-buffer helper functions and macros.  Helpers take substream
as arguments now.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
This commit is contained in:
Takashi Iwai 2008-08-21 13:00:13 +02:00 committed by Jaroslav Kysela
parent 46480b3a5f
commit 77a23f2695
15 changed files with 91 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/sound/memalloc.h
View File

@ -65,6 +65,11 @@ struct snd_dma_buffer {
/* /*
* Scatter-Gather generic device pages * Scatter-Gather generic device pages
*/ */
void *snd_malloc_sgbuf_pages(struct device *device,
size_t size, struct snd_dma_buffer *dmab,
size_t *res_size);
int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab);
struct snd_sg_page { struct snd_sg_page {
void *buf; void *buf;
dma_addr_t addr; dma_addr_t addr;
@ -95,6 +100,13 @@ static inline dma_addr_t snd_sgbuf_get_addr(struct snd_sg_buf *sgbuf, size_t off
return sgbuf->table[offset >> PAGE_SHIFT].addr + offset % PAGE_SIZE; return sgbuf->table[offset >> PAGE_SHIFT].addr + offset % PAGE_SIZE;
} }
/*
* return the virtual address at the corresponding offset
*/
static inline void *snd_sgbuf_get_ptr(struct snd_sg_buf *sgbuf, size_t offset)
{
return sgbuf->table[offset >> PAGE_SHIFT].buf + offset % PAGE_SIZE;
}
/* allocate/release a buffer */ /* allocate/release a buffer */
int snd_dma_alloc_pages(int type, struct device *dev, size_t size, int snd_dma_alloc_pages(int type, struct device *dev, size_t size,

27
include/sound/pcm.h
View File

@ -974,10 +974,29 @@ int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size); int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size);
int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream); int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream);
#define snd_pcm_substream_sgbuf(substream) ((substream)->runtime->dma_buffer_p->private_data) /*
#define snd_pcm_sgbuf_pages(size) snd_sgbuf_aligned_pages(size) * SG-buffer handling
#define snd_pcm_sgbuf_get_addr(sgbuf,ofs) snd_sgbuf_get_addr(sgbuf,ofs) */
struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset); #define snd_pcm_substream_sgbuf(substream) \
((substream)->runtime->dma_buffer_p->private_data)
static inline dma_addr_t
snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)
{
struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
return snd_sgbuf_get_addr(sg, ofs);
}
static inline void *
snd_pcm_sgbuf_get_ptr(struct snd_pcm_substream *substream, unsigned int ofs)
{
struct snd_sg_buf *sg = snd_pcm_substream_sgbuf(substream);
return snd_sgbuf_get_ptr(sg, ofs);
}
struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream,
unsigned long offset);
/* handle mmap counter - PCM mmap callback should handle this counter properly */ /* handle mmap counter - PCM mmap callback should handle this counter properly */
static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area) static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)

8
sound/core/memalloc.c
View File

@ -43,14 +43,6 @@ MODULE_DESCRIPTION("Memory allocator for ALSA system.");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
/*
*/
void *snd_malloc_sgbuf_pages(struct device *device,
size_t size, struct snd_dma_buffer *dmab,
size_t *res_size);
int snd_free_sgbuf_pages(struct snd_dma_buffer *dmab);
/* /*
*/ */

7
sound/pci/au88x0/au88x0.h
View File

@ -125,7 +125,6 @@ typedef struct {
/* Virtual page extender stuff */ /* Virtual page extender stuff */
int nr_periods; int nr_periods;
int period_bytes; int period_bytes;
struct snd_sg_buf *sgbuf; /* DMA Scatter Gather struct */
int period_real; int period_real;
int period_virt; int period_virt;
@ -195,16 +194,14 @@ static void vortex_adb_setsrc(vortex_t * vortex, int adbdma,
/* DMA Engines. */ /* DMA Engines. */
static void vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma, static void vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma,
struct snd_sg_buf * sgbuf, int size, int size, int count);
int count);
static void vortex_adbdma_setmode(vortex_t * vortex, int adbdma, int ie, static void vortex_adbdma_setmode(vortex_t * vortex, int adbdma, int ie,
int dir, int fmt, int d, int dir, int fmt, int d,
u32 offset); u32 offset);
static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb); static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb);
#ifndef CHIP_AU8810 #ifndef CHIP_AU8810
static void vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma, static void vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma,
struct snd_sg_buf * sgbuf, int size, int size, int count);
int count);
static void vortex_wtdma_setmode(vortex_t * vortex, int wtdma, int ie, int fmt, int d, /*int e, */ static void vortex_wtdma_setmode(vortex_t * vortex, int wtdma, int ie, int fmt, int d, /*int e, */
u32 offset); u32 offset);
static void vortex_wtdma_setstartbuffer(vortex_t * vortex, int wtdma, int sb); static void vortex_wtdma_setstartbuffer(vortex_t * vortex, int wtdma, int sb);

38
sound/pci/au88x0/au88x0_core.c
View File

@ -1097,19 +1097,12 @@ static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb)
static void static void
vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma, vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma,
struct snd_sg_buf * sgbuf, int psize, int count) int psize, int count)
{ {
stream_t *dma = &vortex->dma_adb[adbdma]; stream_t *dma = &vortex->dma_adb[adbdma];
if (sgbuf == NULL) {
printk(KERN_INFO "vortex: FATAL: sgbuf is NULL!\n");
return;
}
//printk(KERN_INFO "vortex: page count = %d, tblcount = %d\n", count, sgbuf->tblsize);
dma->period_bytes = psize; dma->period_bytes = psize;
dma->nr_periods = count; dma->nr_periods = count;
dma->sgbuf = sgbuf;
dma->cfg0 = 0; dma->cfg0 = 0;
dma->cfg1 = 0; dma->cfg1 = 0;
@ -1120,26 +1113,26 @@ vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma,
dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize - 1); dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize - 1);
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0xc, VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0xc,
snd_sgbuf_get_addr(sgbuf, psize * 3)); snd_pcm_sgbuf_get_addr(dma->substream, psize * 3));
/* 3 pages */ /* 3 pages */
case 3: case 3:
dma->cfg0 |= 0x12000000; dma->cfg0 |= 0x12000000;
dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc); dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc);
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x8, VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x8,
snd_sgbuf_get_addr(sgbuf, psize * 2)); snd_pcm_sgbuf_get_addr(dma->substream, psize * 2));
/* 2 pages */ /* 2 pages */
case 2: case 2:
dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize - 1); dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize - 1);
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x4, VORTEX_ADBDMA_BUFBASE + (adbdma << 4) + 0x4,
snd_sgbuf_get_addr(sgbuf, psize)); snd_pcm_sgbuf_get_addr(dma->substream, psize));
/* 1 page */ /* 1 page */
case 1: case 1:
dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc); dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize - 1) << 0xc);
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (adbdma << 4), VORTEX_ADBDMA_BUFBASE + (adbdma << 4),
snd_sgbuf_get_addr(sgbuf, 0)); snd_pcm_sgbuf_get_addr(dma->substream, 0));
break; break;
} }
//printk("vortex: cfg0 = 0x%x\nvortex: cfg1=0x%x\n", dma->cfg0, dma->cfg1); //printk("vortex: cfg0 = 0x%x\nvortex: cfg1=0x%x\n", dma->cfg0, dma->cfg1);
@ -1205,7 +1198,7 @@ static int vortex_adbdma_bufshift(vortex_t * vortex, int adbdma)
//hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFBASE+(((adbdma << 2)+pp) << 2), dma->table[p].addr); //hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFBASE+(((adbdma << 2)+pp) << 2), dma->table[p].addr);
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (((adbdma << 2) + pp) << 2), VORTEX_ADBDMA_BUFBASE + (((adbdma << 2) + pp) << 2),
snd_sgbuf_get_addr(dma->sgbuf, snd_pcm_sgbuf_get_addr(dma->substream,
dma->period_bytes * p)); dma->period_bytes * p));
/* Force write thru cache. */ /* Force write thru cache. */
hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE + hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE +
@ -1244,7 +1237,10 @@ static void vortex_adbdma_resetup(vortex_t *vortex, int adbdma) {
if (pp >= 4) if (pp >= 4)
pp -= 4; pp -= 4;
} }
hwwrite(vortex->mmio, VORTEX_ADBDMA_BUFBASE+(((adbdma << 2)+pp) << 2), snd_sgbuf_get_addr(dma->sgbuf, dma->period_bytes * p)); hwwrite(vortex->mmio,
VORTEX_ADBDMA_BUFBASE + (((adbdma << 2) + pp) << 2),
snd_pcm_sgbuf_get_addr(dma->substream,
dma->period_bytes * p));
/* Force write thru cache. */ /* Force write thru cache. */
hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE + (((adbdma << 2)+pp) << 2)); hwread(vortex->mmio, VORTEX_ADBDMA_BUFBASE + (((adbdma << 2)+pp) << 2));
} }
@ -1367,13 +1363,12 @@ static void vortex_wtdma_setstartbuffer(vortex_t * vortex, int wtdma, int sb)
static void static void
vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma, vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma,
struct snd_sg_buf * sgbuf, int psize, int count) int psize, int count)
{ {
stream_t *dma = &vortex->dma_wt[wtdma]; stream_t *dma = &vortex->dma_wt[wtdma];
dma->period_bytes = psize; dma->period_bytes = psize;
dma->nr_periods = count; dma->nr_periods = count;
dma->sgbuf = sgbuf;
dma->cfg0 = 0; dma->cfg0 = 0;
dma->cfg1 = 0; dma->cfg1 = 0;
@ -1383,23 +1378,23 @@ vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma,
case 4: case 4:
dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize-1); dma->cfg1 |= 0x88000000 | 0x44000000 | 0x30000000 | (psize-1);
hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0xc, hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0xc,
snd_sgbuf_get_addr(sgbuf, psize * 3)); snd_pcm_sgbuf_get_addr(dma->substream, psize * 3));
/* 3 pages */ /* 3 pages */
case 3: case 3:
dma->cfg0 |= 0x12000000; dma->cfg0 |= 0x12000000;
dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc); dma->cfg1 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc);
hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x8, hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x8,
snd_sgbuf_get_addr(sgbuf, psize * 2)); snd_pcm_sgbuf_get_addr(dma->substream, psize * 2));
/* 2 pages */ /* 2 pages */
case 2: case 2:
dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize-1); dma->cfg0 |= 0x88000000 | 0x44000000 | 0x10000000 | (psize-1);
hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x4, hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4) + 0x4,
snd_sgbuf_get_addr(sgbuf, psize)); snd_pcm_sgbuf_get_addr(dma->substream, psize));
/* 1 page */ /* 1 page */
case 1: case 1:
dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc); dma->cfg0 |= 0x80000000 | 0x40000000 | ((psize-1) << 0xc);
hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4), hwwrite(vortex->mmio, VORTEX_WTDMA_BUFBASE + (wtdma << 4),
snd_sgbuf_get_addr(sgbuf, 0)); snd_pcm_sgbuf_get_addr(dma->substream, 0));
break; break;
} }
hwwrite(vortex->mmio, VORTEX_WTDMA_BUFCFG0 + (wtdma << 3), dma->cfg0); hwwrite(vortex->mmio, VORTEX_WTDMA_BUFCFG0 + (wtdma << 3), dma->cfg0);
@ -1465,7 +1460,8 @@ static int vortex_wtdma_bufshift(vortex_t * vortex, int wtdma)
hwwrite(vortex->mmio, hwwrite(vortex->mmio,
VORTEX_WTDMA_BUFBASE + VORTEX_WTDMA_BUFBASE +
(((wtdma << 2) + pp) << 2), (((wtdma << 2) + pp) << 2),
snd_sgbuf_get_addr(dma->sgbuf, dma->period_bytes * p)); snd_pcm_sgbuf_get_addr(dma->substream,
dma->period_bytes * p));
/* Force write thru cache. */ /* Force write thru cache. */
hwread(vortex->mmio, VORTEX_WTDMA_BUFBASE + hwread(vortex->mmio, VORTEX_WTDMA_BUFBASE +
(((wtdma << 2) + pp) << 2)); (((wtdma << 2) + pp) << 2));

14
sound/pci/au88x0/au88x0_pcm.c
View File

@ -189,7 +189,6 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream,
{ {
vortex_t *chip = snd_pcm_substream_chip(substream); vortex_t *chip = snd_pcm_substream_chip(substream);
stream_t *stream = (stream_t *) (substream->runtime->private_data); stream_t *stream = (stream_t *) (substream->runtime->private_data);
struct snd_sg_buf *sgbuf;
int err; int err;
// Alloc buffer memory. // Alloc buffer memory.
@ -199,8 +198,6 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream,
printk(KERN_ERR "Vortex: pcm page alloc failed!\n"); printk(KERN_ERR "Vortex: pcm page alloc failed!\n");
return err; return err;
} }
//sgbuf = (struct snd_sg_buf *) substream->runtime->dma_private;
sgbuf = snd_pcm_substream_sgbuf(substream);
/* /*
printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params), printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
params_period_bytes(hw_params), params_channels(hw_params)); params_period_bytes(hw_params), params_channels(hw_params));
@ -226,7 +223,7 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream,
stream = substream->runtime->private_data = &chip->dma_adb[dma]; stream = substream->runtime->private_data = &chip->dma_adb[dma];
stream->substream = substream; stream->substream = substream;
/* Setup Buffers. */ /* Setup Buffers. */
vortex_adbdma_setbuffers(chip, dma, sgbuf, vortex_adbdma_setbuffers(chip, dma,
params_period_bytes(hw_params), params_period_bytes(hw_params),
params_periods(hw_params)); params_periods(hw_params));
} }
@ -240,7 +237,7 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream,
&chip->dma_wt[substream->number]; &chip->dma_wt[substream->number];
stream->dma = substream->number; stream->dma = substream->number;
stream->substream = substream; stream->substream = substream;
vortex_wtdma_setbuffers(chip, substream->number, sgbuf, vortex_wtdma_setbuffers(chip, substream->number,
params_period_bytes(hw_params), params_period_bytes(hw_params),
params_periods(hw_params)); params_periods(hw_params));
} }
@ -392,13 +389,6 @@ static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substr
return (bytes_to_frames(substream->runtime, current_ptr)); return (bytes_to_frames(substream->runtime, current_ptr));
} }
/* Page callback. */
/*
static struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset) {
}
*/
/* operators */ /* operators */
static struct snd_pcm_ops snd_vortex_playback_ops = { static struct snd_pcm_ops snd_vortex_playback_ops = {
.open = snd_vortex_pcm_open, .open = snd_vortex_pcm_open,

5
sound/pci/bt87x.c
View File

@ -227,7 +227,6 @@ static inline void snd_bt87x_writel(struct snd_bt87x *chip, u32 reg, u32 value)
static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substream *substream, static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substream *substream,
unsigned int periods, unsigned int period_bytes) unsigned int periods, unsigned int period_bytes)
{ {
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
unsigned int i, offset; unsigned int i, offset;
u32 *risc; u32 *risc;
@ -246,6 +245,7 @@ static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substrea
rest = period_bytes; rest = period_bytes;
do { do {
u32 cmd, len; u32 cmd, len;
unsigned int addr;
len = PAGE_SIZE - (offset % PAGE_SIZE); len = PAGE_SIZE - (offset % PAGE_SIZE);
if (len > rest) if (len > rest)
@ -260,7 +260,8 @@ static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substrea
if (len == rest) if (len == rest)
cmd |= RISC_EOL | RISC_IRQ; cmd |= RISC_EOL | RISC_IRQ;
*risc++ = cpu_to_le32(cmd); *risc++ = cpu_to_le32(cmd);
*risc++ = cpu_to_le32((u32)snd_pcm_sgbuf_get_addr(sgbuf, offset)); addr = snd_pcm_sgbuf_get_addr(substream, offset);
*risc++ = cpu_to_le32(addr);
offset += len; offset += len;
rest -= len; rest -= len;
} while (rest > 0); } while (rest > 0);

14
sound/pci/echoaudio/echoaudio.c
View File

@ -490,7 +490,6 @@ static int init_engine(struct snd_pcm_substream *substream,
{ {
struct echoaudio *chip; struct echoaudio *chip;
int err, per, rest, page, edge, offs; int err, per, rest, page, edge, offs;
struct snd_sg_buf *sgbuf;
struct audiopipe *pipe; struct audiopipe *pipe;
chip = snd_pcm_substream_chip(substream); chip = snd_pcm_substream_chip(substream);
@ -531,10 +530,6 @@ static int init_engine(struct snd_pcm_substream *substream,
return err; return err;
} }
sgbuf = snd_pcm_substream_sgbuf(substream);
DE_HWP(("pcm_hw_params table size=%d pages=%d\n",
sgbuf->size, sgbuf->pages));
sglist_init(chip, pipe); sglist_init(chip, pipe);
edge = PAGE_SIZE; edge = PAGE_SIZE;
for (offs = page = per = 0; offs < params_buffer_bytes(hw_params); for (offs = page = per = 0; offs < params_buffer_bytes(hw_params);
@ -543,16 +538,15 @@ static int init_engine(struct snd_pcm_substream *substream,
if (offs + rest > params_buffer_bytes(hw_params)) if (offs + rest > params_buffer_bytes(hw_params))
rest = params_buffer_bytes(hw_params) - offs; rest = params_buffer_bytes(hw_params) - offs;
while (rest) { while (rest) {
dma_addr_t addr;
addr = snd_pcm_sgbuf_get_addr(substream, offs);
if (rest <= edge - offs) { if (rest <= edge - offs) {
sglist_add_mapping(chip, pipe, sglist_add_mapping(chip, pipe, addr, rest);
snd_sgbuf_get_addr(sgbuf, offs),
rest);
sglist_add_irq(chip, pipe); sglist_add_irq(chip, pipe);
offs += rest; offs += rest;
rest = 0; rest = 0;
} else { } else {
sglist_add_mapping(chip, pipe, sglist_add_mapping(chip, pipe, addr,
snd_sgbuf_get_addr(sgbuf, offs),
edge - offs); edge - offs);
rest -= edge - offs; rest -= edge - offs;
offs = edge; offs = edge;

12
sound/pci/emu10k1/memory.c
View File

@ -296,7 +296,6 @@ struct snd_util_memblk *
snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream) snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
struct snd_util_memhdr *hdr; struct snd_util_memhdr *hdr;
struct snd_emu10k1_memblk *blk; struct snd_emu10k1_memblk *blk;
int page, err, idx; int page, err, idx;
@ -321,16 +320,9 @@ snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *subst
*/ */
idx = 0; idx = 0;
for (page = blk->first_page; page <= blk->last_page; page++, idx++) { for (page = blk->first_page; page <= blk->last_page; page++, idx++) {
unsigned long ofs = idx << PAGE_SHIFT;
dma_addr_t addr; dma_addr_t addr;
#ifdef CONFIG_SND_DEBUG addr = snd_pcm_sgbuf_get_addr(substream, ofs);
if (idx >= sgbuf->pages) {
printk(KERN_ERR "emu: pages overflow! (%d-%d) for %d\n",
blk->first_page, blk->last_page, sgbuf->pages);
mutex_unlock(&hdr->block_mutex);
return NULL;
}
#endif
addr = sgbuf->table[idx].addr;
if (! is_valid_page(emu, addr)) { if (! is_valid_page(emu, addr)) {
printk(KERN_ERR "emu: failure page = %d\n", idx); printk(KERN_ERR "emu: failure page = %d\n", idx);
mutex_unlock(&hdr->block_mutex); mutex_unlock(&hdr->block_mutex);

3
sound/pci/hda/hda_intel.c
View File

@ -998,7 +998,6 @@ static int setup_bdle(struct snd_pcm_substream *substream,
struct azx_dev *azx_dev, u32 **bdlp, struct azx_dev *azx_dev, u32 **bdlp,
int ofs, int size, int with_ioc) int ofs, int size, int with_ioc)
{ {
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
u32 *bdl = *bdlp; u32 *bdl = *bdlp;
while (size > 0) { while (size > 0) {
@ -1008,7 +1007,7 @@ static int setup_bdle(struct snd_pcm_substream *substream,
if (azx_dev->frags >= AZX_MAX_BDL_ENTRIES) if (azx_dev->frags >= AZX_MAX_BDL_ENTRIES)
return -EINVAL; return -EINVAL;
addr = snd_pcm_sgbuf_get_addr(sgbuf, ofs); addr = snd_pcm_sgbuf_get_addr(substream, ofs);
/* program the address field of the BDL entry */ /* program the address field of the BDL entry */
bdl[0] = cpu_to_le32((u32)addr); bdl[0] = cpu_to_le32((u32)addr);
bdl[1] = cpu_to_le32(upper_32_bits(addr)); bdl[1] = cpu_to_le32(upper_32_bits(addr));

13
sound/pci/riptide/riptide.c
View File

@ -1483,7 +1483,6 @@ static int snd_riptide_prepare(struct snd_pcm_substream *substream)
{ {
struct snd_riptide *chip = snd_pcm_substream_chip(substream); struct snd_riptide *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
struct pcmhw *data = get_pcmhwdev(substream); struct pcmhw *data = get_pcmhwdev(substream);
struct cmdif *cif = chip->cif; struct cmdif *cif = chip->cif;
unsigned char *lbuspath = NULL; unsigned char *lbuspath = NULL;
@ -1515,9 +1514,9 @@ static int snd_riptide_prepare(struct snd_pcm_substream *substream)
lbuspath = data->paths.stereo; lbuspath = data->paths.stereo;
break; break;
} }
snd_printdd("use sgdlist at 0x%p and buffer at 0x%p\n", snd_printdd("use sgdlist at 0x%p\n",
data->sgdlist.area, sgbuf); data->sgdlist.area);
if (data->sgdlist.area && sgbuf) { if (data->sgdlist.area) {
unsigned int i, j, size, pages, f, pt, period; unsigned int i, j, size, pages, f, pt, period;
struct sgd *c, *p = NULL; struct sgd *c, *p = NULL;
@ -1535,6 +1534,7 @@ static int snd_riptide_prepare(struct snd_pcm_substream *substream)
pt = 0; pt = 0;
j = 0; j = 0;
for (i = 0; i < pages; i++) { for (i = 0; i < pages; i++) {
unsigned int ofs, addr;
c = &data->sgdbuf[i]; c = &data->sgdbuf[i];
if (p) if (p)
p->dwNextLink = cpu_to_le32(data->sgdlist.addr + p->dwNextLink = cpu_to_le32(data->sgdlist.addr +
@ -1542,8 +1542,9 @@ static int snd_riptide_prepare(struct snd_pcm_substream *substream)
sizeof(struct sizeof(struct
sgd))); sgd)));
c->dwNextLink = cpu_to_le32(data->sgdlist.addr); c->dwNextLink = cpu_to_le32(data->sgdlist.addr);
c->dwSegPtrPhys = ofs = j << PAGE_SHIFT;
cpu_to_le32(sgbuf->table[j].addr + pt); addr = snd_pcm_sgbuf_get_addr(substream, ofs) + pt;
c->dwSegPtrPhys = cpu_to_le32(addr);
pt = (pt + f) % PAGE_SIZE; pt = (pt + f) % PAGE_SIZE;
if (pt == 0) if (pt == 0)
j++; j++;

18
sound/pci/rme9652/hdspm.c
View File

@ -535,7 +535,8 @@ static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm);
static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm); static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm);
static int hdspm_autosync_ref(struct hdspm * hdspm); static int hdspm_autosync_ref(struct hdspm * hdspm);
static int snd_hdspm_set_defaults(struct hdspm * hdspm); static int snd_hdspm_set_defaults(struct hdspm * hdspm);
static void hdspm_set_sgbuf(struct hdspm * hdspm, struct snd_sg_buf *sgbuf, static void hdspm_set_sgbuf(struct hdspm * hdspm,
struct snd_pcm_substream *substream,
unsigned int reg, int channels); unsigned int reg, int channels);
static inline int HDSPM_bit2freq(int n) static inline int HDSPM_bit2freq(int n)
@ -3604,8 +3605,6 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
int i; int i;
pid_t this_pid; pid_t this_pid;
pid_t other_pid; pid_t other_pid;
struct snd_sg_buf *sgbuf;
spin_lock_irq(&hdspm->lock); spin_lock_irq(&hdspm->lock);
@ -3673,11 +3672,9 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
if (err < 0) if (err < 0)
return err; return err;
sgbuf = snd_pcm_substream_sgbuf(substream);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
hdspm_set_sgbuf(hdspm, sgbuf, HDSPM_pageAddressBufferOut, hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferOut,
params_channels(params)); params_channels(params));
for (i = 0; i < params_channels(params); ++i) for (i = 0; i < params_channels(params); ++i)
@ -3688,7 +3685,7 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
snd_printdd("Allocated sample buffer for playback at %p\n", snd_printdd("Allocated sample buffer for playback at %p\n",
hdspm->playback_buffer); hdspm->playback_buffer);
} else { } else {
hdspm_set_sgbuf(hdspm, sgbuf, HDSPM_pageAddressBufferIn, hdspm_set_sgbuf(hdspm, substream, HDSPM_pageAddressBufferIn,
params_channels(params)); params_channels(params));
for (i = 0; i < params_channels(params); ++i) for (i = 0; i < params_channels(params); ++i)
@ -3703,7 +3700,7 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream,
snd_printdd("Allocated sample buffer for %s at 0x%08X\n", snd_printdd("Allocated sample buffer for %s at 0x%08X\n",
substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
"playback" : "capture", "playback" : "capture",
snd_pcm_sgbuf_get_addr(sgbuf, 0)); snd_pcm_sgbuf_get_addr(substream, 0));
*/ */
/* /*
snd_printdd("set_hwparams: %s %d Hz, %d channels, bs = %d\n", snd_printdd("set_hwparams: %s %d Hz, %d channels, bs = %d\n",
@ -4253,13 +4250,14 @@ static int __devinit snd_hdspm_preallocate_memory(struct hdspm * hdspm)
return 0; return 0;
} }
static void hdspm_set_sgbuf(struct hdspm * hdspm, struct snd_sg_buf *sgbuf, static void hdspm_set_sgbuf(struct hdspm * hdspm,
struct snd_pcm_substream *substream,
unsigned int reg, int channels) unsigned int reg, int channels)
{ {
int i; int i;
for (i = 0; i < (channels * 16); i++) for (i = 0; i < (channels * 16); i++)
hdspm_write(hdspm, reg + 4 * i, hdspm_write(hdspm, reg + 4 * i,
snd_pcm_sgbuf_get_addr(sgbuf, (size_t) 4096 * i)); snd_pcm_sgbuf_get_addr(substream, 4096 * i));
} }
/* ------------- ALSA Devices ---------------------------- */ /* ------------- ALSA Devices ---------------------------- */

13
sound/pci/trident/trident_memory.c
View File

@ -194,7 +194,6 @@ snd_trident_alloc_sg_pages(struct snd_trident *trident,
struct snd_util_memblk *blk; struct snd_util_memblk *blk;
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
int idx, page; int idx, page;
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
if (snd_BUG_ON(runtime->dma_bytes <= 0 || if (snd_BUG_ON(runtime->dma_bytes <= 0 ||
runtime->dma_bytes > SNDRV_TRIDENT_MAX_PAGES * runtime->dma_bytes > SNDRV_TRIDENT_MAX_PAGES *
@ -212,18 +211,14 @@ snd_trident_alloc_sg_pages(struct snd_trident *trident,
mutex_unlock(&hdr->block_mutex); mutex_unlock(&hdr->block_mutex);
return NULL; return NULL;
} }
if (lastpg(blk) - firstpg(blk) >= sgbuf->pages) {
snd_printk(KERN_ERR "page calculation doesn't match: allocated pages = %d, trident = %d/%d\n", sgbuf->pages, firstpg(blk), lastpg(blk));
__snd_util_mem_free(hdr, blk);
mutex_unlock(&hdr->block_mutex);
return NULL;
}
/* set TLB entries */ /* set TLB entries */
idx = 0; idx = 0;
for (page = firstpg(blk); page <= lastpg(blk); page++, idx++) { for (page = firstpg(blk); page <= lastpg(blk); page++, idx++) {
dma_addr_t addr = sgbuf->table[idx].addr; unsigned long ofs = idx << PAGE_SHIFT;
unsigned long ptr = (unsigned long)sgbuf->table[idx].buf; dma_addr_t addr = snd_pcm_sgbuf_get_addr(substream, ofs);
unsigned long ptr = (unsigned long)
snd_pcm_sgbuf_get_ptr(substream, ofs);
if (! is_valid_page(addr)) { if (! is_valid_page(addr)) {
__snd_util_mem_free(hdr, blk); __snd_util_mem_free(hdr, blk);
mutex_unlock(&hdr->block_mutex); mutex_unlock(&hdr->block_mutex);

5
sound/pci/via82xx.c
View File

@ -420,7 +420,6 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
{ {
unsigned int i, idx, ofs, rest; unsigned int i, idx, ofs, rest;
struct via82xx *chip = snd_pcm_substream_chip(substream); struct via82xx *chip = snd_pcm_substream_chip(substream);
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
if (dev->table.area == NULL) { if (dev->table.area == NULL) {
/* the start of each lists must be aligned to 8 bytes, /* the start of each lists must be aligned to 8 bytes,
@ -449,12 +448,14 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
do { do {
unsigned int r; unsigned int r;
unsigned int flag; unsigned int flag;
unsigned int addr;
if (idx >= VIA_TABLE_SIZE) { if (idx >= VIA_TABLE_SIZE) {
snd_printk(KERN_ERR "via82xx: too much table size!\n"); snd_printk(KERN_ERR "via82xx: too much table size!\n");
return -EINVAL; return -EINVAL;
} }
((u32 *)dev->table.area)[idx << 1] = cpu_to_le32((u32)snd_pcm_sgbuf_get_addr(sgbuf, ofs)); addr = snd_pcm_sgbuf_get_addr(substream, ofs);
((u32 *)dev->table.area)[idx << 1] = cpu_to_le32(addr);
r = PAGE_SIZE - (ofs % PAGE_SIZE); r = PAGE_SIZE - (ofs % PAGE_SIZE);
if (rest < r) if (rest < r)
r = rest; r = rest;

5
sound/pci/via82xx_modem.c
View File

@ -281,7 +281,6 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
{ {
unsigned int i, idx, ofs, rest; unsigned int i, idx, ofs, rest;
struct via82xx_modem *chip = snd_pcm_substream_chip(substream); struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream);
if (dev->table.area == NULL) { if (dev->table.area == NULL) {
/* the start of each lists must be aligned to 8 bytes, /* the start of each lists must be aligned to 8 bytes,
@ -310,12 +309,14 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre
do { do {
unsigned int r; unsigned int r;
unsigned int flag; unsigned int flag;
unsigned int addr;
if (idx >= VIA_TABLE_SIZE) { if (idx >= VIA_TABLE_SIZE) {
snd_printk(KERN_ERR "via82xx: too much table size!\n"); snd_printk(KERN_ERR "via82xx: too much table size!\n");
return -EINVAL; return -EINVAL;
} }
((u32 *)dev->table.area)[idx << 1] = cpu_to_le32((u32)snd_pcm_sgbuf_get_addr(sgbuf, ofs)); addr = snd_pcm_sgbuf_get_addr(substream, ofs);
((u32 *)dev->table.area)[idx << 1] = cpu_to_le32(addr);
r = PAGE_SIZE - (ofs % PAGE_SIZE); r = PAGE_SIZE - (ofs % PAGE_SIZE);
if (rest < r) if (rest < r)
r = rest; r = rest;