![Takashi Sakamoto](/assets/img/avatar_default.png)
In hwdep interface of fireworks driver, accessing to user space is in a critical section with disabled local interrupt. Depending on architecture, accessing to user space can cause page fault exception. Then local processor stores machine status and handles the synchronous event. A handler corresponding to the event can call task scheduler to wait for preparing pages. In a case of usage of single core processor, the state to disable local interrupt is worse because it don't handle usual interrupts from hardware. This commit fixes this bug, performing the accessing outside spinlock. This commit also gives up counting the number of queued response messages to simplify ring-buffer management. Reported-by: Vaishali Thakkar <vaishali.thakkar@oracle.com> Cc: stable@vger.kernel.org Fixes: 555e8a8f7f14('ALSA: fireworks: Add command/response functionality into hwdep interface') Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp> Signed-off-by: Takashi Iwai <tiwai@suse.de>
233 lines
6.7 KiB
C
233 lines
6.7 KiB
C
/*
|
|
* fireworks_proc.c - a part of driver for Fireworks based devices
|
|
*
|
|
* Copyright (c) 2009-2010 Clemens Ladisch
|
|
* Copyright (c) 2013-2014 Takashi Sakamoto
|
|
*
|
|
* Licensed under the terms of the GNU General Public License, version 2.
|
|
*/
|
|
|
|
#include "./fireworks.h"
|
|
|
|
static inline const char*
|
|
get_phys_name(struct snd_efw_phys_grp *grp, bool input)
|
|
{
|
|
const char *const ch_type[] = {
|
|
"Analog", "S/PDIF", "ADAT", "S/PDIF or ADAT", "Mirroring",
|
|
"Headphones", "I2S", "Guitar", "Pirzo Guitar", "Guitar String",
|
|
};
|
|
|
|
if (grp->type < ARRAY_SIZE(ch_type))
|
|
return ch_type[grp->type];
|
|
else if (input)
|
|
return "Input";
|
|
else
|
|
return "Output";
|
|
}
|
|
|
|
static void
|
|
proc_read_hwinfo(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
|
|
{
|
|
struct snd_efw *efw = entry->private_data;
|
|
unsigned short i;
|
|
struct snd_efw_hwinfo *hwinfo;
|
|
|
|
hwinfo = kmalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
|
|
if (hwinfo == NULL)
|
|
return;
|
|
|
|
if (snd_efw_command_get_hwinfo(efw, hwinfo) < 0)
|
|
goto end;
|
|
|
|
snd_iprintf(buffer, "guid_hi: 0x%X\n", hwinfo->guid_hi);
|
|
snd_iprintf(buffer, "guid_lo: 0x%X\n", hwinfo->guid_lo);
|
|
snd_iprintf(buffer, "type: 0x%X\n", hwinfo->type);
|
|
snd_iprintf(buffer, "version: 0x%X\n", hwinfo->version);
|
|
snd_iprintf(buffer, "vendor_name: %s\n", hwinfo->vendor_name);
|
|
snd_iprintf(buffer, "model_name: %s\n", hwinfo->model_name);
|
|
|
|
snd_iprintf(buffer, "dsp_version: 0x%X\n", hwinfo->dsp_version);
|
|
snd_iprintf(buffer, "arm_version: 0x%X\n", hwinfo->arm_version);
|
|
snd_iprintf(buffer, "fpga_version: 0x%X\n", hwinfo->fpga_version);
|
|
|
|
snd_iprintf(buffer, "flags: 0x%X\n", hwinfo->flags);
|
|
|
|
snd_iprintf(buffer, "max_sample_rate: 0x%X\n", hwinfo->max_sample_rate);
|
|
snd_iprintf(buffer, "min_sample_rate: 0x%X\n", hwinfo->min_sample_rate);
|
|
snd_iprintf(buffer, "supported_clock: 0x%X\n",
|
|
hwinfo->supported_clocks);
|
|
|
|
snd_iprintf(buffer, "phys out: 0x%X\n", hwinfo->phys_out);
|
|
snd_iprintf(buffer, "phys in: 0x%X\n", hwinfo->phys_in);
|
|
|
|
snd_iprintf(buffer, "phys in grps: 0x%X\n",
|
|
hwinfo->phys_in_grp_count);
|
|
for (i = 0; i < hwinfo->phys_in_grp_count; i++) {
|
|
snd_iprintf(buffer,
|
|
"phys in grp[%d]: type 0x%X, count 0x%X\n",
|
|
i, hwinfo->phys_out_grps[i].type,
|
|
hwinfo->phys_out_grps[i].count);
|
|
}
|
|
|
|
snd_iprintf(buffer, "phys out grps: 0x%X\n",
|
|
hwinfo->phys_out_grp_count);
|
|
for (i = 0; i < hwinfo->phys_out_grp_count; i++) {
|
|
snd_iprintf(buffer,
|
|
"phys out grps[%d]: type 0x%X, count 0x%X\n",
|
|
i, hwinfo->phys_out_grps[i].type,
|
|
hwinfo->phys_out_grps[i].count);
|
|
}
|
|
|
|
snd_iprintf(buffer, "amdtp rx pcm channels 1x: 0x%X\n",
|
|
hwinfo->amdtp_rx_pcm_channels);
|
|
snd_iprintf(buffer, "amdtp tx pcm channels 1x: 0x%X\n",
|
|
hwinfo->amdtp_tx_pcm_channels);
|
|
snd_iprintf(buffer, "amdtp rx pcm channels 2x: 0x%X\n",
|
|
hwinfo->amdtp_rx_pcm_channels_2x);
|
|
snd_iprintf(buffer, "amdtp tx pcm channels 2x: 0x%X\n",
|
|
hwinfo->amdtp_tx_pcm_channels_2x);
|
|
snd_iprintf(buffer, "amdtp rx pcm channels 4x: 0x%X\n",
|
|
hwinfo->amdtp_rx_pcm_channels_4x);
|
|
snd_iprintf(buffer, "amdtp tx pcm channels 4x: 0x%X\n",
|
|
hwinfo->amdtp_tx_pcm_channels_4x);
|
|
|
|
snd_iprintf(buffer, "midi out ports: 0x%X\n", hwinfo->midi_out_ports);
|
|
snd_iprintf(buffer, "midi in ports: 0x%X\n", hwinfo->midi_in_ports);
|
|
|
|
snd_iprintf(buffer, "mixer playback channels: 0x%X\n",
|
|
hwinfo->mixer_playback_channels);
|
|
snd_iprintf(buffer, "mixer capture channels: 0x%X\n",
|
|
hwinfo->mixer_capture_channels);
|
|
end:
|
|
kfree(hwinfo);
|
|
}
|
|
|
|
static void
|
|
proc_read_clock(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
|
|
{
|
|
struct snd_efw *efw = entry->private_data;
|
|
enum snd_efw_clock_source clock_source;
|
|
unsigned int sampling_rate;
|
|
|
|
if (snd_efw_command_get_clock_source(efw, &clock_source) < 0)
|
|
return;
|
|
|
|
if (snd_efw_command_get_sampling_rate(efw, &sampling_rate) < 0)
|
|
return;
|
|
|
|
snd_iprintf(buffer, "Clock Source: %d\n", clock_source);
|
|
snd_iprintf(buffer, "Sampling Rate: %d\n", sampling_rate);
|
|
}
|
|
|
|
/*
|
|
* NOTE:
|
|
* dB = 20 * log10(linear / 0x01000000)
|
|
* -144.0 dB when linear is 0
|
|
*/
|
|
static void
|
|
proc_read_phys_meters(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
struct snd_efw *efw = entry->private_data;
|
|
struct snd_efw_phys_meters *meters;
|
|
unsigned int g, c, m, max, size;
|
|
const char *name;
|
|
u32 *linear;
|
|
int err;
|
|
|
|
size = sizeof(struct snd_efw_phys_meters) +
|
|
(efw->phys_in + efw->phys_out) * sizeof(u32);
|
|
meters = kzalloc(size, GFP_KERNEL);
|
|
if (meters == NULL)
|
|
return;
|
|
|
|
err = snd_efw_command_get_phys_meters(efw, meters, size);
|
|
if (err < 0)
|
|
goto end;
|
|
|
|
snd_iprintf(buffer, "Physical Meters:\n");
|
|
|
|
m = 0;
|
|
max = min(efw->phys_out, meters->out_meters);
|
|
linear = meters->values;
|
|
snd_iprintf(buffer, " %d Outputs:\n", max);
|
|
for (g = 0; g < efw->phys_out_grp_count; g++) {
|
|
name = get_phys_name(&efw->phys_out_grps[g], false);
|
|
for (c = 0; c < efw->phys_out_grps[g].count; c++) {
|
|
if (m < max)
|
|
snd_iprintf(buffer, "\t%s [%d]: %d\n",
|
|
name, c, linear[m++]);
|
|
}
|
|
}
|
|
|
|
m = 0;
|
|
max = min(efw->phys_in, meters->in_meters);
|
|
linear = meters->values + meters->out_meters;
|
|
snd_iprintf(buffer, " %d Inputs:\n", max);
|
|
for (g = 0; g < efw->phys_in_grp_count; g++) {
|
|
name = get_phys_name(&efw->phys_in_grps[g], true);
|
|
for (c = 0; c < efw->phys_in_grps[g].count; c++)
|
|
if (m < max)
|
|
snd_iprintf(buffer, "\t%s [%d]: %d\n",
|
|
name, c, linear[m++]);
|
|
}
|
|
end:
|
|
kfree(meters);
|
|
}
|
|
|
|
static void
|
|
proc_read_queues_state(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
struct snd_efw *efw = entry->private_data;
|
|
unsigned int consumed;
|
|
|
|
if (efw->pull_ptr > efw->push_ptr)
|
|
consumed = snd_efw_resp_buf_size -
|
|
(unsigned int)(efw->pull_ptr - efw->push_ptr);
|
|
else
|
|
consumed = (unsigned int)(efw->push_ptr - efw->pull_ptr);
|
|
|
|
snd_iprintf(buffer, "%d/%d\n",
|
|
consumed, snd_efw_resp_buf_size);
|
|
}
|
|
|
|
static void
|
|
add_node(struct snd_efw *efw, struct snd_info_entry *root, const char *name,
|
|
void (*op)(struct snd_info_entry *e, struct snd_info_buffer *b))
|
|
{
|
|
struct snd_info_entry *entry;
|
|
|
|
entry = snd_info_create_card_entry(efw->card, name, root);
|
|
if (entry == NULL)
|
|
return;
|
|
|
|
snd_info_set_text_ops(entry, efw, op);
|
|
if (snd_info_register(entry) < 0)
|
|
snd_info_free_entry(entry);
|
|
}
|
|
|
|
void snd_efw_proc_init(struct snd_efw *efw)
|
|
{
|
|
struct snd_info_entry *root;
|
|
|
|
/*
|
|
* All nodes are automatically removed at snd_card_disconnect(),
|
|
* by following to link list.
|
|
*/
|
|
root = snd_info_create_card_entry(efw->card, "firewire",
|
|
efw->card->proc_root);
|
|
if (root == NULL)
|
|
return;
|
|
root->mode = S_IFDIR | S_IRUGO | S_IXUGO;
|
|
if (snd_info_register(root) < 0) {
|
|
snd_info_free_entry(root);
|
|
return;
|
|
}
|
|
|
|
add_node(efw, root, "clock", proc_read_clock);
|
|
add_node(efw, root, "firmware", proc_read_hwinfo);
|
|
add_node(efw, root, "meters", proc_read_phys_meters);
|
|
add_node(efw, root, "queues", proc_read_queues_state);
|
|
}
|