marvin
/
us144mkii
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

proper kernel code formatting

This commit is contained in:
Šerif Rami 2025-08-03 22:47:19 +02:00
parent 5777265466
commit f44b75094c
8 changed files with 1804 additions and 1681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

855
us144mkii.c
View File

File diff suppressed because it is too large Load Diff

206
us144mkii.h
View File

@ -4,21 +4,20 @@
#ifndef __US144MKII_H #ifndef __US144MKII_H
#define __US144MKII_H #define __US144MKII_H
#include <linux/kfifo.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <sound/control.h> #include <linux/kfifo.h>
#include <sound/core.h> #include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h> #include <sound/pcm.h>
#include <sound/rawmidi.h> #include <sound/rawmidi.h>
#include <sound/initval.h>
#include <sound/control.h>
#define DRIVER_NAME "us144mkii" #define DRIVER_NAME "us144mkii"
#define DRIVER_VERSION "1.7.5" #define DRIVER_VERSION "1.7.4"
/* --- USB Device Identification --- */ /* --- USB Device Identification --- */
#define USB_VID_TASCAM 0x0644 #define USB_VID_TASCAM 0x0644
#define USB_PID_TASCAM_US144 0x800f
#define USB_PID_TASCAM_US144MKII 0x8020 #define USB_PID_TASCAM_US144MKII 0x8020
/* --- USB Endpoints (Alternate Setting 1) --- */ /* --- USB Endpoints (Alternate Setting 1) --- */
@ -35,36 +34,36 @@
#define RT_D2H_VENDOR_DEV (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE) #define RT_D2H_VENDOR_DEV (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
enum uac_request { enum uac_request {
UAC_SET_CUR = 0x01, UAC_SET_CUR = 0x01,
UAC_GET_CUR = 0x81, UAC_GET_CUR = 0x81,
}; };
enum uac_control_selector { enum uac_control_selector {
UAC_SAMPLING_FREQ_CONTROL = 0x0100, UAC_SAMPLING_FREQ_CONTROL = 0x0100,
}; };
enum tascam_vendor_request { enum tascam_vendor_request {
VENDOR_REQ_REGISTER_WRITE = 0x41, VENDOR_REQ_REGISTER_WRITE = 0x41,
VENDOR_REQ_MODE_CONTROL = 0x49, VENDOR_REQ_MODE_CONTROL = 0x49,
}; };
enum tascam_mode_value { enum tascam_mode_value {
MODE_VAL_HANDSHAKE_READ = 0x0000, MODE_VAL_HANDSHAKE_READ = 0x0000,
MODE_VAL_CONFIG = 0x0010, MODE_VAL_CONFIG = 0x0010,
MODE_VAL_STREAM_START = 0x0030, MODE_VAL_STREAM_START = 0x0030,
}; };
#define HANDSHAKE_SUCCESS_VAL 0x12 #define HANDSHAKE_SUCCESS_VAL 0x12
enum tascam_register { enum tascam_register {
REG_ADDR_UNKNOWN_0D = 0x0d04, REG_ADDR_UNKNOWN_0D = 0x0d04,
REG_ADDR_UNKNOWN_0E = 0x0e00, REG_ADDR_UNKNOWN_0E = 0x0e00,
REG_ADDR_UNKNOWN_0F = 0x0f00, REG_ADDR_UNKNOWN_0F = 0x0f00,
REG_ADDR_RATE_44100 = 0x1000, REG_ADDR_RATE_44100 = 0x1000,
REG_ADDR_RATE_48000 = 0x1002, REG_ADDR_RATE_48000 = 0x1002,
REG_ADDR_RATE_88200 = 0x1008, REG_ADDR_RATE_88200 = 0x1008,
REG_ADDR_RATE_96000 = 0x100a, REG_ADDR_RATE_96000 = 0x100a,
REG_ADDR_UNKNOWN_11 = 0x110b, REG_ADDR_UNKNOWN_11 = 0x110b,
}; };
#define REG_VAL_ENABLE 0x0101 #define REG_VAL_ENABLE 0x0101
@ -152,23 +151,17 @@ enum tascam_register {
* @active_urbs: Atomic counter for active URBs. * @active_urbs: Atomic counter for active URBs.
* @current_rate: Currently configured sample rate of the device. * @current_rate: Currently configured sample rate of the device.
* @line_out_source: Source for Line Outputs (0: Playback 1-2, 1: Playback 3-4). * @line_out_source: Source for Line Outputs (0: Playback 1-2, 1: Playback 3-4).
* @digital_out_source: Source for Digital Outputs (0: Playback 1-2, 1: Playback * @digital_out_source: Source for Digital Outputs (0: Playback 1-2, 1: Playback 3-4).
* 3-4). * @capture_12_source: Source for Capture channels 1-2 (0: Analog In, 1: Digital In).
* @capture_12_source: Source for Capture channels 1-2 (0: Analog In, 1: Digital * @capture_34_source: Source for Capture channels 3-4 (0: Analog In, 1: Digital In).
* In).
* @capture_34_source: Source for Capture channels 3-4 (0: Analog In, 1: Digital
* In).
* *
* @feedback_accumulator_pattern: Stores the calculated frames per packet for * @feedback_accumulator_pattern: Stores the calculated frames per packet for feedback.
* feedback.
* @feedback_pattern_out_idx: Read index for feedback_accumulator_pattern. * @feedback_pattern_out_idx: Read index for feedback_accumulator_pattern.
* @feedback_pattern_in_idx: Write index for feedback_accumulator_pattern. * @feedback_pattern_in_idx: Write index for feedback_accumulator_pattern.
* @feedback_synced: Flag indicating if feedback is synced. * @feedback_synced: Flag indicating if feedback is synced.
* @feedback_consecutive_errors: Counter for consecutive feedback errors. * @feedback_consecutive_errors: Counter for consecutive feedback errors.
* @feedback_urb_skip_count: Number of feedback URBs to skip initially for * @feedback_urb_skip_count: Number of feedback URBs to skip initially for stabilization.
* stabilization. * @feedback_patterns: Pointer to the current feedback patterns based on sample rate.
* @feedback_patterns: Pointer to the current feedback patterns based on sample
* rate.
* @feedback_base_value: Base value for feedback pattern lookup. * @feedback_base_value: Base value for feedback pattern lookup.
* @feedback_max_value: Max value for feedback pattern lookup. * @feedback_max_value: Max value for feedback pattern lookup.
* *
@ -179,82 +172,82 @@ enum tascam_register {
* @midi_out_anchor: USB anchor for MIDI output URBs. * @midi_out_anchor: USB anchor for MIDI output URBs.
*/ */
struct tascam_card { struct tascam_card {
struct usb_device *dev; struct usb_device *dev;
struct usb_interface *iface0; struct usb_interface *iface0;
struct usb_interface *iface1; struct usb_interface *iface1;
struct snd_card *card; struct snd_card *card;
struct snd_pcm *pcm; struct snd_pcm *pcm;
struct snd_rawmidi *rmidi; struct snd_rawmidi *rmidi;
/* Playback stream */ /* Playback stream */
struct snd_pcm_substream *playback_substream; struct snd_pcm_substream *playback_substream;
struct urb *playback_urbs[NUM_PLAYBACK_URBS]; struct urb *playback_urbs[NUM_PLAYBACK_URBS];
size_t playback_urb_alloc_size; size_t playback_urb_alloc_size;
struct urb *feedback_urbs[NUM_FEEDBACK_URBS]; struct urb *feedback_urbs[NUM_FEEDBACK_URBS];
size_t feedback_urb_alloc_size; size_t feedback_urb_alloc_size;
atomic_t playback_active; atomic_t playback_active;
u64 playback_frames_consumed; u64 playback_frames_consumed;
snd_pcm_uframes_t driver_playback_pos; snd_pcm_uframes_t driver_playback_pos;
u64 last_period_pos; u64 last_period_pos;
u8 *playback_routing_buffer; u8 *playback_routing_buffer;
/* Capture stream */ /* Capture stream */
struct snd_pcm_substream *capture_substream; struct snd_pcm_substream *capture_substream;
struct urb *capture_urbs[NUM_CAPTURE_URBS]; struct urb *capture_urbs[NUM_CAPTURE_URBS];
size_t capture_urb_alloc_size; size_t capture_urb_alloc_size;
atomic_t capture_active; atomic_t capture_active;
snd_pcm_uframes_t driver_capture_pos; snd_pcm_uframes_t driver_capture_pos;
u64 capture_frames_processed; u64 capture_frames_processed;
u64 last_capture_period_pos; u64 last_capture_period_pos;
u8 *capture_ring_buffer; u8 *capture_ring_buffer;
size_t capture_ring_buffer_read_ptr; size_t capture_ring_buffer_read_ptr;
size_t capture_ring_buffer_write_ptr; size_t capture_ring_buffer_write_ptr;
u8 *capture_decode_raw_block; u8 *capture_decode_raw_block;
s32 *capture_decode_dst_block; s32 *capture_decode_dst_block;
s32 *capture_routing_buffer; s32 *capture_routing_buffer;
struct work_struct capture_work; struct work_struct capture_work;
struct work_struct stop_work; struct work_struct stop_work;
/* MIDI streams */ /* MIDI streams */
struct snd_rawmidi_substream *midi_in_substream; struct snd_rawmidi_substream *midi_in_substream;
struct snd_rawmidi_substream *midi_out_substream; struct snd_rawmidi_substream *midi_out_substream;
struct urb *midi_in_urbs[NUM_MIDI_IN_URBS]; struct urb *midi_in_urbs[NUM_MIDI_IN_URBS];
atomic_t midi_in_active; atomic_t midi_in_active;
struct kfifo midi_in_fifo; struct kfifo midi_in_fifo;
struct work_struct midi_in_work; struct work_struct midi_in_work;
spinlock_t midi_in_lock; spinlock_t midi_in_lock;
struct urb *midi_out_urbs[NUM_MIDI_OUT_URBS]; struct urb *midi_out_urbs[NUM_MIDI_OUT_URBS];
atomic_t midi_out_active; atomic_t midi_out_active;
struct work_struct midi_out_work; struct work_struct midi_out_work;
unsigned long midi_out_urbs_in_flight; unsigned long midi_out_urbs_in_flight;
spinlock_t midi_out_lock; spinlock_t midi_out_lock;
u8 midi_running_status; u8 midi_running_status;
/* Shared state & Routing Matrix */ /* Shared state & Routing Matrix */
spinlock_t lock; spinlock_t lock;
atomic_t active_urbs; atomic_t active_urbs;
int current_rate; int current_rate;
unsigned int line_out_source; /* 0: Playback 1-2, 1: Playback 3-4 */ unsigned int line_out_source; /* 0: Playback 1-2, 1: Playback 3-4 */
unsigned int digital_out_source; /* 0: Playback 1-2, 1: Playback 3-4 */ unsigned int digital_out_source; /* 0: Playback 1-2, 1: Playback 3-4 */
unsigned int capture_12_source; /* 0: Analog In, 1: Digital In */ unsigned int capture_12_source; /* 0: Analog In, 1: Digital In */
unsigned int capture_34_source; /* 0: Analog In, 1: Digital In */ unsigned int capture_34_source; /* 0: Analog In, 1: Digital In */
unsigned int feedback_accumulator_pattern[FEEDBACK_ACCUMULATOR_SIZE]; unsigned int feedback_accumulator_pattern[FEEDBACK_ACCUMULATOR_SIZE];
unsigned int feedback_pattern_out_idx; unsigned int feedback_pattern_out_idx;
unsigned int feedback_pattern_in_idx; unsigned int feedback_pattern_in_idx;
bool feedback_synced; bool feedback_synced;
unsigned int feedback_consecutive_errors; unsigned int feedback_consecutive_errors;
unsigned int feedback_urb_skip_count; unsigned int feedback_urb_skip_count;
const unsigned int (*feedback_patterns)[8]; const unsigned int (*feedback_patterns)[8];
unsigned int feedback_base_value; unsigned int feedback_base_value;
unsigned int feedback_max_value; unsigned int feedback_max_value;
struct usb_anchor playback_anchor; struct usb_anchor playback_anchor;
struct usb_anchor capture_anchor; struct usb_anchor capture_anchor;
struct usb_anchor feedback_anchor; struct usb_anchor feedback_anchor;
struct usb_anchor midi_in_anchor; struct usb_anchor midi_in_anchor;
struct usb_anchor midi_out_anchor; struct usb_anchor midi_out_anchor;
}; };
/* main */ /* main */
@ -283,9 +276,9 @@ int tascam_alloc_urbs(struct tascam_card *tascam);
* tascam_stop_work_handler() - Work handler to stop all active streams. * tascam_stop_work_handler() - Work handler to stop all active streams.
* @work: Pointer to the work_struct. * @work: Pointer to the work_struct.
* *
* This function is scheduled to stop all active URBs (playback, feedback, * This function is scheduled to stop all active URBs (playback, feedback, capture)
* capture) and reset the active_urbs counter. It is used to gracefully stop * and reset the active_urbs counter. It is used to gracefully stop streams
* streams from a workqueue context. * from a workqueue context.
*/ */
void tascam_stop_work_handler(struct work_struct *work); void tascam_stop_work_handler(struct work_struct *work);
@ -324,8 +317,7 @@ int tascam_create_midi(struct tascam_card *tascam);
/* us144mkii_controls.c */ /* us144mkii_controls.c */
/** /**
* tascam_create_controls() - Creates and adds ALSA mixer controls for the * tascam_create_controls() - Creates and adds ALSA mixer controls for the device.
* device.
* @tascam: The driver instance. * @tascam: The driver instance.
* *
* This function registers custom ALSA controls for managing audio routing * This function registers custom ALSA controls for managing audio routing

345
us144mkii_capture.c
View File

@ -12,14 +12,15 @@
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_open(struct snd_pcm_substream *substream) { static int tascam_capture_open(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
substream->runtime->hw = tascam_pcm_hw; substream->runtime->hw = tascam_pcm_hw;
tascam->capture_substream = substream; tascam->capture_substream = substream;
atomic_set(&tascam->capture_active, 0); atomic_set(&tascam->capture_active, 0);
return 0; return 0;
} }
/** /**
@ -31,12 +32,13 @@ static int tascam_capture_open(struct snd_pcm_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_close(struct snd_pcm_substream *substream) { static int tascam_capture_close(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->capture_substream = NULL; tascam->capture_substream = NULL;
return 0; return 0;
} }
/** /**
@ -47,16 +49,17 @@ static int tascam_capture_close(struct snd_pcm_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_prepare(struct snd_pcm_substream *substream) { static int tascam_capture_prepare(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->driver_capture_pos = 0; tascam->driver_capture_pos = 0;
tascam->capture_frames_processed = 0; tascam->capture_frames_processed = 0;
tascam->last_capture_period_pos = 0; tascam->last_capture_period_pos = 0;
tascam->capture_ring_buffer_read_ptr = 0; tascam->capture_ring_buffer_read_ptr = 0;
tascam->capture_ring_buffer_write_ptr = 0; tascam->capture_ring_buffer_write_ptr = 0;
return 0; return 0;
} }
/** /**
@ -69,21 +72,21 @@ static int tascam_capture_prepare(struct snd_pcm_substream *substream) {
* Return: The current capture pointer position in frames. * Return: The current capture pointer position in frames.
*/ */
static snd_pcm_uframes_t static snd_pcm_uframes_t
tascam_capture_pointer(struct snd_pcm_substream *substream) { tascam_capture_pointer(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct snd_pcm_runtime *runtime = substream->runtime; struct tascam_card *tascam = snd_pcm_substream_chip(substream);
u64 pos; struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags; u64 pos;
unsigned long flags;
if (!atomic_read(&tascam->capture_active)) if (!atomic_read(&tascam->capture_active))
return 0; return 0;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
pos = tascam->capture_frames_processed; pos = tascam->capture_frames_processed;
spin_unlock_irqrestore(&tascam->lock, flags); spin_unlock_irqrestore(&tascam->lock, flags);
u64 remainder = do_div(pos, runtime->buffer_size); return runtime ? pos % runtime->buffer_size : 0;
return runtime ? remainder : 0;
} }
/** /**
@ -94,14 +97,14 @@ tascam_capture_pointer(struct snd_pcm_substream *substream) {
* trigger, and pointer. * trigger, and pointer.
*/ */
const struct snd_pcm_ops tascam_capture_ops = { const struct snd_pcm_ops tascam_capture_ops = {
.open = tascam_capture_open, .open = tascam_capture_open,
.close = tascam_capture_close, .close = tascam_capture_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
.hw_params = tascam_pcm_hw_params, .hw_params = tascam_pcm_hw_params,
.hw_free = tascam_pcm_hw_free, .hw_free = tascam_pcm_hw_free,
.prepare = tascam_capture_prepare, .prepare = tascam_capture_prepare,
.trigger = tascam_pcm_trigger, .trigger = tascam_pcm_trigger,
.pointer = tascam_capture_pointer, .pointer = tascam_capture_pointer,
}; };
/** /**
@ -113,39 +116,40 @@ const struct snd_pcm_ops tascam_capture_ops = {
* demultiplexes the bits from the raw block into 8 frames of 4-channel, * demultiplexes the bits from the raw block into 8 frames of 4-channel,
* 24-bit audio (stored in 32-bit containers). * 24-bit audio (stored in 32-bit containers).
*/ */
static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block) { static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block)
int frame, bit; {
int frame, bit;
memset(dst_block, 0, memset(dst_block, 0,
FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME * FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
DECODED_SAMPLE_SIZE); DECODED_SAMPLE_SIZE);
for (frame = 0; frame < FRAMES_PER_DECODE_BLOCK; ++frame) { for (frame = 0; frame < FRAMES_PER_DECODE_BLOCK; ++frame) {
const u8 *p_src_frame_base = src_block + frame * 64; const u8 *p_src_frame_base = src_block + frame * 64;
s32 *p_dst_frame = dst_block + frame * 4; s32 *p_dst_frame = dst_block + frame * 4;
s32 ch[4] = {0}; s32 ch[4] = { 0 };
for (bit = 0; bit < 24; ++bit) { for (bit = 0; bit < 24; ++bit) {
u8 byte1 = p_src_frame_base[bit]; u8 byte1 = p_src_frame_base[bit];
u8 byte2 = p_src_frame_base[bit + 32]; u8 byte2 = p_src_frame_base[bit + 32];
ch[0] = (ch[0] << 1) | (byte1 & 1); ch[0] = (ch[0] << 1) | (byte1 & 1);
ch[2] = (ch[2] << 1) | ((byte1 >> 1) & 1); ch[2] = (ch[2] << 1) | ((byte1 >> 1) & 1);
ch[1] = (ch[1] << 1) | (byte2 & 1); ch[1] = (ch[1] << 1) | (byte2 & 1);
ch[3] = (ch[3] << 1) | ((byte2 >> 1) & 1); ch[3] = (ch[3] << 1) | ((byte2 >> 1) & 1);
} }
/* /*
* The result is a 24-bit sample. Shift left by 8 to align it to * The result is a 24-bit sample. Shift left by 8 to align it to
* the most significant bits of a 32-bit integer (S32_LE format). * the most significant bits of a 32-bit integer (S32_LE format).
*/ */
p_dst_frame[0] = ch[0] << 8; p_dst_frame[0] = ch[0] << 8;
p_dst_frame[1] = ch[1] << 8; p_dst_frame[1] = ch[1] << 8;
p_dst_frame[2] = ch[2] << 8; p_dst_frame[2] = ch[2] << 8;
p_dst_frame[3] = ch[3] << 8; p_dst_frame[3] = ch[3] << 8;
} }
} }
/** /**
@ -157,79 +161,94 @@ static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block) {
* copies the final audio data into the ALSA capture ring buffer. This offloads * copies the final audio data into the ALSA capture ring buffer. This offloads
* * the CPU-intensive decoding from the time-sensitive URB completion handlers. * * the CPU-intensive decoding from the time-sensitive URB completion handlers.
*/ */
void tascam_capture_work_handler(struct work_struct *work) { void tascam_capture_work_handler(struct work_struct *work)
struct tascam_card *tascam = {
container_of(work, struct tascam_card, capture_work); struct tascam_card *tascam =
struct snd_pcm_substream *substream = tascam->capture_substream; container_of(work, struct tascam_card, capture_work);
struct snd_pcm_runtime *runtime; struct snd_pcm_substream *substream = tascam->capture_substream;
unsigned long flags; struct snd_pcm_runtime *runtime;
u8 *raw_block = tascam->capture_decode_raw_block; unsigned long flags;
s32 *decoded_block = tascam->capture_decode_dst_block; u8 *raw_block = tascam->capture_decode_raw_block;
s32 *routed_block = tascam->capture_routing_buffer; s32 *decoded_block = tascam->capture_decode_dst_block;
s32 *routed_block = tascam->capture_routing_buffer;
if (!substream || !substream->runtime) if (!substream || !substream->runtime)
return; return;
runtime = substream->runtime; runtime = substream->runtime;
if (!raw_block || !decoded_block || !routed_block) { if (!raw_block || !decoded_block || !routed_block) {
dev_err(tascam->card->dev, dev_err(tascam->card->dev,
"Capture decode/routing buffers not allocated!\n"); "Capture decode/routing buffers not allocated!\n");
return; return;
} }
while (atomic_read(&tascam->capture_active)) { while (atomic_read(&tascam->capture_active)) {
size_t write_ptr, read_ptr, available_data; size_t write_ptr, read_ptr, available_data;
bool can_process; bool can_process;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
write_ptr = tascam->capture_ring_buffer_write_ptr; write_ptr = tascam->capture_ring_buffer_write_ptr;
read_ptr = tascam->capture_ring_buffer_read_ptr; read_ptr = tascam->capture_ring_buffer_read_ptr;
available_data = (write_ptr >= read_ptr) available_data = (write_ptr >= read_ptr) ?
? (write_ptr - read_ptr) (write_ptr - read_ptr) :
: (CAPTURE_RING_BUFFER_SIZE - read_ptr + write_ptr); (CAPTURE_RING_BUFFER_SIZE - read_ptr +
can_process = (available_data >= RAW_BYTES_PER_DECODE_BLOCK); write_ptr);
can_process = (available_data >= RAW_BYTES_PER_DECODE_BLOCK);
if (can_process) { if (can_process) {
size_t i; size_t i;
for (i = 0; i < RAW_BYTES_PER_DECODE_BLOCK; i++) for (i = 0; i < RAW_BYTES_PER_DECODE_BLOCK; i++)
raw_block[i] = tascam->capture_ring_buffer[(read_ptr + i) % raw_block[i] =
CAPTURE_RING_BUFFER_SIZE]; tascam->capture_ring_buffer
tascam->capture_ring_buffer_read_ptr = [(read_ptr + i) %
(read_ptr + RAW_BYTES_PER_DECODE_BLOCK) % CAPTURE_RING_BUFFER_SIZE; CAPTURE_RING_BUFFER_SIZE];
} tascam->capture_ring_buffer_read_ptr =
spin_unlock_irqrestore(&tascam->lock, flags); (read_ptr + RAW_BYTES_PER_DECODE_BLOCK) %
CAPTURE_RING_BUFFER_SIZE;
}
spin_unlock_irqrestore(&tascam->lock, flags);
if (!can_process) if (!can_process)
break; break;
decode_tascam_capture_block(raw_block, decoded_block); decode_tascam_capture_block(raw_block, decoded_block);
process_capture_routing_us144mkii(tascam, decoded_block, routed_block); process_capture_routing_us144mkii(tascam, decoded_block,
routed_block);
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
if (atomic_read(&tascam->capture_active)) { if (atomic_read(&tascam->capture_active)) {
int f; int f;
for (f = 0; f < FRAMES_PER_DECODE_BLOCK; ++f) { for (f = 0; f < FRAMES_PER_DECODE_BLOCK; ++f) {
u8 *dst_frame_start = u8 *dst_frame_start =
runtime->dma_area + runtime->dma_area +
frames_to_bytes(runtime, tascam->driver_capture_pos); frames_to_bytes(
s32 *routed_frame_start = routed_block + (f * NUM_CHANNELS); runtime,
int c; tascam->driver_capture_pos);
s32 *routed_frame_start =
routed_block + (f * NUM_CHANNELS);
int c;
for (c = 0; c < NUM_CHANNELS; c++) { for (c = 0; c < NUM_CHANNELS; c++) {
u8 *dst_channel = dst_frame_start + (c * BYTES_PER_SAMPLE); u8 *dst_channel =
s32 *src_channel_s32 = routed_frame_start + c; dst_frame_start +
(c * BYTES_PER_SAMPLE);
s32 *src_channel_s32 =
routed_frame_start + c;
memcpy(dst_channel, ((char *)src_channel_s32) + 1, 3); memcpy(dst_channel,
} ((char *)src_channel_s32) + 1,
3);
}
tascam->driver_capture_pos = tascam->driver_capture_pos =
(tascam->driver_capture_pos + 1) % runtime->buffer_size; (tascam->driver_capture_pos + 1) %
} runtime->buffer_size;
} }
spin_unlock_irqrestore(&tascam->lock, flags); }
} spin_unlock_irqrestore(&tascam->lock, flags);
}
} }
/** /**
@ -240,47 +259,51 @@ void tascam_capture_work_handler(struct work_struct *work) {
* into an intermediate ring buffer and then schedules the workqueue to process * into an intermediate ring buffer and then schedules the workqueue to process
* it. It then resubmits the URB to receive more data. * it. It then resubmits the URB to receive more data.
*/ */
void capture_urb_complete(struct urb *urb) { void capture_urb_complete(struct urb *urb)
struct tascam_card *tascam = urb->context; {
int ret; struct tascam_card *tascam = urb->context;
unsigned long flags; int ret;
unsigned long flags;
if (urb->status) { if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN && urb->status != -ENODEV && urb->status != -ESHUTDOWN && urb->status != -ENODEV &&
urb->status != -EPROTO) urb->status != -EPROTO)
dev_err_ratelimited(tascam->card->dev, "Capture URB failed: %d\n", dev_err_ratelimited(tascam->card->dev,
urb->status); "Capture URB failed: %d\n",
goto out; urb->status);
} goto out;
if (!tascam || !atomic_read(&tascam->capture_active)) }
goto out; if (!tascam || !atomic_read(&tascam->capture_active))
goto out;
if (urb->actual_length > 0) { if (urb->actual_length > 0) {
size_t i; size_t i;
size_t write_ptr; size_t write_ptr;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
write_ptr = tascam->capture_ring_buffer_write_ptr; write_ptr = tascam->capture_ring_buffer_write_ptr;
for (i = 0; i < urb->actual_length; i++) { for (i = 0; i < urb->actual_length; i++) {
tascam->capture_ring_buffer[write_ptr] = ((u8 *)urb->transfer_buffer)[i]; tascam->capture_ring_buffer[write_ptr] =
write_ptr = (write_ptr + 1) % CAPTURE_RING_BUFFER_SIZE; ((u8 *)urb->transfer_buffer)[i];
} write_ptr = (write_ptr + 1) % CAPTURE_RING_BUFFER_SIZE;
tascam->capture_ring_buffer_write_ptr = write_ptr; }
spin_unlock_irqrestore(&tascam->lock, flags); tascam->capture_ring_buffer_write_ptr = write_ptr;
spin_unlock_irqrestore(&tascam->lock, flags);
schedule_work(&tascam->capture_work); schedule_work(&tascam->capture_work);
} }
usb_get_urb(urb); usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->capture_anchor); usb_anchor_urb(urb, &tascam->capture_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC); ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) { if (ret < 0) {
dev_err_ratelimited(tascam->card->dev, dev_err_ratelimited(tascam->card->dev,
"Failed to resubmit capture URB: %d\n", ret); "Failed to resubmit capture URB: %d\n",
usb_unanchor_urb(urb); ret);
usb_put_urb(urb); usb_unanchor_urb(urb);
} usb_put_urb(urb);
}
out: out:
usb_put_urb(urb); usb_put_urb(urb);
} }

390
us144mkii_controls.c
View File

@ -9,8 +9,8 @@
* Used by ALSA kcontrol elements to provide user-friendly names for * Used by ALSA kcontrol elements to provide user-friendly names for
* the playback routing options (e.g., "Playback 1-2", "Playback 3-4"). * the playback routing options (e.g., "Playback 1-2", "Playback 3-4").
*/ */
static const char *const playback_source_texts[] = {"Playback 1-2", static const char *const playback_source_texts[] = { "Playback 1-2",
"Playback 3-4"}; "Playback 3-4" };
/** /**
* @brief Text descriptions for capture input source options. * @brief Text descriptions for capture input source options.
@ -18,31 +18,30 @@ static const char *const playback_source_texts[] = {"Playback 1-2",
* Used by ALSA kcontrol elements to provide user-friendly names for * Used by ALSA kcontrol elements to provide user-friendly names for
* the capture routing options (e.g., "Analog In", "Digital In"). * the capture routing options (e.g., "Analog In", "Digital In").
*/ */
static const char *const capture_source_texts[] = {"Analog In", "Digital In"}; static const char *const capture_source_texts[] = { "Analog In", "Digital In" };
/** /**
* tascam_playback_source_info() - ALSA control info callback for playback * tascam_playback_source_info() - ALSA control info callback for playback source.
* source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @uinfo: The ALSA control element info structure to fill. * @uinfo: The ALSA control element info structure to fill.
* *
* This function provides information about the enumerated playback source * This function provides information about the enumerated playback source
* control, including its type, count, and available items (Playback 1-2, * control, including its type, count, and available items (Playback 1-2, Playback 3-4).
* Playback 3-4).
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, static int tascam_playback_source_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo) { struct snd_ctl_elem_info *uinfo)
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; {
uinfo->count = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->value.enumerated.items = 2; uinfo->count = 1;
if (uinfo->value.enumerated.item >= 2) uinfo->value.enumerated.items = 2;
uinfo->value.enumerated.item = 1; if (uinfo->value.enumerated.item >= 2)
strscpy(uinfo->value.enumerated.name, uinfo->value.enumerated.item = 1;
playback_source_texts[uinfo->value.enumerated.item], strscpy(uinfo->value.enumerated.name,
sizeof(uinfo->value.enumerated.name)); playback_source_texts[uinfo->value.enumerated.item],
return 0; sizeof(uinfo->value.enumerated.name));
return 0;
} }
/** /**
@ -57,11 +56,12 @@ static int tascam_playback_source_info(struct snd_kcontrol *kcontrol,
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_line_out_get(struct snd_kcontrol *kcontrol, static int tascam_line_out_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->line_out_source; ucontrol->value.enumerated.item[0] = tascam->line_out_source;
return 0; return 0;
} }
/** /**
@ -76,15 +76,16 @@ static int tascam_line_out_get(struct snd_kcontrol *kcontrol,
* Return: 1 if the value was changed, 0 if unchanged, or a negative error code. * Return: 1 if the value was changed, 0 if unchanged, or a negative error code.
*/ */
static int tascam_line_out_put(struct snd_kcontrol *kcontrol, static int tascam_line_out_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1) if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL; return -EINVAL;
if (tascam->line_out_source == ucontrol->value.enumerated.item[0]) if (tascam->line_out_source == ucontrol->value.enumerated.item[0])
return 0; return 0;
tascam->line_out_source = ucontrol->value.enumerated.item[0]; tascam->line_out_source = ucontrol->value.enumerated.item[0];
return 1; return 1;
} }
/** /**
@ -93,20 +94,18 @@ static int tascam_line_out_put(struct snd_kcontrol *kcontrol,
* This defines a new ALSA mixer control named "Line OUTPUTS Source" that allows * This defines a new ALSA mixer control named "Line OUTPUTS Source" that allows
* the user to select between "Playback 1-2" and "Playback 3-4" for the analog * the user to select between "Playback 1-2" and "Playback 3-4" for the analog
* line outputs of the device. It uses the `tascam_playback_source_info` for * line outputs of the device. It uses the `tascam_playback_source_info` for
* information and `tascam_line_out_get`/`tascam_line_out_put` for value * information and `tascam_line_out_get`/`tascam_line_out_put` for value handling.
* handling.
*/ */
static const struct snd_kcontrol_new tascam_line_out_control = { static const struct snd_kcontrol_new tascam_line_out_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Line OUTPUTS Source", .name = "Line OUTPUTS Source",
.info = tascam_playback_source_info, .info = tascam_playback_source_info,
.get = tascam_line_out_get, .get = tascam_line_out_get,
.put = tascam_line_out_put, .put = tascam_line_out_put,
}; };
/** /**
* tascam_digital_out_get() - ALSA control get callback for Digital Outputs * tascam_digital_out_get() - ALSA control get callback for Digital Outputs Source.
* Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill. * @ucontrol: The ALSA control element value structure to fill.
* *
@ -117,16 +116,16 @@ static const struct snd_kcontrol_new tascam_line_out_control = {
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, static int tascam_digital_out_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->digital_out_source; ucontrol->value.enumerated.item[0] = tascam->digital_out_source;
return 0; return 0;
} }
/** /**
* tascam_digital_out_put() - ALSA control put callback for Digital Outputs * tascam_digital_out_put() - ALSA control put callback for Digital Outputs Source.
* Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure containing the new value. * @ucontrol: The ALSA control element value structure containing the new value.
* *
@ -137,33 +136,32 @@ static int tascam_digital_out_get(struct snd_kcontrol *kcontrol,
* Return: 1 if the value was changed, 0 if unchanged, or a negative error code. * Return: 1 if the value was changed, 0 if unchanged, or a negative error code.
*/ */
static int tascam_digital_out_put(struct snd_kcontrol *kcontrol, static int tascam_digital_out_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1) if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL; return -EINVAL;
if (tascam->digital_out_source == ucontrol->value.enumerated.item[0]) if (tascam->digital_out_source == ucontrol->value.enumerated.item[0])
return 0; return 0;
tascam->digital_out_source = ucontrol->value.enumerated.item[0]; tascam->digital_out_source = ucontrol->value.enumerated.item[0];
return 1; return 1;
} }
/** /**
* tascam_digital_out_control - ALSA kcontrol definition for Digital Outputs * tascam_digital_out_control - ALSA kcontrol definition for Digital Outputs Source.
* Source.
* *
* This defines a new ALSA mixer control named "Digital OUTPUTS Source" that * This defines a new ALSA mixer control named "Digital OUTPUTS Source" that allows
* allows the user to select between "Playback 1-2" and "Playback 3-4" for the * the user to select between "Playback 1-2" and "Playback 3-4" for the digital
* digital outputs of the device. It uses the `tascam_playback_source_info` for * outputs of the device. It uses the `tascam_playback_source_info` for
* information and `tascam_digital_out_get`/`tascam_digital_out_put` for value * information and `tascam_digital_out_get`/`tascam_digital_out_put` for value handling.
* handling.
*/ */
static const struct snd_kcontrol_new tascam_digital_out_control = { static const struct snd_kcontrol_new tascam_digital_out_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Digital OUTPUTS Source", .name = "Digital OUTPUTS Source",
.info = tascam_playback_source_info, .info = tascam_playback_source_info,
.get = tascam_digital_out_get, .get = tascam_digital_out_get,
.put = tascam_digital_out_put, .put = tascam_digital_out_put,
}; };
/** /**
@ -172,146 +170,142 @@ static const struct snd_kcontrol_new tascam_digital_out_control = {
* @uinfo: The ALSA control element info structure to fill. * @uinfo: The ALSA control element info structure to fill.
* *
* This function provides information about the enumerated capture source * This function provides information about the enumerated capture source
* control, including its type, count, and available items (Analog In, Digital * control, including its type, count, and available items (Analog In, Digital In).
* In).
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, static int tascam_capture_source_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo) { struct snd_ctl_elem_info *uinfo)
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; {
uinfo->count = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->value.enumerated.items = 2; uinfo->count = 1;
if (uinfo->value.enumerated.item >= 2) uinfo->value.enumerated.items = 2;
uinfo->value.enumerated.item = 1; if (uinfo->value.enumerated.item >= 2)
strscpy(uinfo->value.enumerated.name, uinfo->value.enumerated.item = 1;
capture_source_texts[uinfo->value.enumerated.item], strscpy(uinfo->value.enumerated.name,
sizeof(uinfo->value.enumerated.name)); capture_source_texts[uinfo->value.enumerated.item],
return 0; sizeof(uinfo->value.enumerated.name));
return 0;
} }
/** /**
* tascam_capture_12_get() - ALSA control get callback for Capture channels 1 * tascam_capture_12_get() - ALSA control get callback for Capture channels 1 and 2 Source.
* and 2 Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill. * @ucontrol: The ALSA control element value structure to fill.
* *
* This function retrieves the current selection for the Capture channels 1 and * This function retrieves the current selection for the Capture channels 1 and 2 source
* 2 source (Analog In or Digital In) from the driver's private data and * (Analog In or Digital In) from the driver's private data and populates
* populates the ALSA control element value. * the ALSA control element value.
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_12_get(struct snd_kcontrol *kcontrol, static int tascam_capture_12_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->capture_12_source; ucontrol->value.enumerated.item[0] = tascam->capture_12_source;
return 0; return 0;
} }
/** /**
* tascam_capture_12_put() - ALSA control put callback for Capture channels 1 * tascam_capture_12_put() - ALSA control put callback for Capture channels 1 and 2 Source.
* and 2 Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure containing the new value. * @ucontrol: The ALSA control element value structure containing the new value.
* *
* This function sets the Capture channels 1 and 2 source (Analog In or Digital * This function sets the Capture channels 1 and 2 source (Analog In or Digital In)
* In) based on the user's selection from the ALSA control element. It validates * based on the user's selection from the ALSA control element. It validates
* the input and updates the driver's private data. * the input and updates the driver's private data.
* *
* Return: 1 if the value was changed, 0 if unchanged, or a negative error code. * Return: 1 if the value was changed, 0 if unchanged, or a negative error code.
*/ */
static int tascam_capture_12_put(struct snd_kcontrol *kcontrol, static int tascam_capture_12_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1) if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL; return -EINVAL;
if (tascam->capture_12_source == ucontrol->value.enumerated.item[0]) if (tascam->capture_12_source == ucontrol->value.enumerated.item[0])
return 0; return 0;
tascam->capture_12_source = ucontrol->value.enumerated.item[0]; tascam->capture_12_source = ucontrol->value.enumerated.item[0];
return 1; return 1;
} }
/** /**
* tascam_capture_12_control - ALSA kcontrol definition for Capture channels 1 * tascam_capture_12_control - ALSA kcontrol definition for Capture channels 1 and 2 Source.
* and 2 Source.
* *
* This defines a new ALSA mixer control named "ch1 and ch2 Source" that allows * This defines a new ALSA mixer control named "ch1 and ch2 Source" that allows
* the user to select between "Analog In" and "Digital In" for the first two * the user to select between "Analog In" and "Digital In" for the first two
* capture channels of the device. It uses the `tascam_capture_source_info` for * capture channels of the device. It uses the `tascam_capture_source_info` for
* information and `tascam_capture_12_get`/`tascam_capture_12_put` for value * information and `tascam_capture_12_get`/`tascam_capture_12_put` for value handling.
* handling.
*/ */
static const struct snd_kcontrol_new tascam_capture_12_control = { static const struct snd_kcontrol_new tascam_capture_12_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch1 and ch2 Source", .name = "ch1 and ch2 Source",
.info = tascam_capture_source_info, .info = tascam_capture_source_info,
.get = tascam_capture_12_get, .get = tascam_capture_12_get,
.put = tascam_capture_12_put, .put = tascam_capture_12_put,
}; };
/** /**
* tascam_capture_34_get() - ALSA control get callback for Capture channels 3 * tascam_capture_34_get() - ALSA control get callback for Capture channels 3 and 4 Source.
* and 4 Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill. * @ucontrol: The ALSA control element value structure to fill.
* *
* This function retrieves the current selection for the Capture channels 3 and * This function retrieves the current selection for the Capture channels 3 and 4 source
* 4 source (Analog In or Digital In) from the driver's private data and * (Analog In or Digital In) from the driver's private data and populates
* populates the ALSA control element value. * the ALSA control element value.
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_capture_34_get(struct snd_kcontrol *kcontrol, static int tascam_capture_34_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->capture_34_source; ucontrol->value.enumerated.item[0] = tascam->capture_34_source;
return 0; return 0;
} }
/** /**
* tascam_capture_34_put() - ALSA control put callback for Capture channels 3 * tascam_capture_34_put() - ALSA control put callback for Capture channels 3 and 4 Source.
* and 4 Source.
* @kcontrol: The ALSA kcontrol instance. * @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure containing the new value. * @ucontrol: The ALSA control element value structure containing the new value.
* *
* This function sets the Capture channels 3 and 4 source (Analog In or Digital * This function sets the Capture channels 3 and 4 source (Analog In or Digital In)
* In) based on the user's selection from the ALSA control element. It validates * based on the user's selection from the ALSA control element. It validates
* the input and updates the driver's private data. * the input and updates the driver's private data.
* *
* Return: 1 if the value was changed, 0 if unchanged, or a negative error code. * Return: 1 if the value was changed, 0 if unchanged, or a negative error code.
*/ */
static int tascam_capture_34_put(struct snd_kcontrol *kcontrol, static int tascam_capture_34_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol); {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1) if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL; return -EINVAL;
if (tascam->capture_34_source == ucontrol->value.enumerated.item[0]) if (tascam->capture_34_source == ucontrol->value.enumerated.item[0])
return 0; return 0;
tascam->capture_34_source = ucontrol->value.enumerated.item[0]; tascam->capture_34_source = ucontrol->value.enumerated.item[0];
return 1; return 1;
} }
/** /**
* tascam_capture_34_control - ALSA kcontrol definition for Capture channels 3 * tascam_capture_34_control - ALSA kcontrol definition for Capture channels 3 and 4 Source.
* and 4 Source.
* *
* This defines a new ALSA mixer control named "ch3 and ch4 Source" that allows * This defines a new ALSA mixer control named "ch3 and ch4 Source" that allows
* the user to select between "Analog In" and "Digital In" for the third and * the user to select between "Analog In" and "Digital In" for the third and fourth
* fourth capture channels of the device. It uses the * capture channels of the device. It uses the `tascam_capture_source_info` for
* `tascam_capture_source_info` for information and * information and `tascam_capture_34_get`/`tascam_capture_34_put` for value handling.
* `tascam_capture_34_get`/`tascam_capture_34_put` for value handling.
*/ */
static const struct snd_kcontrol_new tascam_capture_34_control = { static const struct snd_kcontrol_new tascam_capture_34_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch3 and ch4 Source", .name = "ch3 and ch4 Source",
.info = tascam_capture_source_info, .info = tascam_capture_source_info,
.get = tascam_capture_34_get, .get = tascam_capture_34_get,
.put = tascam_capture_34_put, .put = tascam_capture_34_put,
}; };
/** /**
@ -325,12 +319,13 @@ static const struct snd_kcontrol_new tascam_capture_34_control = {
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_samplerate_info(struct snd_kcontrol *kcontrol, static int tascam_samplerate_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo) { struct snd_ctl_elem_info *uinfo)
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; {
uinfo->count = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->value.integer.min = 0; uinfo->count = 1;
uinfo->value.integer.max = 96000; uinfo->value.integer.min = 0;
return 0; uinfo->value.integer.max = 96000;
return 0;
} }
/** /**
@ -340,38 +335,39 @@ static int tascam_samplerate_info(struct snd_kcontrol *kcontrol,
* *
* This function retrieves the current sample rate from the device via a USB * This function retrieves the current sample rate from the device via a USB
* control message and populates the ALSA control element value. If the rate * control message and populates the ALSA control element value. If the rate
* is already known (i.e., `current_rate` is set), it returns that value * is already known (i.e., `current_rate` is set), it returns that value directly.
* directly.
* *
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, static int tascam_samplerate_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) { struct snd_ctl_elem_value *ucontrol)
struct tascam_card *tascam = {
(struct tascam_card *)snd_kcontrol_chip(kcontrol); struct tascam_card *tascam =
u8 *buf; (struct tascam_card *)snd_kcontrol_chip(kcontrol);
int err; u8 *buf;
u32 rate = 0; int err;
u32 rate = 0;
if (tascam->current_rate > 0) { if (tascam->current_rate > 0) {
ucontrol->value.integer.value[0] = tascam->current_rate; ucontrol->value.integer.value[0] = tascam->current_rate;
return 0; return 0;
} }
buf = kmalloc(3, GFP_KERNEL); buf = kmalloc(3, GFP_KERNEL);
if (!buf) if (!buf)
return -ENOMEM; return -ENOMEM;
err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0), err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0),
UAC_GET_CUR, RT_D2H_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL, UAC_GET_CUR, RT_D2H_CLASS_EP,
EP_AUDIO_IN, buf, 3, USB_CTRL_TIMEOUT_MS); UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, buf, 3,
USB_CTRL_TIMEOUT_MS);
if (err >= 3) if (err >= 3)
rate = buf[0] | (buf[1] << 8) | (buf[2] << 16); rate = buf[0] | (buf[1] << 8) | (buf[2] << 16);
ucontrol->value.integer.value[0] = rate; ucontrol->value.integer.value[0] = rate;
kfree(buf); kfree(buf);
return 0; return 0;
} }
/** /**
@ -381,16 +377,15 @@ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol,
* the current sample rate of the device. It is a read-only control. * the current sample rate of the device. It is a read-only control.
*/ */
static const struct snd_kcontrol_new tascam_samplerate_control = { static const struct snd_kcontrol_new tascam_samplerate_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Sample Rate", .name = "Sample Rate",
.info = tascam_samplerate_info, .info = tascam_samplerate_info,
.get = tascam_samplerate_get, .get = tascam_samplerate_get,
.access = SNDRV_CTL_ELEM_ACCESS_READ, .access = SNDRV_CTL_ELEM_ACCESS_READ,
}; };
/** /**
* tascam_create_controls() - Creates and adds ALSA mixer controls for the * tascam_create_controls() - Creates and adds ALSA mixer controls for the device.
* device.
* @tascam: The driver instance. * @tascam: The driver instance.
* *
* This function registers custom ALSA controls for managing audio routing * This function registers custom ALSA controls for managing audio routing
@ -399,30 +394,31 @@ static const struct snd_kcontrol_new tascam_samplerate_control = {
* *
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int tascam_create_controls(struct tascam_card *tascam) { int tascam_create_controls(struct tascam_card *tascam)
int err; {
int err;
err = err = snd_ctl_add(tascam->card,
snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_line_out_control, tascam)); snd_ctl_new1(&tascam_line_out_control, tascam));
if (err < 0) if (err < 0)
return err; return err;
err = snd_ctl_add(tascam->card, err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_digital_out_control, tascam)); snd_ctl_new1(&tascam_digital_out_control, tascam));
if (err < 0) if (err < 0)
return err; return err;
err = snd_ctl_add(tascam->card, err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_12_control, tascam)); snd_ctl_new1(&tascam_capture_12_control, tascam));
if (err < 0) if (err < 0)
return err; return err;
err = snd_ctl_add(tascam->card, err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_34_control, tascam)); snd_ctl_new1(&tascam_capture_34_control, tascam));
if (err < 0) if (err < 0)
return err; return err;
err = snd_ctl_add(tascam->card, err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_samplerate_control, tascam)); snd_ctl_new1(&tascam_samplerate_control, tascam));
if (err < 0) if (err < 0)
return err; return err;
return 0; return 0;
} }

456
us144mkii_midi.c
View File

@ -11,39 +11,42 @@
* the kfifo, processes it by stripping protocol-specific padding bytes, and * the kfifo, processes it by stripping protocol-specific padding bytes, and
* passes the clean MIDI data to the ALSA rawmidi subsystem. * passes the clean MIDI data to the ALSA rawmidi subsystem.
*/ */
static void tascam_midi_in_work_handler(struct work_struct *work) { static void tascam_midi_in_work_handler(struct work_struct *work)
struct tascam_card *tascam = {
container_of(work, struct tascam_card, midi_in_work); struct tascam_card *tascam =
u8 buf[MIDI_IN_BUF_SIZE]; container_of(work, struct tascam_card, midi_in_work);
unsigned int len; u8 buf[MIDI_IN_BUF_SIZE];
int i; unsigned int len;
int i;
if (!tascam->midi_in_substream) if (!tascam->midi_in_substream)
return; return;
while (!kfifo_is_empty(&tascam->midi_in_fifo)) { while (!kfifo_is_empty(&tascam->midi_in_fifo)) {
len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf, sizeof(buf), len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf,
&tascam->midi_in_lock); sizeof(buf), &tascam->midi_in_lock);
if (len == 0) if (len == 0)
continue; continue;
if (!tascam->midi_in_substream) if (!tascam->midi_in_substream)
continue; continue;
for (i = 0; i < len; ++i) { for (i = 0; i < len; ++i) {
/* Skip padding bytes */ /* Skip padding bytes */
if (buf[i] == 0xfd) if (buf[i] == 0xfd)
continue; continue;
/* The last byte is often a terminator (0x00, 0xFF). Ignore it. */ /* The last byte is often a terminator (0x00, 0xFF). Ignore it. */
if (i == (len - 1) && (buf[i] == 0x00 || buf[i] == 0xff)) if (i == (len - 1) &&
continue; (buf[i] == 0x00 || buf[i] == 0xff))
continue;
/* Submit valid MIDI bytes one by one */ /* Submit valid MIDI bytes one by one */
snd_rawmidi_receive(tascam->midi_in_substream, &buf[i], 1); snd_rawmidi_receive(tascam->midi_in_substream, &buf[i],
} 1);
} }
}
} }
/** /**
@ -54,36 +57,38 @@ static void tascam_midi_in_work_handler(struct work_struct *work) {
* USB endpoint into a kfifo and schedules a work item to process it later, * USB endpoint into a kfifo and schedules a work item to process it later,
* ensuring the interrupt handler remains fast. * ensuring the interrupt handler remains fast.
*/ */
void tascam_midi_in_urb_complete(struct urb *urb) { void tascam_midi_in_urb_complete(struct urb *urb)
struct tascam_card *tascam = urb->context; {
int ret; struct tascam_card *tascam = urb->context;
int ret;
if (urb->status) { if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN && urb->status != -EPROTO) urb->status != -ESHUTDOWN && urb->status != -EPROTO)
dev_err_ratelimited(tascam->card->dev, "MIDI IN URB failed: status %d\n", dev_err_ratelimited(tascam->card->dev,
urb->status); "MIDI IN URB failed: status %d\n",
goto out; urb->status);
} goto out;
}
if (tascam && atomic_read(&tascam->midi_in_active) && if (tascam && atomic_read(&tascam->midi_in_active) &&
urb->actual_length > 0) { urb->actual_length > 0) {
kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer, kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer,
urb->actual_length, &tascam->midi_in_lock); urb->actual_length, &tascam->midi_in_lock);
schedule_work(&tascam->midi_in_work); schedule_work(&tascam->midi_in_work);
} }
usb_get_urb(urb); usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_in_anchor); usb_anchor_urb(urb, &tascam->midi_in_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC); ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) { if (ret < 0) {
dev_err(tascam->card->dev, "Failed to resubmit MIDI IN URB: error %d\n", dev_err(tascam->card->dev,
ret); "Failed to resubmit MIDI IN URB: error %d\n", ret);
usb_unanchor_urb(urb); usb_unanchor_urb(urb);
usb_put_urb(urb); usb_put_urb(urb);
} }
out: out:
usb_put_urb(urb); usb_put_urb(urb);
} }
/** /**
@ -95,11 +100,12 @@ out:
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_midi_in_open(struct snd_rawmidi_substream *substream) { static int tascam_midi_in_open(struct snd_rawmidi_substream *substream)
struct tascam_card *tascam = substream->rmidi->private_data; {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_in_substream = substream; tascam->midi_in_substream = substream;
return 0; return 0;
} }
/** /**
@ -108,8 +114,9 @@ static int tascam_midi_in_open(struct snd_rawmidi_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_midi_in_close(struct snd_rawmidi_substream *substream) { static int tascam_midi_in_close(struct snd_rawmidi_substream *substream)
return 0; {
return 0;
} }
/** /**
@ -117,53 +124,58 @@ static int tascam_midi_in_close(struct snd_rawmidi_substream *substream) {
* @substream: The ALSA rawmidi substream. * @substream: The ALSA rawmidi substream.
* @up: Boolean indicating whether to start (1) or stop (0) the stream. * @up: Boolean indicating whether to start (1) or stop (0) the stream.
* *
* This function starts or stops the MIDI input URBs based on the 'up' * This function starts or stops the MIDI input URBs based on the 'up' parameter.
* parameter. When starting, it resets the kfifo and submits all MIDI input * When starting, it resets the kfifo and submits all MIDI input URBs.
* URBs. When stopping, it kills all anchored MIDI input URBs and cancels the * When stopping, it kills all anchored MIDI input URBs and cancels the
* associated workqueue. * associated workqueue.
*/ */
static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream,
int up) { int up)
struct tascam_card *tascam = substream->rmidi->private_data; {
int i, err; struct tascam_card *tascam = substream->rmidi->private_data;
unsigned long flags; int i, err;
unsigned long flags;
if (up) { if (up) {
if (atomic_xchg(&tascam->midi_in_active, 1) == 0) { if (atomic_xchg(&tascam->midi_in_active, 1) == 0) {
spin_lock_irqsave(&tascam->midi_in_lock, flags); spin_lock_irqsave(&tascam->midi_in_lock, flags);
kfifo_reset(&tascam->midi_in_fifo); kfifo_reset(&tascam->midi_in_fifo);
spin_unlock_irqrestore(&tascam->midi_in_lock, flags); spin_unlock_irqrestore(&tascam->midi_in_lock, flags);
for (i = 0; i < NUM_MIDI_IN_URBS; i++) { for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
usb_get_urb(tascam->midi_in_urbs[i]); usb_get_urb(tascam->midi_in_urbs[i]);
usb_anchor_urb(tascam->midi_in_urbs[i], &tascam->midi_in_anchor); usb_anchor_urb(tascam->midi_in_urbs[i],
err = usb_submit_urb(tascam->midi_in_urbs[i], GFP_KERNEL); &tascam->midi_in_anchor);
if (err < 0) { err = usb_submit_urb(tascam->midi_in_urbs[i],
dev_err(tascam->card->dev, "Failed to submit MIDI IN URB %d: %d\n", i, GFP_KERNEL);
err); if (err < 0) {
usb_unanchor_urb(tascam->midi_in_urbs[i]); dev_err(tascam->card->dev,
usb_put_urb(tascam->midi_in_urbs[i]); "Failed to submit MIDI IN URB %d: %d\n",
} i, err);
} usb_unanchor_urb(
} tascam->midi_in_urbs[i]);
} else { usb_put_urb(tascam->midi_in_urbs[i]);
if (atomic_xchg(&tascam->midi_in_active, 0) == 1) { }
usb_kill_anchored_urbs(&tascam->midi_in_anchor); }
cancel_work_sync(&tascam->midi_in_work); }
} } else {
} if (atomic_xchg(&tascam->midi_in_active, 0) == 1) {
usb_kill_anchored_urbs(&tascam->midi_in_anchor);
cancel_work_sync(&tascam->midi_in_work);
}
}
} }
/** /**
* tascam_midi_in_ops - ALSA rawmidi operations for MIDI input. * tascam_midi_in_ops - ALSA rawmidi operations for MIDI input.
* *
* This structure defines the callback functions for MIDI input stream * This structure defines the callback functions for MIDI input stream operations,
* operations, including open, close, and trigger. * including open, close, and trigger.
*/ */
static const struct snd_rawmidi_ops tascam_midi_in_ops = { static const struct snd_rawmidi_ops tascam_midi_in_ops = {
.open = tascam_midi_in_open, .open = tascam_midi_in_open,
.close = tascam_midi_in_close, .close = tascam_midi_in_close,
.trigger = tascam_midi_in_trigger, .trigger = tascam_midi_in_trigger,
}; };
/** /**
@ -175,41 +187,44 @@ static const struct snd_rawmidi_ops tascam_midi_in_ops = {
* send any more data waiting in the ALSA buffer. This is a safe, non-blocking * send any more data waiting in the ALSA buffer. This is a safe, non-blocking
* way to continue the data transmission chain. * way to continue the data transmission chain.
*/ */
void tascam_midi_out_urb_complete(struct urb *urb) { void tascam_midi_out_urb_complete(struct urb *urb)
struct tascam_card *tascam = urb->context; {
unsigned long flags; struct tascam_card *tascam = urb->context;
int i, urb_index = -1; unsigned long flags;
int i, urb_index = -1;
if (urb->status) { if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN) urb->status != -ESHUTDOWN)
dev_err_ratelimited(tascam->card->dev, "MIDI OUT URB failed: %d\n", dev_err_ratelimited(tascam->card->dev,
urb->status); "MIDI OUT URB failed: %d\n",
} urb->status);
}
if (!tascam) if (!tascam)
goto out; goto out;
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) { for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (tascam->midi_out_urbs[i] == urb) { if (tascam->midi_out_urbs[i] == urb) {
urb_index = i; urb_index = i;
break; break;
} }
} }
if (urb_index < 0) { if (urb_index < 0) {
dev_err_ratelimited(tascam->card->dev, "Unknown MIDI OUT URB completed!\n"); dev_err_ratelimited(tascam->card->dev,
goto out; "Unknown MIDI OUT URB completed!\n");
} goto out;
}
spin_lock_irqsave(&tascam->midi_out_lock, flags); spin_lock_irqsave(&tascam->midi_out_lock, flags);
clear_bit(urb_index, &tascam->midi_out_urbs_in_flight); clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
spin_unlock_irqrestore(&tascam->midi_out_lock, flags); spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
if (atomic_read(&tascam->midi_out_active)) if (atomic_read(&tascam->midi_out_active))
schedule_work(&tascam->midi_out_work); schedule_work(&tascam->midi_out_work);
out: out:
usb_put_urb(urb); usb_put_urb(urb);
} }
/** /**
@ -222,67 +237,70 @@ out:
* This function pulls as many bytes as will fit into one packet from the * This function pulls as many bytes as will fit into one packet from the
* ALSA buffer and sends them. * ALSA buffer and sends them.
*/ */
static void tascam_midi_out_work_handler(struct work_struct *work) { static void tascam_midi_out_work_handler(struct work_struct *work)
struct tascam_card *tascam = {
container_of(work, struct tascam_card, midi_out_work); struct tascam_card *tascam =
struct snd_rawmidi_substream *substream = tascam->midi_out_substream; container_of(work, struct tascam_card, midi_out_work);
int i; struct snd_rawmidi_substream *substream = tascam->midi_out_substream;
int i;
if (!substream || !atomic_read(&tascam->midi_out_active)) if (!substream || !atomic_read(&tascam->midi_out_active))
return; return;
while (snd_rawmidi_transmit_peek(substream, (u8[]){0}, 1) == 1) { while (snd_rawmidi_transmit_peek(substream, (u8[]){ 0 }, 1) == 1) {
unsigned long flags; unsigned long flags;
int urb_index; int urb_index;
struct urb *urb; struct urb *urb;
u8 *buf; u8 *buf;
int bytes_to_send; int bytes_to_send;
spin_lock_irqsave(&tascam->midi_out_lock, flags); spin_lock_irqsave(&tascam->midi_out_lock, flags);
urb_index = -1; urb_index = -1;
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) { for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (!test_bit(i, &tascam->midi_out_urbs_in_flight)) { if (!test_bit(i, &tascam->midi_out_urbs_in_flight)) {
urb_index = i; urb_index = i;
break; break;
} }
} }
if (urb_index < 0) { if (urb_index < 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags); spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
return; /* No free URBs, will be rescheduled by completion handler */ return; /* No free URBs, will be rescheduled by completion handler */
} }
urb = tascam->midi_out_urbs[urb_index]; urb = tascam->midi_out_urbs[urb_index];
buf = urb->transfer_buffer; buf = urb->transfer_buffer;
bytes_to_send = snd_rawmidi_transmit(substream, buf, 8); bytes_to_send = snd_rawmidi_transmit(substream, buf, 8);
if (bytes_to_send <= 0) { if (bytes_to_send <= 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags); spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
break; /* No more data */ break; /* No more data */
} }
if (bytes_to_send < 9) if (bytes_to_send < 9)
memset(buf + bytes_to_send, 0xfd, 9 - bytes_to_send); memset(buf + bytes_to_send, 0xfd, 9 - bytes_to_send);
buf[8] = 0x00; buf[8] = 0x00;
set_bit(urb_index, &tascam->midi_out_urbs_in_flight); set_bit(urb_index, &tascam->midi_out_urbs_in_flight);
urb->transfer_buffer_length = 9; urb->transfer_buffer_length = 9;
spin_unlock_irqrestore(&tascam->midi_out_lock, flags); spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
usb_get_urb(urb); usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_out_anchor); usb_anchor_urb(urb, &tascam->midi_out_anchor);
if (usb_submit_urb(urb, GFP_KERNEL) < 0) { if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
dev_err_ratelimited(tascam->card->dev, dev_err_ratelimited(
"Failed to submit MIDI OUT URB %d\n", urb_index); tascam->card->dev,
spin_lock_irqsave(&tascam->midi_out_lock, flags); "Failed to submit MIDI OUT URB %d\n",
clear_bit(urb_index, &tascam->midi_out_urbs_in_flight); urb_index);
spin_unlock_irqrestore(&tascam->midi_out_lock, flags); spin_lock_irqsave(&tascam->midi_out_lock, flags);
usb_unanchor_urb(urb); clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
usb_put_urb(urb); spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
break; /* Stop on error */ usb_unanchor_urb(urb);
} usb_put_urb(urb);
} break; /* Stop on error */
}
}
} }
/** /**
@ -294,13 +312,14 @@ static void tascam_midi_out_work_handler(struct work_struct *work) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_midi_out_open(struct snd_rawmidi_substream *substream) { static int tascam_midi_out_open(struct snd_rawmidi_substream *substream)
struct tascam_card *tascam = substream->rmidi->private_data; {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_out_substream = substream; tascam->midi_out_substream = substream;
/* Initialize the running status state for the packet packer. */ /* Initialize the running status state for the packet packer. */
tascam->midi_running_status = 0; tascam->midi_running_status = 0;
return 0; return 0;
} }
/** /**
@ -309,8 +328,9 @@ static int tascam_midi_out_open(struct snd_rawmidi_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_midi_out_close(struct snd_rawmidi_substream *substream) { static int tascam_midi_out_close(struct snd_rawmidi_substream *substream)
return 0; {
return 0;
} }
/** /**
@ -320,11 +340,12 @@ static int tascam_midi_out_close(struct snd_rawmidi_substream *substream) {
* This function cancels any pending MIDI output work and kills all * This function cancels any pending MIDI output work and kills all
* anchored MIDI output URBs, ensuring all data is sent or discarded. * anchored MIDI output URBs, ensuring all data is sent or discarded.
*/ */
static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream) { static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream)
struct tascam_card *tascam = substream->rmidi->private_data; {
struct tascam_card *tascam = substream->rmidi->private_data;
cancel_work_sync(&tascam->midi_out_work); cancel_work_sync(&tascam->midi_out_work);
usb_kill_anchored_urbs(&tascam->midi_out_anchor); usb_kill_anchored_urbs(&tascam->midi_out_anchor);
} }
/** /**
@ -336,28 +357,29 @@ static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream) {
* 'up' parameter. * 'up' parameter.
*/ */
static void tascam_midi_out_trigger(struct snd_rawmidi_substream *substream, static void tascam_midi_out_trigger(struct snd_rawmidi_substream *substream,
int up) { int up)
struct tascam_card *tascam = substream->rmidi->private_data; {
struct tascam_card *tascam = substream->rmidi->private_data;
if (up) { if (up) {
atomic_set(&tascam->midi_out_active, 1); atomic_set(&tascam->midi_out_active, 1);
schedule_work(&tascam->midi_out_work); schedule_work(&tascam->midi_out_work);
} else { } else {
atomic_set(&tascam->midi_out_active, 0); atomic_set(&tascam->midi_out_active, 0);
} }
} }
/** /**
* tascam_midi_out_ops - ALSA rawmidi operations for MIDI output. * tascam_midi_out_ops - ALSA rawmidi operations for MIDI output.
* *
* This structure defines the callback functions for MIDI output stream * This structure defines the callback functions for MIDI output stream operations,
* operations, including open, close, trigger, and drain. * including open, close, trigger, and drain.
*/ */
static const struct snd_rawmidi_ops tascam_midi_out_ops = { static const struct snd_rawmidi_ops tascam_midi_out_ops = {
.open = tascam_midi_out_open, .open = tascam_midi_out_open,
.close = tascam_midi_out_close, .close = tascam_midi_out_close,
.trigger = tascam_midi_out_trigger, .trigger = tascam_midi_out_trigger,
.drain = tascam_midi_out_drain, .drain = tascam_midi_out_drain,
}; };
/** /**
@ -366,28 +388,30 @@ static const struct snd_rawmidi_ops tascam_midi_out_ops = {
* *
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int tascam_create_midi(struct tascam_card *tascam) { int tascam_create_midi(struct tascam_card *tascam)
int err; {
int err;
err = err = snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1,
snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1, &tascam->rmidi); &tascam->rmidi);
if (err < 0) if (err < 0)
return err; return err;
strscpy(tascam->rmidi->name, "US144MKII MIDI", sizeof(tascam->rmidi->name)); strscpy(tascam->rmidi->name, "US144MKII MIDI",
tascam->rmidi->private_data = tascam; sizeof(tascam->rmidi->name));
tascam->rmidi->private_data = tascam;
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_INPUT, snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
&tascam_midi_in_ops); &tascam_midi_in_ops);
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
&tascam_midi_out_ops); &tascam_midi_out_ops);
tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT | tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT |
SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_OUTPUT |
SNDRV_RAWMIDI_INFO_DUPLEX; SNDRV_RAWMIDI_INFO_DUPLEX;
INIT_WORK(&tascam->midi_in_work, tascam_midi_in_work_handler); INIT_WORK(&tascam->midi_in_work, tascam_midi_in_work_handler);
INIT_WORK(&tascam->midi_out_work, tascam_midi_out_work_handler); INIT_WORK(&tascam->midi_out_work, tascam_midi_out_work_handler);
return 0; return 0;
} }

627
us144mkii_pcm.c
View File

@ -15,45 +15,47 @@
* which helps the driver adjust the packet size dynamically to match the * which helps the driver adjust the packet size dynamically to match the
* device's consumption rate. * device's consumption rate.
*/ */
static const unsigned int patterns_48khz[5][8] = {{5, 6, 6, 6, 6, 6, 6, 6}, static const unsigned int patterns_48khz[5][8] = { { 5, 6, 6, 6, 6, 6, 6, 6 },
{6, 6, 6, 6, 6, 6, 6, 6}, { 6, 6, 6, 6, 6, 6, 6, 6 },
{6, 6, 6, 6, 6, 6, 6, 6}, { 6, 6, 6, 6, 6, 6, 6, 6 },
{6, 6, 6, 7, 6, 6, 6, 6}, { 6, 6, 6, 7, 6, 6, 6, 6 },
{7, 6, 6, 7, 6, 6, 7, 6}}; { 7, 6, 6, 7, 6, 6, 7, 6 } };
static const unsigned int patterns_96khz[5][8] = { static const unsigned int patterns_96khz[5][8] = {
{11, 12, 12, 12, 12, 12, 12, 12}, { 11, 12, 12, 12, 12, 12, 12, 12 },
{12, 12, 12, 12, 12, 12, 12, 12}, { 12, 12, 12, 12, 12, 12, 12, 12 },
{12, 12, 12, 12, 12, 12, 12, 12}, { 12, 12, 12, 12, 12, 12, 12, 12 },
{12, 12, 13, 12, 12, 12, 12, 12}, { 12, 12, 13, 12, 12, 12, 12, 12 },
{13, 12, 12, 13, 12, 12, 13, 12}}; { 13, 12, 12, 13, 12, 12, 13, 12 }
};
static const unsigned int patterns_88khz[5][8] = { static const unsigned int patterns_88khz[5][8] = {
{10, 11, 11, 11, 11, 11, 11, 11}, { 10, 11, 11, 11, 11, 11, 11, 11 },
{11, 11, 11, 11, 11, 11, 11, 11}, { 11, 11, 11, 11, 11, 11, 11, 11 },
{11, 11, 11, 11, 11, 11, 11, 11}, { 11, 11, 11, 11, 11, 11, 11, 11 },
{11, 11, 12, 11, 11, 11, 11, 11}, { 11, 11, 12, 11, 11, 11, 11, 11 },
{12, 11, 11, 12, 11, 11, 12, 11}}; { 12, 11, 11, 12, 11, 11, 12, 11 }
static const unsigned int patterns_44khz[5][8] = {{5, 5, 5, 5, 5, 5, 5, 6}, };
{5, 5, 5, 6, 5, 5, 5, 6}, static const unsigned int patterns_44khz[5][8] = { { 5, 5, 5, 5, 5, 5, 5, 6 },
{5, 5, 6, 5, 6, 5, 5, 6}, { 5, 5, 5, 6, 5, 5, 5, 6 },
{5, 6, 5, 6, 5, 6, 5, 6}, { 5, 5, 6, 5, 6, 5, 5, 6 },
{6, 6, 6, 6, 6, 6, 6, 5}}; { 5, 6, 5, 6, 5, 6, 5, 6 },
{ 6, 6, 6, 6, 6, 6, 6, 5 } };
const struct snd_pcm_hardware tascam_pcm_hw = { const struct snd_pcm_hardware tascam_pcm_hw = {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID |
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME), SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
.formats = SNDRV_PCM_FMTBIT_S24_3LE, .formats = SNDRV_PCM_FMTBIT_S24_3LE,
.rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000), SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000),
.rate_min = 44100, .rate_min = 44100,
.rate_max = 96000, .rate_max = 96000,
.channels_min = NUM_CHANNELS, .channels_min = NUM_CHANNELS,
.channels_max = NUM_CHANNELS, .channels_max = NUM_CHANNELS,
.buffer_bytes_max = 1024 * 1024, .buffer_bytes_max = 1024 * 1024,
.period_bytes_min = 48 * BYTES_PER_FRAME, .period_bytes_min = 48 * BYTES_PER_FRAME,
.period_bytes_max = 1024 * BYTES_PER_FRAME, .period_bytes_max = 1024 * BYTES_PER_FRAME,
.periods_min = 2, .periods_min = 2,
.periods_max = 1024, .periods_max = 1024,
}; };
/** /**
@ -64,30 +66,31 @@ const struct snd_pcm_hardware tascam_pcm_hw = {
* @frames: Number of frames to process. * @frames: Number of frames to process.
*/ */
void process_playback_routing_us144mkii(struct tascam_card *tascam, void process_playback_routing_us144mkii(struct tascam_card *tascam,
const u8 *src_buffer, u8 *dst_buffer, const u8 *src_buffer, u8 *dst_buffer,
size_t frames) { size_t frames)
size_t f; {
const u8 *src_12, *src_34; size_t f;
u8 *dst_line, *dst_digital; const u8 *src_12, *src_34;
u8 *dst_line, *dst_digital;
for (f = 0; f < frames; ++f) { for (f = 0; f < frames; ++f) {
src_12 = src_buffer + f * BYTES_PER_FRAME; src_12 = src_buffer + f * BYTES_PER_FRAME;
src_34 = src_12 + (2 * BYTES_PER_SAMPLE); src_34 = src_12 + (2 * BYTES_PER_SAMPLE);
dst_line = dst_buffer + f * BYTES_PER_FRAME; dst_line = dst_buffer + f * BYTES_PER_FRAME;
dst_digital = dst_line + (2 * BYTES_PER_SAMPLE); dst_digital = dst_line + (2 * BYTES_PER_SAMPLE);
/* LINE OUTPUTS (ch1/2 on device) */ /* LINE OUTPUTS (ch1/2 on device) */
if (tascam->line_out_source == 0) /* "ch1 and ch2" */ if (tascam->line_out_source == 0) /* "ch1 and ch2" */
memcpy(dst_line, src_12, 2 * BYTES_PER_SAMPLE); memcpy(dst_line, src_12, 2 * BYTES_PER_SAMPLE);
else /* "ch3 and ch4" */ else /* "ch3 and ch4" */
memcpy(dst_line, src_34, 2 * BYTES_PER_SAMPLE); memcpy(dst_line, src_34, 2 * BYTES_PER_SAMPLE);
/* DIGITAL OUTPUTS (ch3/4 on device) */ /* DIGITAL OUTPUTS (ch3/4 on device) */
if (tascam->digital_out_source == 0) /* "ch1 and ch2" */ if (tascam->digital_out_source == 0) /* "ch1 and ch2" */
memcpy(dst_digital, src_12, 2 * BYTES_PER_SAMPLE); memcpy(dst_digital, src_12, 2 * BYTES_PER_SAMPLE);
else /* "ch3 and ch4" */ else /* "ch3 and ch4" */
memcpy(dst_digital, src_34, 2 * BYTES_PER_SAMPLE); memcpy(dst_digital, src_34, 2 * BYTES_PER_SAMPLE);
} }
} }
/** /**
@ -97,34 +100,35 @@ void process_playback_routing_us144mkii(struct tascam_card *tascam,
* @routed_block: Buffer to be filled for ALSA. * @routed_block: Buffer to be filled for ALSA.
*/ */
void process_capture_routing_us144mkii(struct tascam_card *tascam, void process_capture_routing_us144mkii(struct tascam_card *tascam,
const s32 *decoded_block, const s32 *decoded_block,
s32 *routed_block) { s32 *routed_block)
int f; {
const s32 *src_frame; int f;
s32 *dst_frame; const s32 *src_frame;
s32 *dst_frame;
for (f = 0; f < FRAMES_PER_DECODE_BLOCK; f++) { for (f = 0; f < FRAMES_PER_DECODE_BLOCK; f++) {
src_frame = decoded_block + (f * DECODED_CHANNELS_PER_FRAME); src_frame = decoded_block + (f * DECODED_CHANNELS_PER_FRAME);
dst_frame = routed_block + (f * DECODED_CHANNELS_PER_FRAME); dst_frame = routed_block + (f * DECODED_CHANNELS_PER_FRAME);
/* ch1 and ch2 Source */ /* ch1 and ch2 Source */
if (tascam->capture_12_source == 0) { /* analog inputs */ if (tascam->capture_12_source == 0) { /* analog inputs */
dst_frame[0] = src_frame[0]; /* Analog L */ dst_frame[0] = src_frame[0]; /* Analog L */
dst_frame[1] = src_frame[1]; /* Analog R */ dst_frame[1] = src_frame[1]; /* Analog R */
} else { /* digital inputs */ } else { /* digital inputs */
dst_frame[0] = src_frame[2]; /* Digital L */ dst_frame[0] = src_frame[2]; /* Digital L */
dst_frame[1] = src_frame[3]; /* Digital R */ dst_frame[1] = src_frame[3]; /* Digital R */
} }
/* ch3 and ch4 Source */ /* ch3 and ch4 Source */
if (tascam->capture_34_source == 0) { /* analog inputs */ if (tascam->capture_34_source == 0) { /* analog inputs */
dst_frame[2] = src_frame[0]; /* Analog L (Duplicate) */ dst_frame[2] = src_frame[0]; /* Analog L (Duplicate) */
dst_frame[3] = src_frame[1]; /* Analog R (Duplicate) */ dst_frame[3] = src_frame[1]; /* Analog R (Duplicate) */
} else { /* digital inputs */ } else { /* digital inputs */
dst_frame[2] = src_frame[2]; /* Digital L */ dst_frame[2] = src_frame[2]; /* Digital L */
dst_frame[3] = src_frame[3]; /* Digital R */ dst_frame[3] = src_frame[3]; /* Digital R */
} }
} }
} }
/** /**
@ -137,100 +141,112 @@ void process_capture_routing_us144mkii(struct tascam_card *tascam,
* *
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate) { int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate)
struct usb_device *dev = tascam->dev; {
u8 *rate_payload_buf; struct usb_device *dev = tascam->dev;
u16 rate_vendor_wValue; u8 *rate_payload_buf;
int err = 0; u16 rate_vendor_wValue;
const u8 *current_payload_src; int err = 0;
const u8 *current_payload_src;
static const u8 payload_44100[] = {0x44, 0xac, 0x00}; static const u8 payload_44100[] = { 0x44, 0xac, 0x00 };
static const u8 payload_48000[] = {0x80, 0xbb, 0x00}; static const u8 payload_48000[] = { 0x80, 0xbb, 0x00 };
static const u8 payload_88200[] = {0x88, 0x58, 0x01}; static const u8 payload_88200[] = { 0x88, 0x58, 0x01 };
static const u8 payload_96000[] = {0x00, 0x77, 0x01}; static const u8 payload_96000[] = { 0x00, 0x77, 0x01 };
switch (rate) { switch (rate) {
case 44100: case 44100:
current_payload_src = payload_44100; current_payload_src = payload_44100;
rate_vendor_wValue = REG_ADDR_RATE_44100; rate_vendor_wValue = REG_ADDR_RATE_44100;
break; break;
case 48000: case 48000:
current_payload_src = payload_48000; current_payload_src = payload_48000;
rate_vendor_wValue = REG_ADDR_RATE_48000; rate_vendor_wValue = REG_ADDR_RATE_48000;
break; break;
case 88200: case 88200:
current_payload_src = payload_88200; current_payload_src = payload_88200;
rate_vendor_wValue = REG_ADDR_RATE_88200; rate_vendor_wValue = REG_ADDR_RATE_88200;
break; break;
case 96000: case 96000:
current_payload_src = payload_96000; current_payload_src = payload_96000;
rate_vendor_wValue = REG_ADDR_RATE_96000; rate_vendor_wValue = REG_ADDR_RATE_96000;
break; break;
default: default:
dev_err(&dev->dev, "Unsupported sample rate %d for configuration\n", rate); dev_err(&dev->dev,
return -EINVAL; "Unsupported sample rate %d for configuration\n", rate);
} return -EINVAL;
}
rate_payload_buf = kmemdup(current_payload_src, 3, GFP_KERNEL); rate_payload_buf = kmemdup(current_payload_src, 3, GFP_KERNEL);
if (!rate_payload_buf) if (!rate_payload_buf)
return -ENOMEM; return -ENOMEM;
dev_info(&dev->dev, "Configuring device for %d Hz\n", rate); dev_info(&dev->dev, "Configuring device for %d Hz\n", rate);
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_MODE_CONTROL, err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
RT_H2D_VENDOR_DEV, MODE_VAL_CONFIG, 0x0000, NULL, 0, VENDOR_REQ_MODE_CONTROL, RT_H2D_VENDOR_DEV,
USB_CTRL_TIMEOUT_MS); MODE_VAL_CONFIG, 0x0000, NULL, 0,
if (err < 0) USB_CTRL_TIMEOUT_MS);
goto fail; if (err < 0)
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, goto fail;
RT_H2D_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
rate_payload_buf, 3, USB_CTRL_TIMEOUT_MS); RT_H2D_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL,
if (err < 0) EP_AUDIO_IN, rate_payload_buf, 3,
goto fail; USB_CTRL_TIMEOUT_MS);
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, if (err < 0)
RT_H2D_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL, goto fail;
EP_AUDIO_OUT, rate_payload_buf, 3, USB_CTRL_TIMEOUT_MS); err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
if (err < 0) RT_H2D_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL,
goto fail; EP_AUDIO_OUT, rate_payload_buf, 3,
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_REGISTER_WRITE, USB_CTRL_TIMEOUT_MS);
RT_H2D_VENDOR_DEV, REG_ADDR_UNKNOWN_0D, REG_VAL_ENABLE, if (err < 0)
NULL, 0, USB_CTRL_TIMEOUT_MS); goto fail;
if (err < 0) err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
goto fail; VENDOR_REQ_REGISTER_WRITE, RT_H2D_VENDOR_DEV,
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_REGISTER_WRITE, REG_ADDR_UNKNOWN_0D, REG_VAL_ENABLE, NULL, 0,
RT_H2D_VENDOR_DEV, REG_ADDR_UNKNOWN_0E, REG_VAL_ENABLE, USB_CTRL_TIMEOUT_MS);
NULL, 0, USB_CTRL_TIMEOUT_MS); if (err < 0)
if (err < 0) goto fail;
goto fail; err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_REGISTER_WRITE, VENDOR_REQ_REGISTER_WRITE, RT_H2D_VENDOR_DEV,
RT_H2D_VENDOR_DEV, REG_ADDR_UNKNOWN_0F, REG_VAL_ENABLE, REG_ADDR_UNKNOWN_0E, REG_VAL_ENABLE, NULL, 0,
NULL, 0, USB_CTRL_TIMEOUT_MS); USB_CTRL_TIMEOUT_MS);
if (err < 0) if (err < 0)
goto fail; goto fail;
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_REGISTER_WRITE, err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
RT_H2D_VENDOR_DEV, rate_vendor_wValue, REG_VAL_ENABLE, VENDOR_REQ_REGISTER_WRITE, RT_H2D_VENDOR_DEV,
NULL, 0, USB_CTRL_TIMEOUT_MS); REG_ADDR_UNKNOWN_0F, REG_VAL_ENABLE, NULL, 0,
if (err < 0) USB_CTRL_TIMEOUT_MS);
goto fail; if (err < 0)
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_REGISTER_WRITE, goto fail;
RT_H2D_VENDOR_DEV, REG_ADDR_UNKNOWN_11, REG_VAL_ENABLE, err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
NULL, 0, USB_CTRL_TIMEOUT_MS); VENDOR_REQ_REGISTER_WRITE, RT_H2D_VENDOR_DEV,
if (err < 0) rate_vendor_wValue, REG_VAL_ENABLE, NULL, 0,
goto fail; USB_CTRL_TIMEOUT_MS);
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), VENDOR_REQ_MODE_CONTROL, if (err < 0)
RT_H2D_VENDOR_DEV, MODE_VAL_STREAM_START, 0x0000, NULL, goto fail;
0, USB_CTRL_TIMEOUT_MS); err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
if (err < 0) VENDOR_REQ_REGISTER_WRITE, RT_H2D_VENDOR_DEV,
goto fail; REG_ADDR_UNKNOWN_11, REG_VAL_ENABLE, NULL, 0,
USB_CTRL_TIMEOUT_MS);
if (err < 0)
goto fail;
err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
VENDOR_REQ_MODE_CONTROL, RT_H2D_VENDOR_DEV,
MODE_VAL_STREAM_START, 0x0000, NULL, 0,
USB_CTRL_TIMEOUT_MS);
if (err < 0)
goto fail;
kfree(rate_payload_buf); kfree(rate_payload_buf);
return 0; return 0;
fail: fail:
dev_err(&dev->dev, "Device configuration failed at rate %d with error %d\n", dev_err(&dev->dev,
rate, err); "Device configuration failed at rate %d with error %d\n", rate,
kfree(rate_payload_buf); err);
return err; kfree(rate_payload_buf);
return err;
} }
/** /**
@ -246,52 +262,53 @@ fail:
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int tascam_pcm_hw_params(struct snd_pcm_substream *substream, int tascam_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params) { struct snd_pcm_hw_params *params)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
int err; struct tascam_card *tascam = snd_pcm_substream_chip(substream);
unsigned int rate = params_rate(params); int err;
unsigned int rate = params_rate(params);
err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
if (err < 0) if (err < 0)
return err; return err;
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
switch (rate) { switch (rate) {
case 44100: case 44100:
tascam->feedback_patterns = patterns_44khz; tascam->feedback_patterns = patterns_44khz;
tascam->feedback_base_value = 43; tascam->feedback_base_value = 43;
tascam->feedback_max_value = 45; tascam->feedback_max_value = 45;
break; break;
case 48000: case 48000:
tascam->feedback_patterns = patterns_48khz; tascam->feedback_patterns = patterns_48khz;
tascam->feedback_base_value = 47; tascam->feedback_base_value = 47;
tascam->feedback_max_value = 49; tascam->feedback_max_value = 49;
break; break;
case 88200: case 88200:
tascam->feedback_patterns = patterns_88khz; tascam->feedback_patterns = patterns_88khz;
tascam->feedback_base_value = 87; tascam->feedback_base_value = 87;
tascam->feedback_max_value = 89; tascam->feedback_max_value = 89;
break; break;
case 96000: case 96000:
tascam->feedback_patterns = patterns_96khz; tascam->feedback_patterns = patterns_96khz;
tascam->feedback_base_value = 95; tascam->feedback_base_value = 95;
tascam->feedback_max_value = 97; tascam->feedback_max_value = 97;
break; break;
default: default:
return -EINVAL; return -EINVAL;
} }
} }
if (tascam->current_rate != rate) { if (tascam->current_rate != rate) {
err = us144mkii_configure_device_for_rate(tascam, rate); err = us144mkii_configure_device_for_rate(tascam, rate);
if (err < 0) { if (err < 0) {
tascam->current_rate = 0; tascam->current_rate = 0;
return err; return err;
} }
tascam->current_rate = rate; tascam->current_rate = rate;
} }
return 0; return 0;
} }
/** /**
@ -302,15 +319,15 @@ int tascam_pcm_hw_params(struct snd_pcm_substream *substream,
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
int tascam_pcm_hw_free(struct snd_pcm_substream *substream) { int tascam_pcm_hw_free(struct snd_pcm_substream *substream)
return snd_pcm_lib_free_pages(substream); {
return snd_pcm_lib_free_pages(substream);
} }
/** /**
* tascam_pcm_trigger() - Triggers the start or stop of PCM streams. * tascam_pcm_trigger() - Triggers the start or stop of PCM streams.
* @substream: The ALSA PCM substream. * @substream: The ALSA PCM substream.
* @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START, * @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START, SNDRV_PCM_TRIGGER_STOP).
* SNDRV_PCM_TRIGGER_STOP).
* *
* This function handles starting and stopping of playback and capture streams * This function handles starting and stopping of playback and capture streams
* by submitting or killing the associated URBs. It ensures that both streams * by submitting or killing the associated URBs. It ensures that both streams
@ -318,90 +335,98 @@ int tascam_pcm_hw_free(struct snd_pcm_substream *substream) {
* *
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int tascam_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { int tascam_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
unsigned long flags; struct tascam_card *tascam = snd_pcm_substream_chip(substream);
int err = 0; unsigned long flags;
int i; int err = 0;
bool do_start = false; int i;
bool do_stop = false; bool do_start = false;
bool do_stop = false;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_RESUME:
if (!atomic_read(&tascam->playback_active)) { if (!atomic_read(&tascam->playback_active)) {
atomic_set(&tascam->playback_active, 1); atomic_set(&tascam->playback_active, 1);
atomic_set(&tascam->capture_active, 1); atomic_set(&tascam->capture_active, 1);
do_start = true; do_start = true;
} }
break; break;
case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
if (atomic_read(&tascam->playback_active)) { if (atomic_read(&tascam->playback_active)) {
atomic_set(&tascam->playback_active, 0); atomic_set(&tascam->playback_active, 0);
atomic_set(&tascam->capture_active, 0); atomic_set(&tascam->capture_active, 0);
do_stop = true; do_stop = true;
} }
break; break;
default: default:
err = -EINVAL; err = -EINVAL;
break; break;
} }
spin_unlock_irqrestore(&tascam->lock, flags); spin_unlock_irqrestore(&tascam->lock, flags);
if (do_start) { if (do_start) {
if (atomic_read(&tascam->active_urbs) > 0) { if (atomic_read(&tascam->active_urbs) > 0) {
dev_WARN(tascam->card->dev, "Cannot start, URBs still active.\n"); dev_WARN(tascam->card->dev,
return -EAGAIN; "Cannot start, URBs still active.\n");
} return -EAGAIN;
}
for (i = 0; i < NUM_FEEDBACK_URBS; i++) { for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
usb_get_urb(tascam->feedback_urbs[i]); usb_get_urb(tascam->feedback_urbs[i]);
usb_anchor_urb(tascam->feedback_urbs[i], &tascam->feedback_anchor); usb_anchor_urb(tascam->feedback_urbs[i],
err = usb_submit_urb(tascam->feedback_urbs[i], GFP_ATOMIC); &tascam->feedback_anchor);
if (err < 0) { err = usb_submit_urb(tascam->feedback_urbs[i],
usb_unanchor_urb(tascam->feedback_urbs[i]); GFP_ATOMIC);
usb_put_urb(tascam->feedback_urbs[i]); if (err < 0) {
goto start_rollback; usb_unanchor_urb(tascam->feedback_urbs[i]);
} usb_put_urb(tascam->feedback_urbs[i]);
atomic_inc(&tascam->active_urbs); goto start_rollback;
} }
for (i = 0; i < NUM_PLAYBACK_URBS; i++) { atomic_inc(&tascam->active_urbs);
usb_get_urb(tascam->playback_urbs[i]); }
usb_anchor_urb(tascam->playback_urbs[i], &tascam->playback_anchor); for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
err = usb_submit_urb(tascam->playback_urbs[i], GFP_ATOMIC); usb_get_urb(tascam->playback_urbs[i]);
if (err < 0) { usb_anchor_urb(tascam->playback_urbs[i],
usb_unanchor_urb(tascam->playback_urbs[i]); &tascam->playback_anchor);
usb_put_urb(tascam->playback_urbs[i]); err = usb_submit_urb(tascam->playback_urbs[i],
goto start_rollback; GFP_ATOMIC);
} if (err < 0) {
atomic_inc(&tascam->active_urbs); usb_unanchor_urb(tascam->playback_urbs[i]);
} usb_put_urb(tascam->playback_urbs[i]);
for (i = 0; i < NUM_CAPTURE_URBS; i++) { goto start_rollback;
usb_get_urb(tascam->capture_urbs[i]); }
usb_anchor_urb(tascam->capture_urbs[i], &tascam->capture_anchor); atomic_inc(&tascam->active_urbs);
err = usb_submit_urb(tascam->capture_urbs[i], GFP_ATOMIC); }
if (err < 0) { for (i = 0; i < NUM_CAPTURE_URBS; i++) {
usb_unanchor_urb(tascam->capture_urbs[i]); usb_get_urb(tascam->capture_urbs[i]);
usb_put_urb(tascam->capture_urbs[i]); usb_anchor_urb(tascam->capture_urbs[i],
goto start_rollback; &tascam->capture_anchor);
} err = usb_submit_urb(tascam->capture_urbs[i],
atomic_inc(&tascam->active_urbs); GFP_ATOMIC);
} if (err < 0) {
usb_unanchor_urb(tascam->capture_urbs[i]);
usb_put_urb(tascam->capture_urbs[i]);
goto start_rollback;
}
atomic_inc(&tascam->active_urbs);
}
return 0; return 0;
start_rollback: start_rollback:
dev_err(tascam->card->dev, "Failed to submit URBs to start stream: %d\n", dev_err(tascam->card->dev,
err); "Failed to submit URBs to start stream: %d\n", err);
do_stop = true; do_stop = true;
} }
if (do_stop) if (do_stop)
schedule_work(&tascam->stop_work); schedule_work(&tascam->stop_work);
return err; return err;
} }
/** /**
@ -414,16 +439,18 @@ int tascam_pcm_trigger(struct snd_pcm_substream *substream, int cmd) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
int tascam_init_pcm(struct snd_pcm *pcm) { int tascam_init_pcm(struct snd_pcm *pcm)
struct tascam_card *tascam = pcm->private_data; {
struct tascam_card *tascam = pcm->private_data;
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &tascam_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &tascam_playback_ops);
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &tascam_capture_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &tascam_capture_ops);
snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
tascam->dev->dev.parent, 64 * 1024, tascam->dev->dev.parent,
tascam_pcm_hw.buffer_bytes_max); 64 * 1024,
tascam_pcm_hw.buffer_bytes_max);
INIT_WORK(&tascam->capture_work, tascam_capture_work_handler); INIT_WORK(&tascam->capture_work, tascam_capture_work_handler);
return 0; return 0;
} }

13
us144mkii_pcm.h
View File

@ -97,8 +97,8 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate);
* @frames: Number of frames to process. * @frames: Number of frames to process.
*/ */
void process_playback_routing_us144mkii(struct tascam_card *tascam, void process_playback_routing_us144mkii(struct tascam_card *tascam,
const u8 *src_buffer, u8 *dst_buffer, const u8 *src_buffer, u8 *dst_buffer,
size_t frames); size_t frames);
/** /**
* process_capture_routing_us144mkii() - Apply capture routing matrix * process_capture_routing_us144mkii() - Apply capture routing matrix
@ -107,8 +107,8 @@ void process_playback_routing_us144mkii(struct tascam_card *tascam,
* @routed_block: Buffer to be filled for ALSA. * @routed_block: Buffer to be filled for ALSA.
*/ */
void process_capture_routing_us144mkii(struct tascam_card *tascam, void process_capture_routing_us144mkii(struct tascam_card *tascam,
const s32 *decoded_block, const s32 *decoded_block,
s32 *routed_block); s32 *routed_block);
/** /**
* tascam_pcm_hw_params() - Configures hardware parameters for PCM streams. * tascam_pcm_hw_params() - Configures hardware parameters for PCM streams.
@ -123,7 +123,7 @@ void process_capture_routing_us144mkii(struct tascam_card *tascam,
* Return: 0 on success, or a negative error code on failure. * Return: 0 on success, or a negative error code on failure.
*/ */
int tascam_pcm_hw_params(struct snd_pcm_substream *substream, int tascam_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params); struct snd_pcm_hw_params *params);
/** /**
* tascam_pcm_hw_free() - Frees hardware parameters for PCM streams. * tascam_pcm_hw_free() - Frees hardware parameters for PCM streams.
@ -138,8 +138,7 @@ int tascam_pcm_hw_free(struct snd_pcm_substream *substream);
/** /**
* tascam_pcm_trigger() - Triggers the start or stop of PCM streams. * tascam_pcm_trigger() - Triggers the start or stop of PCM streams.
* @substream: The ALSA PCM substream. * @substream: The ALSA PCM substream.
* @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START, * @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START, SNDRV_PCM_TRIGGER_STOP).
* SNDRV_PCM_TRIGGER_STOP).
* *
* This function handles starting and stopping of playback and capture streams * This function handles starting and stopping of playback and capture streams
* by submitting or killing the associated URBs. It ensures that both streams * by submitting or killing the associated URBs. It ensures that both streams

593
us144mkii_playback.c
View File

@ -12,14 +12,15 @@
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_playback_open(struct snd_pcm_substream *substream) { static int tascam_playback_open(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
substream->runtime->hw = tascam_pcm_hw; substream->runtime->hw = tascam_pcm_hw;
tascam->playback_substream = substream; tascam->playback_substream = substream;
atomic_set(&tascam->playback_active, 0); atomic_set(&tascam->playback_active, 0);
return 0; return 0;
} }
/** /**
@ -31,12 +32,13 @@ static int tascam_playback_open(struct snd_pcm_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_playback_close(struct snd_pcm_substream *substream) { static int tascam_playback_close(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->playback_substream = NULL; tascam->playback_substream = NULL;
return 0; return 0;
} }
/** /**
@ -49,57 +51,64 @@ static int tascam_playback_close(struct snd_pcm_substream *substream) {
* *
* Return: 0 on success. * Return: 0 on success.
*/ */
static int tascam_playback_prepare(struct snd_pcm_substream *substream) { static int tascam_playback_prepare(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct snd_pcm_runtime *runtime = substream->runtime; struct tascam_card *tascam = snd_pcm_substream_chip(substream);
int i, u; struct snd_pcm_runtime *runtime = substream->runtime;
size_t nominal_frames_per_packet, nominal_bytes_per_packet; int i, u;
size_t total_bytes_in_urb; size_t nominal_frames_per_packet, nominal_bytes_per_packet;
unsigned int feedback_packets; size_t total_bytes_in_urb;
unsigned int feedback_packets;
tascam->driver_playback_pos = 0; tascam->driver_playback_pos = 0;
tascam->playback_frames_consumed = 0; tascam->playback_frames_consumed = 0;
tascam->last_period_pos = 0; tascam->last_period_pos = 0;
tascam->feedback_pattern_in_idx = 0; tascam->feedback_pattern_in_idx = 0;
tascam->feedback_pattern_out_idx = 0; tascam->feedback_pattern_out_idx = 0;
tascam->feedback_synced = false; tascam->feedback_synced = false;
tascam->feedback_consecutive_errors = 0; tascam->feedback_consecutive_errors = 0;
tascam->feedback_urb_skip_count = NUM_FEEDBACK_URBS; tascam->feedback_urb_skip_count = NUM_FEEDBACK_URBS;
nominal_frames_per_packet = runtime->rate / 8000; nominal_frames_per_packet = runtime->rate / 8000;
for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++) for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++)
tascam->feedback_accumulator_pattern[i] = nominal_frames_per_packet; tascam->feedback_accumulator_pattern[i] =
nominal_frames_per_packet;
feedback_packets = 1; feedback_packets = 1;
for (i = 0; i < NUM_FEEDBACK_URBS; i++) { for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
struct urb *f_urb = tascam->feedback_urbs[i]; struct urb *f_urb = tascam->feedback_urbs[i];
int j; int j;
f_urb->number_of_packets = feedback_packets; f_urb->number_of_packets = feedback_packets;
f_urb->transfer_buffer_length = feedback_packets * FEEDBACK_PACKET_SIZE; f_urb->transfer_buffer_length =
for (j = 0; j < feedback_packets; j++) { feedback_packets * FEEDBACK_PACKET_SIZE;
f_urb->iso_frame_desc[j].offset = j * FEEDBACK_PACKET_SIZE; for (j = 0; j < feedback_packets; j++) {
f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE; f_urb->iso_frame_desc[j].offset =
} j * FEEDBACK_PACKET_SIZE;
} f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE;
}
}
nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME; nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME;
total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS; total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS;
for (u = 0; u < NUM_PLAYBACK_URBS; u++) { for (u = 0; u < NUM_PLAYBACK_URBS; u++) {
struct urb *urb = tascam->playback_urbs[u]; struct urb *urb = tascam->playback_urbs[u];
memset(urb->transfer_buffer, 0, tascam->playback_urb_alloc_size); memset(urb->transfer_buffer, 0,
urb->transfer_buffer_length = total_bytes_in_urb; tascam->playback_urb_alloc_size);
urb->number_of_packets = PLAYBACK_URB_PACKETS; urb->transfer_buffer_length = total_bytes_in_urb;
for (i = 0; i < PLAYBACK_URB_PACKETS; i++) { urb->number_of_packets = PLAYBACK_URB_PACKETS;
urb->iso_frame_desc[i].offset = i * nominal_bytes_per_packet; for (i = 0; i < PLAYBACK_URB_PACKETS; i++) {
urb->iso_frame_desc[i].length = nominal_bytes_per_packet; urb->iso_frame_desc[i].offset =
} i * nominal_bytes_per_packet;
} urb->iso_frame_desc[i].length =
nominal_bytes_per_packet;
}
}
return 0; return 0;
} }
/** /**
@ -112,21 +121,21 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream) {
* Return: The current playback pointer position in frames. * Return: The current playback pointer position in frames.
*/ */
static snd_pcm_uframes_t static snd_pcm_uframes_t
tascam_playback_pointer(struct snd_pcm_substream *substream) { tascam_playback_pointer(struct snd_pcm_substream *substream)
struct tascam_card *tascam = snd_pcm_substream_chip(substream); {
struct snd_pcm_runtime *runtime = substream->runtime; struct tascam_card *tascam = snd_pcm_substream_chip(substream);
u64 pos; struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags; u64 pos;
unsigned long flags;
if (!atomic_read(&tascam->playback_active)) if (!atomic_read(&tascam->playback_active))
return 0; return 0;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
pos = tascam->playback_frames_consumed; pos = tascam->playback_frames_consumed;
spin_unlock_irqrestore(&tascam->lock, flags); spin_unlock_irqrestore(&tascam->lock, flags);
u64 remainder = do_div(pos, runtime->buffer_size); return runtime ? pos % runtime->buffer_size : 0;
return runtime ? remainder : 0;
} }
/** /**
@ -137,14 +146,14 @@ tascam_playback_pointer(struct snd_pcm_substream *substream) {
* trigger, and pointer. * trigger, and pointer.
*/ */
const struct snd_pcm_ops tascam_playback_ops = { const struct snd_pcm_ops tascam_playback_ops = {
.open = tascam_playback_open, .open = tascam_playback_open,
.close = tascam_playback_close, .close = tascam_playback_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
.hw_params = tascam_pcm_hw_params, .hw_params = tascam_pcm_hw_params,
.hw_free = tascam_pcm_hw_free, .hw_free = tascam_pcm_hw_free,
.prepare = tascam_playback_prepare, .prepare = tascam_playback_prepare,
.trigger = tascam_pcm_trigger, .trigger = tascam_pcm_trigger,
.pointer = tascam_playback_pointer, .pointer = tascam_playback_pointer,
}; };
/** /**
@ -156,97 +165,103 @@ const struct snd_pcm_ops tascam_playback_ops = {
* copies the audio data from the ALSA ring buffer (applying routing), and * copies the audio data from the ALSA ring buffer (applying routing), and
* resubmits the URB. * resubmits the URB.
*/ */
void playback_urb_complete(struct urb *urb) { void playback_urb_complete(struct urb *urb)
struct tascam_card *tascam = urb->context; {
struct snd_pcm_substream *substream; struct tascam_card *tascam = urb->context;
struct snd_pcm_runtime *runtime; struct snd_pcm_substream *substream;
unsigned long flags; struct snd_pcm_runtime *runtime;
u8 *src_buf, *dst_buf; unsigned long flags;
size_t total_bytes_for_urb = 0; u8 *src_buf, *dst_buf;
snd_pcm_uframes_t offset_frames; size_t total_bytes_for_urb = 0;
snd_pcm_uframes_t frames_to_copy; snd_pcm_uframes_t offset_frames;
int ret, i; snd_pcm_uframes_t frames_to_copy;
int ret, i;
if (urb->status) { if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN && urb->status != -ENODEV) urb->status != -ESHUTDOWN && urb->status != -ENODEV)
dev_err_ratelimited(tascam->card->dev, "Playback URB failed: %d\n", dev_err_ratelimited(tascam->card->dev,
urb->status); "Playback URB failed: %d\n",
goto out; urb->status);
} goto out;
if (!tascam || !atomic_read(&tascam->playback_active)) }
goto out; if (!tascam || !atomic_read(&tascam->playback_active))
goto out;
substream = tascam->playback_substream; substream = tascam->playback_substream;
if (!substream || !substream->runtime) if (!substream || !substream->runtime)
goto out; goto out;
runtime = substream->runtime; runtime = substream->runtime;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
for (i = 0; i < urb->number_of_packets; i++) { for (i = 0; i < urb->number_of_packets; i++) {
unsigned int frames_for_packet; unsigned int frames_for_packet;
size_t bytes_for_packet; size_t bytes_for_packet;
if (tascam->feedback_synced) { if (tascam->feedback_synced) {
frames_for_packet = frames_for_packet =
tascam tascam->feedback_accumulator_pattern
->feedback_accumulator_pattern[tascam->feedback_pattern_out_idx]; [tascam->feedback_pattern_out_idx];
tascam->feedback_pattern_out_idx = tascam->feedback_pattern_out_idx =
(tascam->feedback_pattern_out_idx + 1) % FEEDBACK_ACCUMULATOR_SIZE; (tascam->feedback_pattern_out_idx + 1) %
} else { FEEDBACK_ACCUMULATOR_SIZE;
frames_for_packet = runtime->rate / 8000; } else {
} frames_for_packet = runtime->rate / 8000;
bytes_for_packet = frames_for_packet * BYTES_PER_FRAME; }
bytes_for_packet = frames_for_packet * BYTES_PER_FRAME;
urb->iso_frame_desc[i].offset = total_bytes_for_urb; urb->iso_frame_desc[i].offset = total_bytes_for_urb;
urb->iso_frame_desc[i].length = bytes_for_packet; urb->iso_frame_desc[i].length = bytes_for_packet;
total_bytes_for_urb += bytes_for_packet; total_bytes_for_urb += bytes_for_packet;
} }
urb->transfer_buffer_length = total_bytes_for_urb; urb->transfer_buffer_length = total_bytes_for_urb;
offset_frames = tascam->driver_playback_pos; offset_frames = tascam->driver_playback_pos;
frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb); frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb);
tascam->driver_playback_pos = tascam->driver_playback_pos =
(offset_frames + frames_to_copy) % runtime->buffer_size; (offset_frames + frames_to_copy) % runtime->buffer_size;
spin_unlock_irqrestore(&tascam->lock, flags); spin_unlock_irqrestore(&tascam->lock, flags);
if (total_bytes_for_urb > 0) { if (total_bytes_for_urb > 0) {
src_buf = runtime->dma_area + frames_to_bytes(runtime, offset_frames); src_buf = runtime->dma_area +
dst_buf = tascam->playback_routing_buffer; frames_to_bytes(runtime, offset_frames);
dst_buf = tascam->playback_routing_buffer;
/* Handle ring buffer wrap-around */ /* Handle ring buffer wrap-around */
if (offset_frames + frames_to_copy > runtime->buffer_size) { if (offset_frames + frames_to_copy > runtime->buffer_size) {
size_t first_chunk_bytes = size_t first_chunk_bytes = frames_to_bytes(
frames_to_bytes(runtime, runtime->buffer_size - offset_frames); runtime, runtime->buffer_size - offset_frames);
size_t second_chunk_bytes = total_bytes_for_urb - first_chunk_bytes; size_t second_chunk_bytes =
total_bytes_for_urb - first_chunk_bytes;
memcpy(dst_buf, src_buf, first_chunk_bytes); memcpy(dst_buf, src_buf, first_chunk_bytes);
memcpy(dst_buf + first_chunk_bytes, runtime->dma_area, memcpy(dst_buf + first_chunk_bytes, runtime->dma_area,
second_chunk_bytes); second_chunk_bytes);
} else { } else {
memcpy(dst_buf, src_buf, total_bytes_for_urb); memcpy(dst_buf, src_buf, total_bytes_for_urb);
} }
/* Apply routing to the contiguous data in our routing buffer */ /* Apply routing to the contiguous data in our routing buffer */
process_playback_routing_us144mkii(tascam, dst_buf, dst_buf, process_playback_routing_us144mkii(tascam, dst_buf, dst_buf,
frames_to_copy); frames_to_copy);
memcpy(urb->transfer_buffer, dst_buf, total_bytes_for_urb); memcpy(urb->transfer_buffer, dst_buf, total_bytes_for_urb);
} }
urb->dev = tascam->dev; urb->dev = tascam->dev;
usb_get_urb(urb); usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->playback_anchor); usb_anchor_urb(urb, &tascam->playback_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC); ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) { if (ret < 0) {
dev_err_ratelimited(tascam->card->dev, dev_err_ratelimited(tascam->card->dev,
"Failed to resubmit playback URB: %d\n", ret); "Failed to resubmit playback URB: %d\n",
usb_unanchor_urb(urb); ret);
usb_put_urb(urb); usb_unanchor_urb(urb);
} usb_put_urb(urb);
}
out: out:
usb_put_urb(urb); usb_put_urb(urb);
} }
/** /**
@ -260,161 +275,179 @@ out:
* streams in sync. It then calls snd_pcm_period_elapsed if necessary and * streams in sync. It then calls snd_pcm_period_elapsed if necessary and
* resubmits itself. * resubmits itself.
*/ */
void feedback_urb_complete(struct urb *urb) { void feedback_urb_complete(struct urb *urb)
struct tascam_card *tascam = urb->context; {
struct snd_pcm_substream *playback_ss, *capture_ss; struct tascam_card *tascam = urb->context;
struct snd_pcm_runtime *playback_rt, *capture_rt; struct snd_pcm_substream *playback_ss, *capture_ss;
unsigned long flags; struct snd_pcm_runtime *playback_rt, *capture_rt;
u64 total_frames_in_urb = 0; unsigned long flags;
int ret, p; u64 total_frames_in_urb = 0;
unsigned int old_in_idx, new_in_idx; int ret, p;
bool playback_period_elapsed = false; unsigned int old_in_idx, new_in_idx;
bool capture_period_elapsed = false; bool playback_period_elapsed = false;
bool capture_period_elapsed = false;
if (urb->status) { if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN && urb->status != -ENODEV) urb->status != -ESHUTDOWN && urb->status != -ENODEV)
dev_err_ratelimited(tascam->card->dev, "Feedback URB failed: %d\n", dev_err_ratelimited(tascam->card->dev,
urb->status); "Feedback URB failed: %d\n",
goto out; urb->status);
} goto out;
if (!tascam || !atomic_read(&tascam->playback_active)) }
goto out; if (!tascam || !atomic_read(&tascam->playback_active))
goto out;
playback_ss = tascam->playback_substream; playback_ss = tascam->playback_substream;
if (!playback_ss || !playback_ss->runtime) if (!playback_ss || !playback_ss->runtime)
goto out; goto out;
playback_rt = playback_ss->runtime; playback_rt = playback_ss->runtime;
capture_ss = tascam->capture_substream; capture_ss = tascam->capture_substream;
capture_rt = capture_ss ? capture_ss->runtime : NULL; capture_rt = capture_ss ? capture_ss->runtime : NULL;
spin_lock_irqsave(&tascam->lock, flags); spin_lock_irqsave(&tascam->lock, flags);
if (tascam->feedback_urb_skip_count > 0) { if (tascam->feedback_urb_skip_count > 0) {
tascam->feedback_urb_skip_count--; tascam->feedback_urb_skip_count--;
goto unlock_and_continue; goto unlock_and_continue;
} }
old_in_idx = tascam->feedback_pattern_in_idx; old_in_idx = tascam->feedback_pattern_in_idx;
for (p = 0; p < urb->number_of_packets; p++) { for (p = 0; p < urb->number_of_packets; p++) {
u8 feedback_value = 0; u8 feedback_value = 0;
const unsigned int *pattern; const unsigned int *pattern;
bool packet_ok = (urb->iso_frame_desc[p].status == 0 && bool packet_ok = (urb->iso_frame_desc[p].status == 0 &&
urb->iso_frame_desc[p].actual_length >= 1); urb->iso_frame_desc[p].actual_length >= 1);
if (packet_ok) if (packet_ok)
feedback_value = feedback_value = *((u8 *)urb->transfer_buffer +
*((u8 *)urb->transfer_buffer + urb->iso_frame_desc[p].offset); urb->iso_frame_desc[p].offset);
if (packet_ok && feedback_value >= tascam->feedback_base_value && if (packet_ok &&
feedback_value <= tascam->feedback_max_value) { feedback_value >= tascam->feedback_base_value &&
pattern = feedback_value <= tascam->feedback_max_value) {
tascam pattern = tascam->feedback_patterns
->feedback_patterns[feedback_value - tascam->feedback_base_value]; [feedback_value -
tascam->feedback_consecutive_errors = 0; tascam->feedback_base_value];
int i; tascam->feedback_consecutive_errors = 0;
int i;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
unsigned int in_idx = unsigned int in_idx =
(tascam->feedback_pattern_in_idx + i) % FEEDBACK_ACCUMULATOR_SIZE; (tascam->feedback_pattern_in_idx + i) %
FEEDBACK_ACCUMULATOR_SIZE;
tascam->feedback_accumulator_pattern[in_idx] = pattern[i]; tascam->feedback_accumulator_pattern[in_idx] =
total_frames_in_urb += pattern[i]; pattern[i];
} total_frames_in_urb += pattern[i];
} else { }
unsigned int nominal_frames = playback_rt->rate / 8000; } else {
int i; unsigned int nominal_frames = playback_rt->rate / 8000;
int i;
if (tascam->feedback_synced) { if (tascam->feedback_synced) {
tascam->feedback_consecutive_errors++; tascam->feedback_consecutive_errors++;
if (tascam->feedback_consecutive_errors > if (tascam->feedback_consecutive_errors >
FEEDBACK_SYNC_LOSS_THRESHOLD) { FEEDBACK_SYNC_LOSS_THRESHOLD) {
dev_err(tascam->card->dev, dev_err(tascam->card->dev,
"Fatal: Feedback sync lost. Stopping stream.\n"); "Fatal: Feedback sync lost. Stopping stream.\n");
if (playback_ss) if (playback_ss)
snd_pcm_stop(playback_ss, SNDRV_PCM_STATE_XRUN); snd_pcm_stop(
if (capture_ss) playback_ss,
snd_pcm_stop(capture_ss, SNDRV_PCM_STATE_XRUN); SNDRV_PCM_STATE_XRUN);
tascam->feedback_synced = false; if (capture_ss)
goto unlock_and_continue; snd_pcm_stop(
} capture_ss,
} SNDRV_PCM_STATE_XRUN);
for (i = 0; i < 8; i++) { tascam->feedback_synced = false;
unsigned int in_idx = goto unlock_and_continue;
(tascam->feedback_pattern_in_idx + i) % FEEDBACK_ACCUMULATOR_SIZE; }
}
for (i = 0; i < 8; i++) {
unsigned int in_idx =
(tascam->feedback_pattern_in_idx + i) %
FEEDBACK_ACCUMULATOR_SIZE;
tascam->feedback_accumulator_pattern[in_idx] = nominal_frames; tascam->feedback_accumulator_pattern[in_idx] =
total_frames_in_urb += nominal_frames; nominal_frames;
} total_frames_in_urb += nominal_frames;
} }
tascam->feedback_pattern_in_idx = }
(tascam->feedback_pattern_in_idx + 8) % FEEDBACK_ACCUMULATOR_SIZE; tascam->feedback_pattern_in_idx =
} (tascam->feedback_pattern_in_idx + 8) %
FEEDBACK_ACCUMULATOR_SIZE;
}
new_in_idx = tascam->feedback_pattern_in_idx; new_in_idx = tascam->feedback_pattern_in_idx;
if (!tascam->feedback_synced) { if (!tascam->feedback_synced) {
unsigned int out_idx = tascam->feedback_pattern_out_idx; unsigned int out_idx = tascam->feedback_pattern_out_idx;
bool is_ahead = (new_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE < bool is_ahead =
(FEEDBACK_ACCUMULATOR_SIZE / 2); (new_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE <
bool was_behind = (old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >= (FEEDBACK_ACCUMULATOR_SIZE / 2);
(FEEDBACK_ACCUMULATOR_SIZE / 2); bool was_behind =
(old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >=
(FEEDBACK_ACCUMULATOR_SIZE / 2);
if (is_ahead && was_behind) { if (is_ahead && was_behind) {
dev_dbg(tascam->card->dev, "Sync Acquired! (in: %u, out: %u)\n", dev_dbg(tascam->card->dev,
new_in_idx, out_idx); "Sync Acquired! (in: %u, out: %u)\n",
tascam->feedback_synced = true; new_in_idx, out_idx);
tascam->feedback_consecutive_errors = 0; tascam->feedback_synced = true;
} tascam->feedback_consecutive_errors = 0;
} }
}
if (total_frames_in_urb > 0) { if (total_frames_in_urb > 0) {
tascam->playback_frames_consumed += total_frames_in_urb; tascam->playback_frames_consumed += total_frames_in_urb;
if (atomic_read(&tascam->capture_active)) if (atomic_read(&tascam->capture_active))
tascam->capture_frames_processed += total_frames_in_urb; tascam->capture_frames_processed += total_frames_in_urb;
} }
if (playback_rt->period_size > 0) { if (playback_rt->period_size > 0) {
u64 current_period = u64 current_period = div_u64(tascam->playback_frames_consumed,
div_u64(tascam->playback_frames_consumed, playback_rt->period_size); playback_rt->period_size);
if (current_period > tascam->last_period_pos) { if (current_period > tascam->last_period_pos) {
tascam->last_period_pos = current_period; tascam->last_period_pos = current_period;
playback_period_elapsed = true; playback_period_elapsed = true;
} }
} }
if (atomic_read(&tascam->capture_active) && capture_rt && if (atomic_read(&tascam->capture_active) && capture_rt &&
capture_rt->period_size > 0) { capture_rt->period_size > 0) {
u64 current_capture_period = u64 current_capture_period =
div_u64(tascam->capture_frames_processed, capture_rt->period_size); div_u64(tascam->capture_frames_processed,
capture_rt->period_size);
if (current_capture_period > tascam->last_capture_period_pos) { if (current_capture_period > tascam->last_capture_period_pos) {
tascam->last_capture_period_pos = current_capture_period; tascam->last_capture_period_pos =
capture_period_elapsed = true; current_capture_period;
} capture_period_elapsed = true;
} }
}
unlock_and_continue: unlock_and_continue:
spin_unlock_irqrestore(&tascam->lock, flags); spin_unlock_irqrestore(&tascam->lock, flags);
if (playback_period_elapsed) if (playback_period_elapsed)
snd_pcm_period_elapsed(playback_ss); snd_pcm_period_elapsed(playback_ss);
if (capture_period_elapsed) if (capture_period_elapsed)
snd_pcm_period_elapsed(capture_ss); snd_pcm_period_elapsed(capture_ss);
urb->dev = tascam->dev; urb->dev = tascam->dev;
usb_get_urb(urb); usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->feedback_anchor); usb_anchor_urb(urb, &tascam->feedback_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC); ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) { if (ret < 0) {
dev_err_ratelimited(tascam->card->dev, dev_err_ratelimited(tascam->card->dev,
"Failed to resubmit feedback URB: %d\n", ret); "Failed to resubmit feedback URB: %d\n",
usb_unanchor_urb(urb); ret);
usb_put_urb(urb); usb_unanchor_urb(urb);
} usb_put_urb(urb);
}
out: out:
usb_put_urb(urb); usb_put_urb(urb);
} }