android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6

Browse Source 
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6:
  ALSA: Fix yet another race in disconnection
  ALSA: asihpi - Update verbose debug print macros
  ALSA: asihpi - Improve non-busmaster adapter operation
  ALSA: asihpi - Support single-rate no-SRC cards
  ALSA: HDA: New AD1984A model for Dell Precision R5500
  ALSA: vmalloc buffers should use normal mmap
  ALSA: hda - Fix SPDIF out regression on ALC889
  ALSA: usb-audio - Support for Boss JS-8 Jam Station
  ALSA: usb-audio: add Cakewalk UM-1G support
  sound/oss/opl3: validate voice and channel indexes
  sound/oss: remove offset from load_patch callbacks
This commit is contained in:
Linus Torvalds 2011-03-27 20:35:07 -07:00
commit 7b724a2260
12 changed files with 230 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sound/pcm.h
View File

@ -1031,9 +1031,7 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_s
#define snd_pcm_lib_mmap_iomem NULL #define snd_pcm_lib_mmap_iomem NULL
#endif #endif
int snd_pcm_lib_mmap_noncached(struct snd_pcm_substream *substream, #define snd_pcm_lib_mmap_vmalloc NULL
struct vm_area_struct *area);
#define snd_pcm_lib_mmap_vmalloc snd_pcm_lib_mmap_noncached
static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max) static inline void snd_pcm_limit_isa_dma_size(int dma, size_t *max)
{ {

4
sound/core/init.c
View File

@ -848,6 +848,7 @@ int snd_card_file_add(struct snd_card *card, struct file *file)
return -ENOMEM; return -ENOMEM;
mfile->file = file; mfile->file = file;
mfile->disconnected_f_op = NULL; mfile->disconnected_f_op = NULL;
INIT_LIST_HEAD(&mfile->shutdown_list);
spin_lock(&card->files_lock); spin_lock(&card->files_lock);
if (card->shutdown) { if (card->shutdown) {
spin_unlock(&card->files_lock); spin_unlock(&card->files_lock);
@ -883,6 +884,9 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
list_for_each_entry(mfile, &card->files_list, list) { list_for_each_entry(mfile, &card->files_list, list) {
if (mfile->file == file) { if (mfile->file == file) {
list_del(&mfile->list); list_del(&mfile->list);
spin_lock(&shutdown_lock);
list_del(&mfile->shutdown_list);
spin_unlock(&shutdown_lock);
if (mfile->disconnected_f_op) if (mfile->disconnected_f_op)
fops_put(mfile->disconnected_f_op); fops_put(mfile->disconnected_f_op);
found = mfile; found = mfile;

9
sound/core/pcm_native.c
View File

@ -3201,15 +3201,6 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem); EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
#endif /* SNDRV_PCM_INFO_MMAP */ #endif /* SNDRV_PCM_INFO_MMAP */
/* mmap callback with pgprot_noncached */
int snd_pcm_lib_mmap_noncached(struct snd_pcm_substream *substream,
struct vm_area_struct *area)
{
area->vm_page_prot = pgprot_noncached(area->vm_page_prot);
return snd_pcm_default_mmap(substream, area);
}
EXPORT_SYMBOL(snd_pcm_lib_mmap_noncached);
/* /*
* mmap DMA buffer * mmap DMA buffer
*/ */

2
sound/oss/dev_table.h
View File

@ -271,7 +271,7 @@ struct synth_operations
void (*reset) (int dev); void (*reset) (int dev);
void (*hw_control) (int dev, unsigned char *event); void (*hw_control) (int dev, unsigned char *event);
int (*load_patch) (int dev, int format, const char __user *addr, int (*load_patch) (int dev, int format, const char __user *addr,
int offs, int count, int pmgr_flag); int count, int pmgr_flag);
void (*aftertouch) (int dev, int voice, int pressure); void (*aftertouch) (int dev, int voice, int pressure);
void (*controller) (int dev, int voice, int ctrl_num, int value); void (*controller) (int dev, int voice, int ctrl_num, int value);
void (*panning) (int dev, int voice, int value); void (*panning) (int dev, int voice, int value);

30
sound/oss/midi_synth.c
View File

@ -476,7 +476,7 @@ EXPORT_SYMBOL(midi_synth_hw_control);
int int
midi_synth_load_patch(int dev, int format, const char __user *addr, midi_synth_load_patch(int dev, int format, const char __user *addr,
int offs, int count, int pmgr_flag) int count, int pmgr_flag)
{ {
int orig_dev = synth_devs[dev]->midi_dev; int orig_dev = synth_devs[dev]->midi_dev;
@ -491,33 +491,29 @@ midi_synth_load_patch(int dev, int format, const char __user *addr,
if (!prefix_cmd(orig_dev, 0xf0)) if (!prefix_cmd(orig_dev, 0xf0))
return 0; return 0;
/* Invalid patch format */
if (format != SYSEX_PATCH) if (format != SYSEX_PATCH)
{
/* printk("MIDI Error: Invalid patch format (key) 0x%x\n", format);*/
return -EINVAL; return -EINVAL;
}
/* Patch header too short */
if (count < hdr_size) if (count < hdr_size)
{
/* printk("MIDI Error: Patch header too short\n");*/
return -EINVAL; return -EINVAL;
}
count -= hdr_size; count -= hdr_size;
/* /*
* Copy the header from user space but ignore the first bytes which have * Copy the header from user space
* been transferred already.
*/ */
if(copy_from_user(&((char *) &sysex)[offs], &(addr)[offs], hdr_size - offs)) if (copy_from_user(&sysex, addr, hdr_size))
return -EFAULT; return -EFAULT;
if (count < sysex.len) /* Sysex record too short */
{ if ((unsigned)count < (unsigned)sysex.len)
/* printk(KERN_WARNING "MIDI Warning: Sysex record too short (%d<%d)\n", count, (int) sysex.len);*/
sysex.len = count; sysex.len = count;
}
left = sysex.len; left = sysex.len;
src_offs = 0; src_offs = 0;
for (i = 0; i < left && !signal_pending(current); i++) for (i = 0; i < left && !signal_pending(current); i++)
{ {

2
sound/oss/midi_synth.h
View File

@ -8,7 +8,7 @@ int midi_synth_open (int dev, int mode);
void midi_synth_close (int dev); void midi_synth_close (int dev);
void midi_synth_hw_control (int dev, unsigned char *event); void midi_synth_hw_control (int dev, unsigned char *event);
int midi_synth_load_patch (int dev, int format, const char __user * addr, int midi_synth_load_patch (int dev, int format, const char __user * addr,
int offs, int count, int pmgr_flag); int count, int pmgr_flag);
void midi_synth_panning (int dev, int channel, int pressure); void midi_synth_panning (int dev, int channel, int pressure);
void midi_synth_aftertouch (int dev, int channel, int pressure); void midi_synth_aftertouch (int dev, int channel, int pressure);
void midi_synth_controller (int dev, int channel, int ctrl_num, int value); void midi_synth_controller (int dev, int channel, int ctrl_num, int value);

23
sound/oss/opl3.c
View File

@ -820,7 +820,7 @@ static void opl3_hw_control(int dev, unsigned char *event)
} }
static int opl3_load_patch(int dev, int format, const char __user *addr, static int opl3_load_patch(int dev, int format, const char __user *addr,
int offs, int count, int pmgr_flag) int count, int pmgr_flag)
{ {
struct sbi_instrument ins; struct sbi_instrument ins;
@ -830,11 +830,7 @@ static int opl3_load_patch(int dev, int format, const char __user *addr,
return -EINVAL; return -EINVAL;
} }
/* if (copy_from_user(&ins, addr, sizeof(ins)))
* What the fuck is going on here? We leave junk in the beginning
* of ins and then check the field pretty close to that beginning?
*/
if(copy_from_user(&((char *) &ins)[offs], addr + offs, sizeof(ins) - offs))
return -EFAULT; return -EFAULT;
if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR) if (ins.channel < 0 || ins.channel >= SBFM_MAXINSTR)
@ -849,6 +845,10 @@ static int opl3_load_patch(int dev, int format, const char __user *addr,
static void opl3_panning(int dev, int voice, int value) static void opl3_panning(int dev, int voice, int value)
{ {
if (voice < 0 || voice >= devc->nr_voice)
return;
devc->voc[voice].panning = value; devc->voc[voice].panning = value;
} }
@ -1066,8 +1066,15 @@ static int opl3_alloc_voice(int dev, int chn, int note, struct voice_alloc_info
static void opl3_setup_voice(int dev, int voice, int chn) static void opl3_setup_voice(int dev, int voice, int chn)
{ {
struct channel_info *info = struct channel_info *info;
&synth_devs[dev]->chn_info[chn];
if (voice < 0 || voice >= devc->nr_voice)
return;
if (chn < 0 || chn > 15)
return;
info = &synth_devs[dev]->chn_info[chn];
opl3_set_instr(dev, voice, info->pgm_num); opl3_set_instr(dev, voice, info->pgm_num);

2
sound/oss/sequencer.c
View File

@ -241,7 +241,7 @@ int sequencer_write(int dev, struct file *file, const char __user *buf, int coun
return -ENXIO; return -ENXIO;
fmt = (*(short *) &event_rec[0]) & 0xffff; fmt = (*(short *) &event_rec[0]) & 0xffff;
err = synth_devs[dev]->load_patch(dev, fmt, buf, p + 4, c, 0); err = synth_devs[dev]->load_patch(dev, fmt, buf + p, c, 0);
if (err < 0) if (err < 0)
return err; return err;

137
sound/pci/asihpi/asihpi.c
View File

@ -22,21 +22,6 @@
* for any purpose including commercial applications. * for any purpose including commercial applications.
*/ */
/* >0: print Hw params, timer vars. >1: print stream write/copy sizes */
#define REALLY_VERBOSE_LOGGING 0
#if REALLY_VERBOSE_LOGGING
#define VPRINTK1 snd_printd
#else
#define VPRINTK1(...)
#endif
#if REALLY_VERBOSE_LOGGING > 1
#define VPRINTK2 snd_printd
#else
#define VPRINTK2(...)
#endif
#include "hpi_internal.h" #include "hpi_internal.h"
#include "hpimsginit.h" #include "hpimsginit.h"
#include "hpioctl.h" #include "hpioctl.h"
@ -57,11 +42,25 @@
#include <sound/tlv.h> #include <sound/tlv.h>
#include <sound/hwdep.h> #include <sound/hwdep.h>
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("AudioScience inc. <support@audioscience.com>"); MODULE_AUTHOR("AudioScience inc. <support@audioscience.com>");
MODULE_DESCRIPTION("AudioScience ALSA ASI5000 ASI6000 ASI87xx ASI89xx"); MODULE_DESCRIPTION("AudioScience ALSA ASI5000 ASI6000 ASI87xx ASI89xx");
#if defined CONFIG_SND_DEBUG_VERBOSE
/**
* snd_printddd - very verbose debug printk
* @format: format string
*
* Works like snd_printk() for debugging purposes.
* Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
* Must set snd module debug parameter to 3 to enable at runtime.
*/
#define snd_printddd(format, args...) \
__snd_printk(3, __FILE__, __LINE__, format, ##args)
#else
#define snd_printddd(format, args...) do { } while (0)
#endif
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* index 0-MAX */ static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* index 0-MAX */
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
@ -289,7 +288,6 @@ static u16 handle_error(u16 err, int line, char *filename)
#define hpi_handle_error(x) handle_error(x, __LINE__, __FILE__) #define hpi_handle_error(x) handle_error(x, __LINE__, __FILE__)
/***************************** GENERAL PCM ****************/ /***************************** GENERAL PCM ****************/
#if REALLY_VERBOSE_LOGGING
static void print_hwparams(struct snd_pcm_hw_params *p) static void print_hwparams(struct snd_pcm_hw_params *p)
{ {
snd_printd("HWPARAMS \n"); snd_printd("HWPARAMS \n");
@ -304,9 +302,6 @@ static void print_hwparams(struct snd_pcm_hw_params *p)
snd_printd("periods %d \n", params_periods(p)); snd_printd("periods %d \n", params_periods(p));
snd_printd("buffer_size %d \n", params_buffer_size(p)); snd_printd("buffer_size %d \n", params_buffer_size(p));
} }
#else
#define print_hwparams(x)
#endif
static snd_pcm_format_t hpi_to_alsa_formats[] = { static snd_pcm_format_t hpi_to_alsa_formats[] = {
-1, /* INVALID */ -1, /* INVALID */
@ -381,13 +376,13 @@ static void snd_card_asihpi_pcm_samplerates(struct snd_card_asihpi *asihpi,
"No local sampleclock, err %d\n", err); "No local sampleclock, err %d\n", err);
} }
for (idx = 0; idx < 100; idx++) { for (idx = -1; idx < 100; idx++) {
if (hpi_sample_clock_query_local_rate( if (idx == -1) {
h_control, idx, &sample_rate)) { if (hpi_sample_clock_get_sample_rate(h_control,
if (!idx) &sample_rate))
snd_printk(KERN_ERR continue;
"Local rate query failed\n"); } else if (hpi_sample_clock_query_local_rate(h_control,
idx, &sample_rate)) {
break; break;
} }
@ -440,8 +435,6 @@ static void snd_card_asihpi_pcm_samplerates(struct snd_card_asihpi *asihpi,
} }
} }
/* printk(KERN_INFO "Supported rates %X %d %d\n",
rates, rate_min, rate_max); */
pcmhw->rates = rates; pcmhw->rates = rates;
pcmhw->rate_min = rate_min; pcmhw->rate_min = rate_min;
pcmhw->rate_max = rate_max; pcmhw->rate_max = rate_max;
@ -466,7 +459,7 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
if (err) if (err)
return err; return err;
VPRINTK1(KERN_INFO "format %d, %d chans, %d_hz\n", snd_printdd("format %d, %d chans, %d_hz\n",
format, params_channels(params), format, params_channels(params),
params_rate(params)); params_rate(params));
@ -489,13 +482,12 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
err = hpi_stream_host_buffer_attach(dpcm->h_stream, err = hpi_stream_host_buffer_attach(dpcm->h_stream,
params_buffer_bytes(params), runtime->dma_addr); params_buffer_bytes(params), runtime->dma_addr);
if (err == 0) { if (err == 0) {
VPRINTK1(KERN_INFO snd_printdd(
"stream_host_buffer_attach succeeded %u %lu\n", "stream_host_buffer_attach succeeded %u %lu\n",
params_buffer_bytes(params), params_buffer_bytes(params),
(unsigned long)runtime->dma_addr); (unsigned long)runtime->dma_addr);
} else { } else {
snd_printd(KERN_INFO snd_printd("stream_host_buffer_attach error %d\n",
"stream_host_buffer_attach error %d\n",
err); err);
return -ENOMEM; return -ENOMEM;
} }
@ -504,7 +496,7 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
&dpcm->hpi_buffer_attached, &dpcm->hpi_buffer_attached,
NULL, NULL, NULL); NULL, NULL, NULL);
VPRINTK1(KERN_INFO "stream_host_buffer_attach status 0x%x\n", snd_printdd("stream_host_buffer_attach status 0x%x\n",
dpcm->hpi_buffer_attached); dpcm->hpi_buffer_attached);
} }
bytes_per_sec = params_rate(params) * params_channels(params); bytes_per_sec = params_rate(params) * params_channels(params);
@ -517,7 +509,7 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
dpcm->bytes_per_sec = bytes_per_sec; dpcm->bytes_per_sec = bytes_per_sec;
dpcm->buffer_bytes = params_buffer_bytes(params); dpcm->buffer_bytes = params_buffer_bytes(params);
dpcm->period_bytes = params_period_bytes(params); dpcm->period_bytes = params_period_bytes(params);
VPRINTK1(KERN_INFO "buffer_bytes=%d, period_bytes=%d, bps=%d\n", snd_printdd("buffer_bytes=%d, period_bytes=%d, bps=%d\n",
dpcm->buffer_bytes, dpcm->period_bytes, bytes_per_sec); dpcm->buffer_bytes, dpcm->period_bytes, bytes_per_sec);
return 0; return 0;
@ -573,7 +565,7 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
struct snd_pcm_substream *s; struct snd_pcm_substream *s;
u16 e; u16 e;
VPRINTK1(KERN_INFO "%c%d trigger\n", snd_printdd("%c%d trigger\n",
SCHR(substream->stream), substream->number); SCHR(substream->stream), substream->number);
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
@ -597,7 +589,7 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
* data?? * data??
*/ */
unsigned int preload = ds->period_bytes * 1; unsigned int preload = ds->period_bytes * 1;
VPRINTK2(KERN_INFO "%d preload x%x\n", s->number, preload); snd_printddd("%d preload x%x\n", s->number, preload);
hpi_handle_error(hpi_outstream_write_buf( hpi_handle_error(hpi_outstream_write_buf(
ds->h_stream, ds->h_stream,
&runtime->dma_area[0], &runtime->dma_area[0],
@ -607,7 +599,7 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
} }
if (card->support_grouping) { if (card->support_grouping) {
VPRINTK1(KERN_INFO "\t%c%d group\n", snd_printdd("\t%c%d group\n",
SCHR(s->stream), SCHR(s->stream),
s->number); s->number);
e = hpi_stream_group_add( e = hpi_stream_group_add(
@ -622,7 +614,7 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
} else } else
break; break;
} }
VPRINTK1(KERN_INFO "start\n"); snd_printdd("start\n");
/* start the master stream */ /* start the master stream */
snd_card_asihpi_pcm_timer_start(substream); snd_card_asihpi_pcm_timer_start(substream);
if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) || if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ||
@ -644,14 +636,14 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
s->runtime->status->state = SNDRV_PCM_STATE_SETUP; s->runtime->status->state = SNDRV_PCM_STATE_SETUP;
if (card->support_grouping) { if (card->support_grouping) {
VPRINTK1(KERN_INFO "\t%c%d group\n", snd_printdd("\t%c%d group\n",
SCHR(s->stream), SCHR(s->stream),
s->number); s->number);
snd_pcm_trigger_done(s, substream); snd_pcm_trigger_done(s, substream);
} else } else
break; break;
} }
VPRINTK1(KERN_INFO "stop\n"); snd_printdd("stop\n");
/* _prepare and _hwparams reset the stream */ /* _prepare and _hwparams reset the stream */
hpi_handle_error(hpi_stream_stop(dpcm->h_stream)); hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
@ -664,12 +656,12 @@ static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
break; break;
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
VPRINTK1(KERN_INFO "pause release\n"); snd_printdd("pause release\n");
hpi_handle_error(hpi_stream_start(dpcm->h_stream)); hpi_handle_error(hpi_stream_start(dpcm->h_stream));
snd_card_asihpi_pcm_timer_start(substream); snd_card_asihpi_pcm_timer_start(substream);
break; break;
case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
VPRINTK1(KERN_INFO "pause\n"); snd_printdd("pause\n");
snd_card_asihpi_pcm_timer_stop(substream); snd_card_asihpi_pcm_timer_stop(substream);
hpi_handle_error(hpi_stream_stop(dpcm->h_stream)); hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
break; break;
@ -741,7 +733,7 @@ static void snd_card_asihpi_timer_function(unsigned long data)
u16 state; u16 state;
u32 buffer_size, bytes_avail, samples_played, on_card_bytes; u32 buffer_size, bytes_avail, samples_played, on_card_bytes;
VPRINTK1(KERN_INFO "%c%d snd_card_asihpi_timer_function\n", snd_printdd("%c%d snd_card_asihpi_timer_function\n",
SCHR(substream->stream), substream->number); SCHR(substream->stream), substream->number);
/* find minimum newdata and buffer pos in group */ /* find minimum newdata and buffer pos in group */
@ -770,10 +762,10 @@ static void snd_card_asihpi_timer_function(unsigned long data)
if ((bytes_avail == 0) && if ((bytes_avail == 0) &&
(on_card_bytes < ds->pcm_buf_host_rw_ofs)) { (on_card_bytes < ds->pcm_buf_host_rw_ofs)) {
hpi_handle_error(hpi_stream_start(ds->h_stream)); hpi_handle_error(hpi_stream_start(ds->h_stream));
VPRINTK1(KERN_INFO "P%d start\n", s->number); snd_printdd("P%d start\n", s->number);
} }
} else if (state == HPI_STATE_DRAINED) { } else if (state == HPI_STATE_DRAINED) {
VPRINTK1(KERN_WARNING "P%d drained\n", snd_printd(KERN_WARNING "P%d drained\n",
s->number); s->number);
/*snd_pcm_stop(s, SNDRV_PCM_STATE_XRUN); /*snd_pcm_stop(s, SNDRV_PCM_STATE_XRUN);
continue; */ continue; */
@ -794,13 +786,13 @@ static void snd_card_asihpi_timer_function(unsigned long data)
newdata); newdata);
} }
VPRINTK1(KERN_INFO "PB timer hw_ptr x%04lX, appl_ptr x%04lX\n", snd_printdd("hw_ptr x%04lX, appl_ptr x%04lX\n",
(unsigned long)frames_to_bytes(runtime, (unsigned long)frames_to_bytes(runtime,
runtime->status->hw_ptr), runtime->status->hw_ptr),
(unsigned long)frames_to_bytes(runtime, (unsigned long)frames_to_bytes(runtime,
runtime->control->appl_ptr)); runtime->control->appl_ptr));
VPRINTK1(KERN_INFO "%d %c%d S=%d, rw=%04X, dma=x%04X, left=x%04X," snd_printdd("%d %c%d S=%d, rw=%04X, dma=x%04X, left=x%04X,"
" aux=x%04X space=x%04X\n", " aux=x%04X space=x%04X\n",
loops, SCHR(s->stream), s->number, loops, SCHR(s->stream), s->number,
state, ds->pcm_buf_host_rw_ofs, pcm_buf_dma_ofs, (int)bytes_avail, state, ds->pcm_buf_host_rw_ofs, pcm_buf_dma_ofs, (int)bytes_avail,
@ -822,7 +814,7 @@ static void snd_card_asihpi_timer_function(unsigned long data)
next_jiffies = max(next_jiffies, 1U); next_jiffies = max(next_jiffies, 1U);
dpcm->timer.expires = jiffies + next_jiffies; dpcm->timer.expires = jiffies + next_jiffies;
VPRINTK1(KERN_INFO "jif %d buf pos x%04X newdata x%04X xfer x%04X\n", snd_printdd("jif %d buf pos x%04X newdata x%04X xfer x%04X\n",
next_jiffies, pcm_buf_dma_ofs, newdata, xfercount); next_jiffies, pcm_buf_dma_ofs, newdata, xfercount);
snd_pcm_group_for_each_entry(s, substream) { snd_pcm_group_for_each_entry(s, substream) {
@ -837,7 +829,7 @@ static void snd_card_asihpi_timer_function(unsigned long data)
if (xfercount && (on_card_bytes <= ds->period_bytes)) { if (xfercount && (on_card_bytes <= ds->period_bytes)) {
if (card->support_mmap) { if (card->support_mmap) {
if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) { if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
VPRINTK2(KERN_INFO "P%d write x%04x\n", snd_printddd("P%d write x%04x\n",
s->number, s->number,
ds->period_bytes); ds->period_bytes);
hpi_handle_error( hpi_handle_error(
@ -848,7 +840,7 @@ static void snd_card_asihpi_timer_function(unsigned long data)
xfercount, xfercount,
&ds->format)); &ds->format));
} else { } else {
VPRINTK2(KERN_INFO "C%d read x%04x\n", snd_printddd("C%d read x%04x\n",
s->number, s->number,
xfercount); xfercount);
hpi_handle_error( hpi_handle_error(
@ -871,7 +863,7 @@ static void snd_card_asihpi_timer_function(unsigned long data)
static int snd_card_asihpi_playback_ioctl(struct snd_pcm_substream *substream, static int snd_card_asihpi_playback_ioctl(struct snd_pcm_substream *substream,
unsigned int cmd, void *arg) unsigned int cmd, void *arg)
{ {
/* snd_printd(KERN_INFO "Playback ioctl %d\n", cmd); */ snd_printdd(KERN_INFO "Playback ioctl %d\n", cmd);
return snd_pcm_lib_ioctl(substream, cmd, arg); return snd_pcm_lib_ioctl(substream, cmd, arg);
} }
@ -881,7 +873,7 @@ static int snd_card_asihpi_playback_prepare(struct snd_pcm_substream *
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_card_asihpi_pcm *dpcm = runtime->private_data; struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
VPRINTK1(KERN_INFO "playback prepare %d\n", substream->number); snd_printdd("playback prepare %d\n", substream->number);
hpi_handle_error(hpi_outstream_reset(dpcm->h_stream)); hpi_handle_error(hpi_outstream_reset(dpcm->h_stream));
dpcm->pcm_buf_host_rw_ofs = 0; dpcm->pcm_buf_host_rw_ofs = 0;
@ -898,7 +890,7 @@ snd_card_asihpi_playback_pointer(struct snd_pcm_substream *substream)
snd_pcm_uframes_t ptr; snd_pcm_uframes_t ptr;
ptr = bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes); ptr = bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
/* VPRINTK2(KERN_INFO "playback_pointer=x%04lx\n", (unsigned long)ptr); */ snd_printddd("playback_pointer=x%04lx\n", (unsigned long)ptr);
return ptr; return ptr;
} }
@ -1014,12 +1006,13 @@ static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
card->update_interval_frames); card->update_interval_frames);
snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
card->update_interval_frames * 2, UINT_MAX); card->update_interval_frames * 2, UINT_MAX);
snd_pcm_set_sync(substream); snd_pcm_set_sync(substream);
VPRINTK1(KERN_INFO "playback open\n"); snd_printdd("playback open\n");
return 0; return 0;
} }
@ -1030,7 +1023,7 @@ static int snd_card_asihpi_playback_close(struct snd_pcm_substream *substream)
struct snd_card_asihpi_pcm *dpcm = runtime->private_data; struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
hpi_handle_error(hpi_outstream_close(dpcm->h_stream)); hpi_handle_error(hpi_outstream_close(dpcm->h_stream));
VPRINTK1(KERN_INFO "playback close\n"); snd_printdd("playback close\n");
return 0; return 0;
} }
@ -1050,13 +1043,13 @@ static int snd_card_asihpi_playback_copy(struct snd_pcm_substream *substream,
if (copy_from_user(runtime->dma_area, src, len)) if (copy_from_user(runtime->dma_area, src, len))
return -EFAULT; return -EFAULT;
VPRINTK2(KERN_DEBUG "playback copy%d %u bytes\n", snd_printddd("playback copy%d %u bytes\n",
substream->number, len); substream->number, len);
hpi_handle_error(hpi_outstream_write_buf(dpcm->h_stream, hpi_handle_error(hpi_outstream_write_buf(dpcm->h_stream,
runtime->dma_area, len, &dpcm->format)); runtime->dma_area, len, &dpcm->format));
dpcm->pcm_buf_host_rw_ofs = dpcm->pcm_buf_host_rw_ofs + len; dpcm->pcm_buf_host_rw_ofs += len;
return 0; return 0;
} }
@ -1066,16 +1059,11 @@ static int snd_card_asihpi_playback_silence(struct snd_pcm_substream *
snd_pcm_uframes_t pos, snd_pcm_uframes_t pos,
snd_pcm_uframes_t count) snd_pcm_uframes_t count)
{ {
unsigned int len; /* Usually writes silence to DMA buffer, which should be overwritten
struct snd_pcm_runtime *runtime = substream->runtime; by real audio later. Our fifos cannot be overwritten, and are not
struct snd_card_asihpi_pcm *dpcm = runtime->private_data; free-running DMAs. Silence is output on fifo underflow.
This callback is still required to allow the copy callback to be used.
len = frames_to_bytes(runtime, count); */
VPRINTK1(KERN_INFO "playback silence %u bytes\n", len);
memset(runtime->dma_area, 0, len);
hpi_handle_error(hpi_outstream_write_buf(dpcm->h_stream,
runtime->dma_area, len, &dpcm->format));
return 0; return 0;
} }
@ -1110,7 +1098,7 @@ snd_card_asihpi_capture_pointer(struct snd_pcm_substream *substream)
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_card_asihpi_pcm *dpcm = runtime->private_data; struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
VPRINTK2(KERN_INFO "capture pointer %d=%d\n", snd_printddd("capture pointer %d=%d\n",
substream->number, dpcm->pcm_buf_dma_ofs); substream->number, dpcm->pcm_buf_dma_ofs);
/* NOTE Unlike playback can't use actual samples_played /* NOTE Unlike playback can't use actual samples_played
for the capture position, because those samples aren't yet in for the capture position, because those samples aren't yet in
@ -1135,7 +1123,7 @@ static int snd_card_asihpi_capture_prepare(struct snd_pcm_substream *substream)
dpcm->pcm_buf_dma_ofs = 0; dpcm->pcm_buf_dma_ofs = 0;
dpcm->pcm_buf_elapsed_dma_ofs = 0; dpcm->pcm_buf_elapsed_dma_ofs = 0;
VPRINTK1("Capture Prepare %d\n", substream->number); snd_printdd("Capture Prepare %d\n", substream->number);
return 0; return 0;
} }
@ -1198,7 +1186,7 @@ static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
if (dpcm == NULL) if (dpcm == NULL)
return -ENOMEM; return -ENOMEM;
VPRINTK1("hpi_instream_open adapter %d stream %d\n", snd_printdd("capture open adapter %d stream %d\n",
card->adapter_index, substream->number); card->adapter_index, substream->number);
err = hpi_handle_error( err = hpi_handle_error(
@ -1268,7 +1256,7 @@ static int snd_card_asihpi_capture_copy(struct snd_pcm_substream *substream,
len = frames_to_bytes(runtime, count); len = frames_to_bytes(runtime, count);
VPRINTK2(KERN_INFO "capture copy%d %d bytes\n", substream->number, len); snd_printddd("capture copy%d %d bytes\n", substream->number, len);
hpi_handle_error(hpi_instream_read_buf(dpcm->h_stream, hpi_handle_error(hpi_instream_read_buf(dpcm->h_stream,
runtime->dma_area, len)); runtime->dma_area, len));
@ -2887,6 +2875,9 @@ static int __devinit snd_asihpi_probe(struct pci_dev *pci_dev,
if (err) if (err)
asihpi->update_interval_frames = 512; asihpi->update_interval_frames = 512;
if (!asihpi->support_mmap)
asihpi->update_interval_frames *= 2;
hpi_handle_error(hpi_instream_open(asihpi->adapter_index, hpi_handle_error(hpi_instream_open(asihpi->adapter_index,
0, &h_stream)); 0, &h_stream));
@ -2909,7 +2900,6 @@ static int __devinit snd_asihpi_probe(struct pci_dev *pci_dev,
asihpi->support_mrx asihpi->support_mrx
); );
err = snd_card_asihpi_pcm_new(asihpi, 0, pcm_substreams); err = snd_card_asihpi_pcm_new(asihpi, 0, pcm_substreams);
if (err < 0) { if (err < 0) {
snd_printk(KERN_ERR "pcm_new failed\n"); snd_printk(KERN_ERR "pcm_new failed\n");
@ -2944,6 +2934,7 @@ static int __devinit snd_asihpi_probe(struct pci_dev *pci_dev,
sprintf(card->longname, "%s %i", sprintf(card->longname, "%s %i",
card->shortname, asihpi->adapter_index); card->shortname, asihpi->adapter_index);
err = snd_card_register(card); err = snd_card_register(card);
if (!err) { if (!err) {
hpi_card->snd_card_asihpi = card; hpi_card->snd_card_asihpi = card;
dev++; dev++;

89
sound/pci/hda/patch_analog.c
View File

@ -4255,6 +4255,84 @@ static int ad1984a_thinkpad_init(struct hda_codec *codec)
return 0; return 0;
} }
/*
* Precision R5500
* 0x12 - HP/line-out
* 0x13 - speaker (mono)
* 0x15 - mic-in
*/
static struct hda_verb ad1984a_precision_verbs[] = {
/* Unmute main output path */
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x1f}, /* 0dB */
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) + 0x17}, /* 0dB */
/* Analog mixer; mute as default */
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
{0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
/* Select mic as input */
{0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x27}, /* 0dB */
/* Configure as mic */
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
/* HP unmute */
{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
/* turn on EAPD */
{0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
/* unsolicited event for pin-sense */
{0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
{ } /* end */
};
static struct snd_kcontrol_new ad1984a_precision_mixers[] = {
HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x13, 0x0, HDA_OUTPUT),
HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
{ } /* end */
};
/* mute internal speaker if HP is plugged */
static void ad1984a_precision_automute(struct hda_codec *codec)
{
unsigned int present;
present = snd_hda_jack_detect(codec, 0x12);
snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
}
/* unsolicited event for HP jack sensing */
static void ad1984a_precision_unsol_event(struct hda_codec *codec,
unsigned int res)
{
if ((res >> 26) != AD1884A_HP_EVENT)
return;
ad1984a_precision_automute(codec);
}
/* initialize jack-sensing, too */
static int ad1984a_precision_init(struct hda_codec *codec)
{
ad198x_init(codec);
ad1984a_precision_automute(codec);
return 0;
}
/* /*
* HP Touchsmart * HP Touchsmart
* port-A (0x11) - front hp-out * port-A (0x11) - front hp-out
@ -4384,6 +4462,7 @@ enum {
AD1884A_MOBILE, AD1884A_MOBILE,
AD1884A_THINKPAD, AD1884A_THINKPAD,
AD1984A_TOUCHSMART, AD1984A_TOUCHSMART,
AD1984A_PRECISION,
AD1884A_MODELS AD1884A_MODELS
}; };
@ -4393,9 +4472,11 @@ static const char * const ad1884a_models[AD1884A_MODELS] = {
[AD1884A_MOBILE] = "mobile", [AD1884A_MOBILE] = "mobile",
[AD1884A_THINKPAD] = "thinkpad", [AD1884A_THINKPAD] = "thinkpad",
[AD1984A_TOUCHSMART] = "touchsmart", [AD1984A_TOUCHSMART] = "touchsmart",
[AD1984A_PRECISION] = "precision",
}; };
static struct snd_pci_quirk ad1884a_cfg_tbl[] = { static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
SND_PCI_QUIRK(0x1028, 0x04ac, "Precision R5500", AD1984A_PRECISION),
SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE), SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP), SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE), SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
@ -4489,6 +4570,14 @@ static int patch_ad1884a(struct hda_codec *codec)
codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event; codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
codec->patch_ops.init = ad1984a_thinkpad_init; codec->patch_ops.init = ad1984a_thinkpad_init;
break; break;
case AD1984A_PRECISION:
spec->mixers[0] = ad1984a_precision_mixers;
spec->init_verbs[spec->num_init_verbs++] =
ad1984a_precision_verbs;
spec->multiout.dig_out_nid = 0;
codec->patch_ops.unsol_event = ad1984a_precision_unsol_event;
codec->patch_ops.init = ad1984a_precision_init;
break;
case AD1984A_TOUCHSMART: case AD1984A_TOUCHSMART:
spec->mixers[0] = ad1984a_touchsmart_mixers; spec->mixers[0] = ad1984a_touchsmart_mixers;
spec->init_verbs[0] = ad1984a_touchsmart_verbs; spec->init_verbs[0] = ad1984a_touchsmart_verbs;

2
sound/pci/hda/patch_realtek.c
View File

@ -1290,7 +1290,7 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type)
case 0x10ec0883: case 0x10ec0883:
case 0x10ec0885: case 0x10ec0885:
case 0x10ec0887: case 0x10ec0887:
case 0x10ec0889: /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
alc889_coef_init(codec); alc889_coef_init(codec);
break; break;
case 0x10ec0888: case 0x10ec0888:

40
sound/usb/quirks-table.h
View File

@ -1567,6 +1567,46 @@ YAMAHA_DEVICE(0x7010, "UB99"),
} }
} }
}, },
{
USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
/* .vendor_name = "Roland", */
/* .product_name = "UM-1G", */
.ifnum = 0,
.type = QUIRK_MIDI_FIXED_ENDPOINT,
.data = & (const struct snd_usb_midi_endpoint_info) {
.out_cables = 0x0001,
.in_cables = 0x0001
}
}
},
{
/* Boss JS-8 Jam Station */
USB_DEVICE(0x0582, 0x0109),
.driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
/* .vendor_name = "BOSS", */
/* .product_name = "JS-8", */
.ifnum = QUIRK_ANY_INTERFACE,
.type = QUIRK_COMPOSITE,
.data = (const struct snd_usb_audio_quirk[]) {
{
.ifnum = 0,
.type = QUIRK_AUDIO_STANDARD_INTERFACE
},
{
.ifnum = 1,
.type = QUIRK_AUDIO_STANDARD_INTERFACE
},
{
.ifnum = 2,
.type = QUIRK_MIDI_STANDARD_INTERFACE
},
{
.ifnum = -1
}
}
}
},
{ {
/* has ID 0x0110 when not in Advanced Driver mode */ /* has ID 0x0110 when not in Advanced Driver mode */
USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f), USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),