320 lines
8.6 KiB
C
320 lines
8.6 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
// Copyright (c) 2025 Šerif Rami <ramiserifpersia@gmail.com>
|
|
|
|
#include "us144mkii.h"
|
|
|
|
/**
|
|
* tascam_capture_open() - Opens the PCM capture substream.
|
|
* @substream: The ALSA PCM substream to open.
|
|
*
|
|
* This function sets the hardware parameters for the capture substream
|
|
* and stores a reference to the substream in the driver's private data.
|
|
*
|
|
* Return: 0 on success.
|
|
*/
|
|
static int tascam_capture_open(struct snd_pcm_substream *substream)
|
|
{
|
|
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
|
|
|
|
substream->runtime->hw = tascam_pcm_hw;
|
|
tascam->capture_substream = substream;
|
|
atomic_set(&tascam->capture_active, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tascam_capture_close() - Closes the PCM capture substream.
|
|
* @substream: The ALSA PCM substream to close.
|
|
*
|
|
* This function clears the reference to the capture substream in the
|
|
* driver's private data.
|
|
*
|
|
* Return: 0 on success.
|
|
*/
|
|
static int tascam_capture_close(struct snd_pcm_substream *substream)
|
|
{
|
|
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
|
|
|
|
tascam->capture_substream = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tascam_capture_prepare() - Prepares the PCM capture substream for use.
|
|
* @substream: The ALSA PCM substream to prepare.
|
|
*
|
|
* This function initializes capture-related counters and ring buffer pointers.
|
|
*
|
|
* Return: 0 on success.
|
|
*/
|
|
static int tascam_capture_prepare(struct snd_pcm_substream *substream)
|
|
{
|
|
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
|
|
|
|
tascam->driver_capture_pos = 0;
|
|
tascam->capture_frames_processed = 0;
|
|
tascam->last_capture_period_pos = 0;
|
|
tascam->capture_ring_buffer_read_ptr = 0;
|
|
tascam->capture_ring_buffer_write_ptr = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tascam_capture_pointer() - Returns the current capture pointer position.
|
|
* @substream: The ALSA PCM substream.
|
|
*
|
|
* This function returns the current position of the capture pointer within
|
|
* the ALSA ring buffer, in frames.
|
|
*
|
|
* Return: The current capture pointer position in frames.
|
|
*/
|
|
static snd_pcm_uframes_t
|
|
tascam_capture_pointer(struct snd_pcm_substream *substream)
|
|
{
|
|
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
u64 pos;
|
|
|
|
if (!atomic_read(&tascam->capture_active))
|
|
return 0;
|
|
|
|
scoped_guard(spinlock_irqsave, &tascam->lock) {
|
|
pos = tascam->capture_frames_processed;
|
|
}
|
|
|
|
if (runtime->buffer_size == 0)
|
|
return 0;
|
|
|
|
return do_div(pos, runtime->buffer_size);
|
|
}
|
|
|
|
/**
|
|
* tascam_capture_ops - ALSA PCM operations for capture.
|
|
*
|
|
* This structure defines the callback functions for capture stream operations,
|
|
* including open, close, ioctl, hardware parameters, hardware free, prepare,
|
|
* trigger, and pointer.
|
|
*/
|
|
const struct snd_pcm_ops tascam_capture_ops = {
|
|
.open = tascam_capture_open,
|
|
.close = tascam_capture_close,
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
.hw_params = tascam_pcm_hw_params,
|
|
.hw_free = tascam_pcm_hw_free,
|
|
.prepare = tascam_capture_prepare,
|
|
.trigger = tascam_pcm_trigger,
|
|
.pointer = tascam_capture_pointer,
|
|
};
|
|
|
|
/**
|
|
* decode_tascam_capture_block() - Decodes a raw 512-byte block from the device.
|
|
* @src_block: Pointer to the 512-byte raw source block.
|
|
* @dst_block: Pointer to the destination buffer for decoded audio frames.
|
|
*
|
|
* The device sends audio data in a complex, multiplexed format. This function
|
|
* demultiplexes the bits from the raw block into 8 frames of 4-channel,
|
|
* 24-bit audio (stored in 32-bit containers).
|
|
*/
|
|
static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block)
|
|
{
|
|
int frame, bit;
|
|
|
|
memset(dst_block, 0,
|
|
FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
|
|
DECODED_SAMPLE_SIZE);
|
|
|
|
for (frame = 0; frame < FRAMES_PER_DECODE_BLOCK; ++frame) {
|
|
const u8 *p_src_frame_base = src_block + frame * 64;
|
|
s32 *p_dst_frame = dst_block + frame * 4;
|
|
|
|
s32 ch[4] = { 0 };
|
|
|
|
for (bit = 0; bit < 24; ++bit) {
|
|
u8 byte1 = p_src_frame_base[bit];
|
|
u8 byte2 = p_src_frame_base[bit + 32];
|
|
|
|
ch[0] = (ch[0] << 1) | (byte1 & 1);
|
|
ch[2] = (ch[2] << 1) | ((byte1 >> 1) & 1);
|
|
|
|
ch[1] = (ch[1] << 1) | (byte2 & 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 most significant bits of a 32-bit integer (S32_LE format).
|
|
*/
|
|
p_dst_frame[0] = ch[0] << 8;
|
|
p_dst_frame[1] = ch[1] << 8;
|
|
p_dst_frame[2] = ch[2] << 8;
|
|
p_dst_frame[3] = ch[3] << 8;
|
|
}
|
|
}
|
|
|
|
void tascam_capture_work_handler(struct work_struct *work)
|
|
{
|
|
struct tascam_card *tascam =
|
|
container_of(work, struct tascam_card, capture_work);
|
|
struct snd_pcm_substream *substream = tascam->capture_substream;
|
|
struct snd_pcm_runtime *runtime;
|
|
u8 *raw_block = tascam->capture_decode_raw_block;
|
|
s32 *decoded_block = tascam->capture_decode_dst_block;
|
|
s32 *routed_block = tascam->capture_routing_buffer;
|
|
|
|
if (!substream || !substream->runtime)
|
|
return;
|
|
runtime = substream->runtime;
|
|
|
|
if (!raw_block || !decoded_block || !routed_block) {
|
|
dev_err(tascam->card->dev,
|
|
"Capture decode/routing buffers not allocated!\n");
|
|
return;
|
|
}
|
|
|
|
while (atomic_read(&tascam->capture_active)) {
|
|
size_t write_ptr, read_ptr, available_data;
|
|
bool can_process;
|
|
|
|
scoped_guard(spinlock_irqsave, &tascam->lock) {
|
|
write_ptr = tascam->capture_ring_buffer_write_ptr;
|
|
read_ptr = tascam->capture_ring_buffer_read_ptr;
|
|
available_data = (write_ptr >= read_ptr) ?
|
|
(write_ptr - read_ptr) :
|
|
(CAPTURE_RING_BUFFER_SIZE -
|
|
read_ptr + write_ptr);
|
|
can_process =
|
|
(available_data >= RAW_BYTES_PER_DECODE_BLOCK);
|
|
|
|
if (can_process) {
|
|
size_t bytes_to_end =
|
|
CAPTURE_RING_BUFFER_SIZE - read_ptr;
|
|
if (bytes_to_end >=
|
|
RAW_BYTES_PER_DECODE_BLOCK) {
|
|
memcpy(raw_block,
|
|
tascam->capture_ring_buffer +
|
|
read_ptr,
|
|
RAW_BYTES_PER_DECODE_BLOCK);
|
|
} else {
|
|
memcpy(raw_block,
|
|
tascam->capture_ring_buffer +
|
|
read_ptr,
|
|
bytes_to_end);
|
|
memcpy(raw_block + bytes_to_end,
|
|
tascam->capture_ring_buffer,
|
|
RAW_BYTES_PER_DECODE_BLOCK -
|
|
bytes_to_end);
|
|
}
|
|
tascam->capture_ring_buffer_read_ptr =
|
|
(read_ptr +
|
|
RAW_BYTES_PER_DECODE_BLOCK) %
|
|
CAPTURE_RING_BUFFER_SIZE;
|
|
}
|
|
}
|
|
|
|
if (!can_process)
|
|
break;
|
|
|
|
decode_tascam_capture_block(raw_block, decoded_block);
|
|
process_capture_routing_us144mkii(tascam, decoded_block,
|
|
routed_block);
|
|
|
|
scoped_guard(spinlock_irqsave, &tascam->lock) {
|
|
if (atomic_read(&tascam->capture_active)) {
|
|
int f;
|
|
|
|
for (f = 0; f < FRAMES_PER_DECODE_BLOCK; ++f) {
|
|
u8 *dst_frame_start =
|
|
runtime->dma_area +
|
|
frames_to_bytes(
|
|
runtime,
|
|
tascam->driver_capture_pos);
|
|
s32 *routed_frame_start =
|
|
routed_block +
|
|
(f * NUM_CHANNELS);
|
|
int c;
|
|
|
|
for (c = 0; c < NUM_CHANNELS; c++) {
|
|
u8 *dst_channel =
|
|
dst_frame_start +
|
|
(c * BYTES_PER_SAMPLE);
|
|
s32 *src_channel_s32 =
|
|
routed_frame_start + c;
|
|
|
|
memcpy(dst_channel,
|
|
((char *)src_channel_s32) +
|
|
1,
|
|
3);
|
|
}
|
|
|
|
tascam->driver_capture_pos =
|
|
(tascam->driver_capture_pos +
|
|
1) %
|
|
runtime->buffer_size;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void capture_urb_complete(struct urb *urb)
|
|
{
|
|
struct tascam_card *tascam = urb->context;
|
|
int ret;
|
|
|
|
if (urb->status) {
|
|
if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
|
|
urb->status != -ESHUTDOWN && urb->status != -ENODEV &&
|
|
urb->status != -EPROTO)
|
|
dev_err_ratelimited(tascam->card->dev,
|
|
"Capture URB failed: %d\n",
|
|
urb->status);
|
|
goto out;
|
|
}
|
|
if (!tascam || !atomic_read(&tascam->capture_active))
|
|
goto out;
|
|
|
|
if (urb->actual_length > 0) {
|
|
scoped_guard(spinlock_irqsave, &tascam->lock) {
|
|
size_t write_ptr = tascam->capture_ring_buffer_write_ptr;
|
|
size_t bytes_to_end = CAPTURE_RING_BUFFER_SIZE - write_ptr;
|
|
|
|
if (urb->actual_length > bytes_to_end) {
|
|
memcpy(tascam->capture_ring_buffer + write_ptr,
|
|
urb->transfer_buffer, bytes_to_end);
|
|
memcpy(tascam->capture_ring_buffer,
|
|
urb->transfer_buffer + bytes_to_end,
|
|
urb->actual_length - bytes_to_end);
|
|
} else {
|
|
memcpy(tascam->capture_ring_buffer + write_ptr,
|
|
urb->transfer_buffer,
|
|
urb->actual_length);
|
|
}
|
|
|
|
tascam->capture_ring_buffer_write_ptr =
|
|
(write_ptr + urb->actual_length) %
|
|
CAPTURE_RING_BUFFER_SIZE;
|
|
}
|
|
|
|
schedule_work(&tascam->capture_work);
|
|
}
|
|
|
|
usb_get_urb(urb);
|
|
usb_anchor_urb(urb, &tascam->capture_anchor);
|
|
ret = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (ret < 0) {
|
|
dev_err_ratelimited(tascam->card->dev,
|
|
"Failed to resubmit capture URB: %d\n",
|
|
ret);
|
|
usb_unanchor_urb(urb);
|
|
usb_put_urb(urb);
|
|
atomic_dec(
|
|
&tascam->active_urbs); /* Decrement on failed resubmission */
|
|
}
|
|
out:
|
|
usb_put_urb(urb);
|
|
}
|
|
|