// 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);
}