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-06 13:40:07 +02:00
parent 652814585c
commit fcfad9bfc2
12 changed files with 2552 additions and 1152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -14,6 +14,7 @@ This driver is under active development.
### 📝 To-Do & Known Limitations
* Find Bugs, if possible improve performance/stablity
* *MIDI IN/OUT works only in active audio streaming(DAW ALSA/JACK or browser audio)
* Non MKII US-144 needs testing to see if the driver will work with it.
## Installation and Usage

29
tascam_controls/src/alsacontroller.cpp
View File

@ -2,8 +2,9 @@
#include <alsa/asoundlib.h>
#include <fstream>
#include <iostream>
#include <vector>
AlsaController::AlsaController(const std::string& target_card_name)
AlsaController::AlsaController(const std::vector<std::string>& target_card_names)
{
int card = -1;
if (snd_card_next(&card) < 0 || card < 0) {
@ -14,14 +15,24 @@ AlsaController::AlsaController(const std::string& target_card_name)
while (card >= 0) {
char* long_name = nullptr;
snd_card_get_longname(card, &long_name);
if (long_name && std::string(long_name).find(target_card_name) != std::string::npos) {
m_card_num = card;
m_card_id_str = "hw:" + std::to_string(card);
m_card_found = true;
free(long_name);
break;
if (long_name) {
bool found_match_and_freed = false;
for (const auto& name : target_card_names) {
if (std::string(long_name).find(name) != std::string::npos) {
m_card_num = card;
m_card_id_str = "hw:" + std::to_string(card);
m_card_found = true;
free(long_name);
found_match_and_freed = true;
break;
}
}
if (!found_match_and_freed) {
free(long_name);
}
}
if (long_name) free(long_name);
if (m_card_found) break;
if (snd_card_next(&card) < 0) {
break;
@ -29,7 +40,7 @@ AlsaController::AlsaController(const std::string& target_card_name)
}
if (!m_card_found) {
std::cerr << "Target sound card '" << target_card_name << "' not found." << std::endl;
std::cerr << "Target sound card(s) not found." << std::endl;
}
}

3
tascam_controls/src/alsacontroller.h
View File

@ -3,11 +3,12 @@
#include <string>
#include <optional>
#include <vector>
class AlsaController
{
public:
AlsaController(const std::string& target_card_name = "US-144MKII");
AlsaController(const std::vector<std::string>& target_card_names = {"US-144MKII", "US-144"});
std::optional<std::string> getCardId() const;
int getCardNumber() const;

2
tascam_controls/src/mainwindow.cpp
View File

@ -84,7 +84,7 @@ MainWindow::MainWindow(QWidget *parent)
, m_aboutDialog(nullptr)
{
if (!m_alsa.isCardFound()) {
QMessageBox::critical(this, "Error", "TASCAM US-144MKII Not Found.\nPlease ensure the device is connected and the 'us144mkii' driver is loaded.");
QMessageBox::critical(this, "Error", "TASCAM US-144/US-144MKII Not Found.\nPlease ensure the device is connected and the 'us144mkii' driver is loaded.");
QTimer::singleShot(0, this, &QWidget::close);
return;
}

859
us144mkii.c
View File

File diff suppressed because it is too large Load Diff

315
us144mkii.h
View File

@ -4,100 +4,133 @@
#ifndef __US144MKII_H
#define __US144MKII_H
#include <linux/kfifo.h>
#include <linux/usb.h>
#include <linux/workqueue.h>
#include <linux/kfifo.h>
#include <sound/control.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/rawmidi.h>
#include <sound/initval.h>
#include <sound/control.h>
#define DRIVER_NAME "us144mkii"
#define DRIVER_VERSION "1.7.4"
/* --- USB Device Identification --- */
#define USB_VID_TASCAM 0x0644
#define USB_PID_TASCAM_US144MKII 0x8020
#define USB_VID_TASCAM 0x0644
<<<<<<< HEAD
#define USB_PID_TASCAM_US144 0x800f
=======
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
#define USB_PID_TASCAM_US144MKII 0x8020
/* --- USB Endpoints (Alternate Setting 1) --- */
#define EP_PLAYBACK_FEEDBACK 0x81
#define EP_AUDIO_OUT 0x02
#define EP_MIDI_IN 0x83
#define EP_MIDI_OUT 0x04
#define EP_AUDIO_IN 0x86
#define EP_PLAYBACK_FEEDBACK 0x81
#define EP_AUDIO_OUT 0x02
#define EP_MIDI_IN 0x83
#define EP_MIDI_OUT 0x04
#define EP_AUDIO_IN 0x86
/* --- USB Control Message Protocol --- */
#define RT_H2D_CLASS_EP (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT)
#define RT_D2H_CLASS_EP (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT)
#define RT_H2D_VENDOR_DEV (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
#define RT_D2H_VENDOR_DEV (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
#define RT_H2D_CLASS_EP (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT)
#define RT_D2H_CLASS_EP (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT)
#define RT_H2D_VENDOR_DEV (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
#define RT_D2H_VENDOR_DEV (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
enum uac_request {
UAC_SET_CUR = 0x01,
UAC_GET_CUR = 0x81,
<<<<<<< HEAD
UAC_SET_CUR = 0x01,
UAC_GET_CUR = 0x81,
};
enum uac_control_selector {
UAC_SAMPLING_FREQ_CONTROL = 0x0100,
UAC_SAMPLING_FREQ_CONTROL = 0x0100,
};
enum tascam_vendor_request {
VENDOR_REQ_REGISTER_WRITE = 0x41,
VENDOR_REQ_MODE_CONTROL = 0x49,
VENDOR_REQ_REGISTER_WRITE = 0x41,
VENDOR_REQ_MODE_CONTROL = 0x49,
};
enum tascam_mode_value {
MODE_VAL_HANDSHAKE_READ = 0x0000,
MODE_VAL_CONFIG = 0x0010,
MODE_VAL_STREAM_START = 0x0030,
MODE_VAL_HANDSHAKE_READ = 0x0000,
MODE_VAL_CONFIG = 0x0010,
MODE_VAL_STREAM_START = 0x0030,
=======
UAC_SET_CUR = 0x01,
UAC_GET_CUR = 0x81,
};
#define HANDSHAKE_SUCCESS_VAL 0x12
enum uac_control_selector {
UAC_SAMPLING_FREQ_CONTROL = 0x0100,
};
enum tascam_vendor_request {
VENDOR_REQ_REGISTER_WRITE = 0x41,
VENDOR_REQ_MODE_CONTROL = 0x49,
};
enum tascam_mode_value {
MODE_VAL_HANDSHAKE_READ = 0x0000,
MODE_VAL_CONFIG = 0x0010,
MODE_VAL_STREAM_START = 0x0030,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
#define HANDSHAKE_SUCCESS_VAL 0x12
enum tascam_register {
REG_ADDR_UNKNOWN_0D = 0x0d04,
REG_ADDR_UNKNOWN_0E = 0x0e00,
REG_ADDR_UNKNOWN_0F = 0x0f00,
REG_ADDR_RATE_44100 = 0x1000,
REG_ADDR_RATE_48000 = 0x1002,
REG_ADDR_RATE_88200 = 0x1008,
REG_ADDR_RATE_96000 = 0x100a,
REG_ADDR_UNKNOWN_11 = 0x110b,
<<<<<<< HEAD
REG_ADDR_UNKNOWN_0D = 0x0d04,
REG_ADDR_UNKNOWN_0E = 0x0e00,
REG_ADDR_UNKNOWN_0F = 0x0f00,
REG_ADDR_RATE_44100 = 0x1000,
REG_ADDR_RATE_48000 = 0x1002,
REG_ADDR_RATE_88200 = 0x1008,
REG_ADDR_RATE_96000 = 0x100a,
REG_ADDR_UNKNOWN_11 = 0x110b,
=======
REG_ADDR_UNKNOWN_0D = 0x0d04,
REG_ADDR_UNKNOWN_0E = 0x0e00,
REG_ADDR_UNKNOWN_0F = 0x0f00,
REG_ADDR_RATE_44100 = 0x1000,
REG_ADDR_RATE_48000 = 0x1002,
REG_ADDR_RATE_88200 = 0x1008,
REG_ADDR_RATE_96000 = 0x100a,
REG_ADDR_UNKNOWN_11 = 0x110b,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
#define REG_VAL_ENABLE 0x0101
#define REG_VAL_ENABLE 0x0101
/* --- URB Configuration --- */
#define NUM_PLAYBACK_URBS 8
#define PLAYBACK_URB_PACKETS 4
#define NUM_FEEDBACK_URBS 4
#define MAX_FEEDBACK_PACKETS 5
#define FEEDBACK_PACKET_SIZE 3
#define NUM_CAPTURE_URBS 8
#define CAPTURE_URB_SIZE 512
#define CAPTURE_RING_BUFFER_SIZE (CAPTURE_URB_SIZE * NUM_CAPTURE_URBS * 4)
#define NUM_MIDI_IN_URBS 4
#define MIDI_IN_BUF_SIZE 64
#define MIDI_IN_FIFO_SIZE (MIDI_IN_BUF_SIZE * NUM_MIDI_IN_URBS)
#define MIDI_OUT_BUF_SIZE 64
#define NUM_MIDI_OUT_URBS 4
#define USB_CTRL_TIMEOUT_MS 1000
#define FEEDBACK_SYNC_LOSS_THRESHOLD 41
#define NUM_PLAYBACK_URBS 8
#define PLAYBACK_URB_PACKETS 4
#define NUM_FEEDBACK_URBS 4
#define MAX_FEEDBACK_PACKETS 5
#define FEEDBACK_PACKET_SIZE 3
#define NUM_CAPTURE_URBS 8
#define CAPTURE_URB_SIZE 512
#define CAPTURE_RING_BUFFER_SIZE (CAPTURE_URB_SIZE * NUM_CAPTURE_URBS * 4)
#define NUM_MIDI_IN_URBS 4
#define MIDI_IN_BUF_SIZE 64
#define MIDI_IN_FIFO_SIZE (MIDI_IN_BUF_SIZE * NUM_MIDI_IN_URBS)
#define MIDI_OUT_BUF_SIZE 64
#define NUM_MIDI_OUT_URBS 4
#define USB_CTRL_TIMEOUT_MS 1000
#define FEEDBACK_SYNC_LOSS_THRESHOLD 41
/* --- Audio Format Configuration --- */
#define BYTES_PER_SAMPLE 3
#define NUM_CHANNELS 4
#define BYTES_PER_FRAME (NUM_CHANNELS * BYTES_PER_SAMPLE)
#define FEEDBACK_ACCUMULATOR_SIZE 128
#define BYTES_PER_SAMPLE 3
#define NUM_CHANNELS 4
#define BYTES_PER_FRAME (NUM_CHANNELS * BYTES_PER_SAMPLE)
#define FEEDBACK_ACCUMULATOR_SIZE 128
/* --- Capture Decoding Defines --- */
#define DECODED_CHANNELS_PER_FRAME 4
#define DECODED_SAMPLE_SIZE 4
#define FRAMES_PER_DECODE_BLOCK 8
#define RAW_BYTES_PER_DECODE_BLOCK 512
#define DECODED_CHANNELS_PER_FRAME 4
#define DECODED_SAMPLE_SIZE 4
#define FRAMES_PER_DECODE_BLOCK 8
#define RAW_BYTES_PER_DECODE_BLOCK 512
/**
* struct tascam_card - Main driver data structure for the TASCAM US-144MKII.
@ -153,17 +186,23 @@ enum tascam_register {
* @active_urbs: Atomic counter for active URBs.
* @current_rate: Currently configured sample rate of the device.
* @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 3-4).
* @capture_12_source: Source for Capture channels 1-2 (0: Analog In, 1: Digital In).
* @capture_34_source: Source for Capture channels 3-4 (0: Analog In, 1: Digital In).
* @digital_out_source: Source for Digital Outputs (0: Playback 1-2, 1: Playback
* 3-4).
* @capture_12_source: Source for Capture channels 1-2 (0: Analog In, 1: Digital
* 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.
* @feedback_accumulator_pattern: Stores the calculated frames per packet for
* feedback.
* @feedback_pattern_out_idx: Read index for feedback_accumulator_pattern.
* @feedback_pattern_in_idx: Write index for feedback_accumulator_pattern.
* @feedback_synced: Flag indicating if feedback is synced.
* @feedback_consecutive_errors: Counter for consecutive feedback errors.
* @feedback_urb_skip_count: Number of feedback URBs to skip initially for stabilization.
* @feedback_patterns: Pointer to the current feedback patterns based on sample rate.
* @feedback_urb_skip_count: Number of feedback URBs to skip initially for
* stabilization.
* @feedback_patterns: Pointer to the current feedback patterns based on sample
* rate.
* @feedback_base_value: Base value for feedback pattern lookup.
* @feedback_max_value: Max value for feedback pattern lookup.
*
@ -174,82 +213,93 @@ enum tascam_register {
* @midi_out_anchor: USB anchor for MIDI output URBs.
*/
struct tascam_card {
struct usb_device *dev;
struct usb_interface *iface0;
struct usb_interface *iface1;
struct snd_card *card;
struct snd_pcm *pcm;
struct snd_rawmidi *rmidi;
struct usb_device *dev;
struct usb_interface *iface0;
struct usb_interface *iface1;
struct snd_card *card;
struct snd_pcm *pcm;
struct snd_rawmidi *rmidi;
/* Playback stream */
struct snd_pcm_substream *playback_substream;
struct urb *playback_urbs[NUM_PLAYBACK_URBS];
size_t playback_urb_alloc_size;
struct urb *feedback_urbs[NUM_FEEDBACK_URBS];
size_t feedback_urb_alloc_size;
atomic_t playback_active;
u64 playback_frames_consumed;
snd_pcm_uframes_t driver_playback_pos;
u64 last_period_pos;
u8 *playback_routing_buffer;
/* Playback stream */
struct snd_pcm_substream *playback_substream;
struct urb *playback_urbs[NUM_PLAYBACK_URBS];
size_t playback_urb_alloc_size;
struct urb *feedback_urbs[NUM_FEEDBACK_URBS];
size_t feedback_urb_alloc_size;
atomic_t playback_active;
u64 playback_frames_consumed;
snd_pcm_uframes_t driver_playback_pos;
u64 last_period_pos;
u8 *playback_routing_buffer;
/* Capture stream */
struct snd_pcm_substream *capture_substream;
struct urb *capture_urbs[NUM_CAPTURE_URBS];
size_t capture_urb_alloc_size;
atomic_t capture_active;
snd_pcm_uframes_t driver_capture_pos;
u64 capture_frames_processed;
u64 last_capture_period_pos;
u8 *capture_ring_buffer;
size_t capture_ring_buffer_read_ptr;
size_t capture_ring_buffer_write_ptr;
u8 *capture_decode_raw_block;
s32 *capture_decode_dst_block;
s32 *capture_routing_buffer;
struct work_struct capture_work;
struct work_struct stop_work;
/* Capture stream */
struct snd_pcm_substream *capture_substream;
struct urb *capture_urbs[NUM_CAPTURE_URBS];
size_t capture_urb_alloc_size;
atomic_t capture_active;
snd_pcm_uframes_t driver_capture_pos;
u64 capture_frames_processed;
u64 last_capture_period_pos;
u8 *capture_ring_buffer;
size_t capture_ring_buffer_read_ptr;
size_t capture_ring_buffer_write_ptr;
u8 *capture_decode_raw_block;
s32 *capture_decode_dst_block;
s32 *capture_routing_buffer;
struct work_struct capture_work;
struct work_struct stop_work;
/* MIDI streams */
struct snd_rawmidi_substream *midi_in_substream;
struct snd_rawmidi_substream *midi_out_substream;
struct urb *midi_in_urbs[NUM_MIDI_IN_URBS];
atomic_t midi_in_active;
struct kfifo midi_in_fifo;
struct work_struct midi_in_work;
spinlock_t midi_in_lock;
struct urb *midi_out_urbs[NUM_MIDI_OUT_URBS];
atomic_t midi_out_active;
struct work_struct midi_out_work;
unsigned long midi_out_urbs_in_flight;
spinlock_t midi_out_lock;
u8 midi_running_status;
/* MIDI streams */
struct snd_rawmidi_substream *midi_in_substream;
struct snd_rawmidi_substream *midi_out_substream;
struct urb *midi_in_urbs[NUM_MIDI_IN_URBS];
atomic_t midi_in_active;
struct kfifo midi_in_fifo;
struct work_struct midi_in_work;
spinlock_t midi_in_lock;
struct urb *midi_out_urbs[NUM_MIDI_OUT_URBS];
atomic_t midi_out_active;
struct work_struct midi_out_work;
unsigned long midi_out_urbs_in_flight;
spinlock_t midi_out_lock;
u8 midi_running_status;
<<<<<<< HEAD
/* Shared state & Routing Matrix */
spinlock_t lock;
atomic_t active_urbs;
int current_rate;
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 capture_12_source; /* 0: Analog In, 1: Digital In */
unsigned int capture_34_source; /* 0: Analog In, 1: Digital In */
=======
/* Shared state & Routing Matrix */
spinlock_t lock;
atomic_t active_urbs;
int current_rate;
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 capture_12_source; /* 0: Analog In, 1: Digital In */
unsigned int capture_34_source; /* 0: Analog In, 1: Digital In */
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 capture_12_source; /* 0: Analog In, 1: Digital In */
unsigned int capture_34_source; /* 0: Analog In, 1: Digital In */
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
unsigned int feedback_accumulator_pattern[FEEDBACK_ACCUMULATOR_SIZE];
unsigned int feedback_pattern_out_idx;
unsigned int feedback_pattern_in_idx;
bool feedback_synced;
unsigned int feedback_consecutive_errors;
unsigned int feedback_urb_skip_count;
unsigned int feedback_accumulator_pattern[FEEDBACK_ACCUMULATOR_SIZE];
unsigned int feedback_pattern_out_idx;
unsigned int feedback_pattern_in_idx;
bool feedback_synced;
unsigned int feedback_consecutive_errors;
unsigned int feedback_urb_skip_count;
const unsigned int (*feedback_patterns)[8];
unsigned int feedback_base_value;
unsigned int feedback_max_value;
const unsigned int (*feedback_patterns)[8];
unsigned int feedback_base_value;
unsigned int feedback_max_value;
struct usb_anchor playback_anchor;
struct usb_anchor capture_anchor;
struct usb_anchor feedback_anchor;
struct usb_anchor midi_in_anchor;
struct usb_anchor midi_out_anchor;
struct usb_anchor playback_anchor;
struct usb_anchor capture_anchor;
struct usb_anchor feedback_anchor;
struct usb_anchor midi_in_anchor;
struct usb_anchor midi_out_anchor;
};
/* main */
@ -278,9 +328,9 @@ int tascam_alloc_urbs(struct tascam_card *tascam);
* tascam_stop_work_handler() - Work handler to stop all active streams.
* @work: Pointer to the work_struct.
*
* This function is scheduled to stop all active URBs (playback, feedback, capture)
* and reset the active_urbs counter. It is used to gracefully stop streams
* from a workqueue context.
* This function is scheduled to stop all active URBs (playback, feedback,
* capture) and reset the active_urbs counter. It is used to gracefully stop
* streams from a workqueue context.
*/
void tascam_stop_work_handler(struct work_struct *work);
@ -319,7 +369,8 @@ int tascam_create_midi(struct tascam_card *tascam);
/* us144mkii_controls.c */
/**
* tascam_create_controls() - Creates and adds ALSA mixer controls for the device.
* tascam_create_controls() - Creates and adds ALSA mixer controls for the
* device.
* @tascam: The driver instance.
*
* This function registers custom ALSA controls for managing audio routing

354
us144mkii_capture.c
View File

@ -12,15 +12,14 @@
*
* Return: 0 on success.
*/
static int tascam_capture_open(struct snd_pcm_substream *substream)
{
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
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);
substream->runtime->hw = tascam_pcm_hw;
tascam->capture_substream = substream;
atomic_set(&tascam->capture_active, 0);
return 0;
return 0;
}
/**
@ -32,13 +31,12 @@ static int tascam_capture_open(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_capture_close(struct snd_pcm_substream *substream)
{
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
static int tascam_capture_close(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->capture_substream = NULL;
tascam->capture_substream = NULL;
return 0;
return 0;
}
/**
@ -49,17 +47,16 @@ static int tascam_capture_close(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_capture_prepare(struct snd_pcm_substream *substream)
{
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
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;
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;
return 0;
}
/**
@ -71,21 +68,31 @@ static int tascam_capture_prepare(struct snd_pcm_substream *substream)
*
* Return: The current capture pointer position in frames.
*/
static snd_pcm_uframes_t tascam_capture_pointer(struct snd_pcm_substream *substream)
static snd_pcm_uframes_t
<<<<<<< HEAD
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;
unsigned long flags;
=======
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;
unsigned long flags;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (!atomic_read(&tascam->capture_active))
return 0;
if (!atomic_read(&tascam->capture_active))
return 0;
spin_lock_irqsave(&tascam->lock, flags);
pos = tascam->capture_frames_processed;
spin_unlock_irqrestore(&tascam->lock, flags);
spin_lock_irqsave(&tascam->lock, flags);
pos = tascam->capture_frames_processed;
spin_unlock_irqrestore(&tascam->lock, flags);
return runtime ? pos % runtime->buffer_size : 0;
u64 remainder = do_div(pos, runtime->buffer_size);
return runtime ? remainder : 0;
}
/**
@ -96,14 +103,14 @@ static snd_pcm_uframes_t tascam_capture_pointer(struct snd_pcm_substream *substr
* 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,
.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,
};
/**
@ -115,38 +122,49 @@ const struct snd_pcm_ops tascam_capture_ops = {
* 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;
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);
<<<<<<< HEAD
memset(dst_block, 0,
FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
DECODED_SAMPLE_SIZE);
=======
memset(dst_block, 0,
FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
DECODED_SAMPLE_SIZE);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
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;
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};
<<<<<<< HEAD
s32 ch[4] = {0};
=======
s32 ch[4] = { 0 };
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
for (bit = 0; bit < 24; ++bit) {
u8 byte1 = p_src_frame_base[bit];
u8 byte2 = p_src_frame_base[bit + 32];
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[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);
}
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;
}
/*
* 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;
}
}
/**
@ -158,71 +176,162 @@ 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
* * the CPU-intensive decoding from the time-sensitive URB completion handlers.
*/
<<<<<<< HEAD
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;
unsigned long flags;
u8 *raw_block = tascam->capture_decode_raw_block;
s32 *decoded_block = tascam->capture_decode_dst_block;
s32 *routed_block = tascam->capture_routing_buffer;
=======
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 =
container_of(work, struct tascam_card, capture_work);
struct snd_pcm_substream *substream = tascam->capture_substream;
struct snd_pcm_runtime *runtime;
unsigned long flags;
u8 *raw_block = tascam->capture_decode_raw_block;
s32 *decoded_block = tascam->capture_decode_dst_block;
s32 *routed_block = tascam->capture_routing_buffer;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (!substream || !substream->runtime)
return;
runtime = substream->runtime;
if (!substream || !substream->runtime)
return;
runtime = substream->runtime;
<<<<<<< HEAD
if (!raw_block || !decoded_block || !routed_block) {
dev_err(tascam->card->dev,
"Capture decode/routing buffers not allocated!\n");
return;
}
=======
if (!raw_block || !decoded_block || !routed_block) {
dev_err(tascam->card->dev, "Capture decode/routing buffers not allocated!\n");
dev_err(tascam->card->dev,
"Capture decode/routing buffers not allocated!\n");
return;
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
while (atomic_read(&tascam->capture_active)) {
size_t write_ptr, read_ptr, available_data;
bool can_process;
while (atomic_read(&tascam->capture_active)) {
size_t write_ptr, read_ptr, available_data;
bool can_process;
<<<<<<< HEAD
spin_lock_irqsave(&tascam->lock, flags);
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);
=======
spin_lock_irqsave(&tascam->lock, flags);
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);
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);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (can_process) {
size_t i;
if (can_process) {
size_t i;
<<<<<<< HEAD
for (i = 0; i < RAW_BYTES_PER_DECODE_BLOCK; i++)
raw_block[i] = tascam->capture_ring_buffer[(read_ptr + i) %
CAPTURE_RING_BUFFER_SIZE];
tascam->capture_ring_buffer_read_ptr =
(read_ptr + RAW_BYTES_PER_DECODE_BLOCK) % CAPTURE_RING_BUFFER_SIZE;
}
spin_unlock_irqrestore(&tascam->lock, flags);
=======
for (i = 0; i < RAW_BYTES_PER_DECODE_BLOCK; i++)
raw_block[i] = tascam->capture_ring_buffer[(read_ptr + i) % CAPTURE_RING_BUFFER_SIZE];
tascam->capture_ring_buffer_read_ptr = (read_ptr + RAW_BYTES_PER_DECODE_BLOCK) % CAPTURE_RING_BUFFER_SIZE;
raw_block[i] =
tascam->capture_ring_buffer
[(read_ptr + i) %
CAPTURE_RING_BUFFER_SIZE];
tascam->capture_ring_buffer_read_ptr =
(read_ptr + RAW_BYTES_PER_DECODE_BLOCK) %
CAPTURE_RING_BUFFER_SIZE;
}
spin_unlock_irqrestore(&tascam->lock, flags);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (!can_process)
break;
if (!can_process)
break;
<<<<<<< HEAD
decode_tascam_capture_block(raw_block, decoded_block);
process_capture_routing_us144mkii(tascam, decoded_block, routed_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);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
spin_lock_irqsave(&tascam->lock, flags);
if (atomic_read(&tascam->capture_active)) {
int f;
spin_lock_irqsave(&tascam->lock, flags);
if (atomic_read(&tascam->capture_active)) {
int f;
<<<<<<< HEAD
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;
}
}
spin_unlock_irqrestore(&tascam->lock, flags);
}
=======
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);
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;
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);
memcpy(dst_channel,
((char *)src_channel_s32) + 1,
3);
}
tascam->driver_capture_pos = (tascam->driver_capture_pos + 1) % runtime->buffer_size;
tascam->driver_capture_pos =
(tascam->driver_capture_pos + 1) %
runtime->buffer_size;
}
}
spin_unlock_irqrestore(&tascam->lock, flags);
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
@ -233,45 +342,86 @@ void tascam_capture_work_handler(struct work_struct *work)
* into an intermediate ring buffer and then schedules the workqueue to process
* it. It then resubmits the URB to receive more data.
*/
void capture_urb_complete(struct urb *urb)
{
struct tascam_card *tascam = urb->context;
int ret;
unsigned long flags;
void capture_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
int ret;
unsigned long flags;
<<<<<<< HEAD
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->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);
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;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (urb->actual_length > 0) {
size_t i;
size_t write_ptr;
if (urb->actual_length > 0) {
size_t i;
size_t write_ptr;
<<<<<<< HEAD
spin_lock_irqsave(&tascam->lock, flags);
write_ptr = tascam->capture_ring_buffer_write_ptr;
for (i = 0; i < urb->actual_length; i++) {
tascam->capture_ring_buffer[write_ptr] = ((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);
=======
spin_lock_irqsave(&tascam->lock, flags);
write_ptr = tascam->capture_ring_buffer_write_ptr;
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] =
((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);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
schedule_work(&tascam->capture_work);
}
schedule_work(&tascam->capture_work);
}
<<<<<<< HEAD
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);
}
=======
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);
dev_err_ratelimited(tascam->card->dev,
"Failed to resubmit capture URB: %d\n",
ret);
usb_unanchor_urb(urb);
usb_put_urb(urb);
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
out:
usb_put_urb(urb);
usb_put_urb(urb);
}

435
us144mkii_controls.c
View File

@ -9,7 +9,13 @@
* Used by ALSA kcontrol elements to provide user-friendly names for
* the playback routing options (e.g., "Playback 1-2", "Playback 3-4").
*/
static const char * const playback_source_texts[] = {"Playback 1-2", "Playback 3-4"};
<<<<<<< HEAD
static const char *const playback_source_texts[] = {"Playback 1-2",
"Playback 3-4"};
=======
static const char *const playback_source_texts[] = { "Playback 1-2",
"Playback 3-4" };
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
/**
* @brief Text descriptions for capture input source options.
@ -17,19 +23,38 @@ static const char * const playback_source_texts[] = {"Playback 1-2", "Playback 3
* Used by ALSA kcontrol elements to provide user-friendly names for
* the capture routing options (e.g., "Analog In", "Digital In").
*/
static const char * const capture_source_texts[] = {"Analog In", "Digital In"};
<<<<<<< HEAD
static const char *const capture_source_texts[] = {"Analog In", "Digital In"};
=======
static const char *const capture_source_texts[] = { "Analog In", "Digital In" };
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
/**
* tascam_playback_source_info() - ALSA control info callback for playback source.
* tascam_playback_source_info() - ALSA control info callback for playback
* source.
* @kcontrol: The ALSA kcontrol instance.
* @uinfo: The ALSA control element info structure to fill.
*
* This function provides information about the enumerated playback source
* control, including its type, count, and available items (Playback 1-2, Playback 3-4).
* control, including its type, count, and available items (Playback 1-2,
* Playback 3-4).
*
* Return: 0 on success.
*/
static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
static int tascam_playback_source_info(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
uinfo->value.enumerated.items = 2;
if (uinfo->value.enumerated.item >= 2)
uinfo->value.enumerated.item = 1;
strscpy(uinfo->value.enumerated.name,
playback_source_texts[uinfo->value.enumerated.item],
sizeof(uinfo->value.enumerated.name));
return 0;
=======
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
@ -40,6 +65,7 @@ static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, struct snd
playback_source_texts[uinfo->value.enumerated.item],
sizeof(uinfo->value.enumerated.name));
return 0;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
@ -53,12 +79,18 @@ static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, struct snd
*
* Return: 0 on success.
*/
static int tascam_line_out_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
static int tascam_line_out_get(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
ucontrol->value.enumerated.item[0] = tascam->line_out_source;
return 0;
ucontrol->value.enumerated.item[0] = tascam->line_out_source;
return 0;
}
/**
@ -72,16 +104,22 @@ static int tascam_line_out_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele
*
* 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, struct snd_ctl_elem_value *ucontrol)
static int tascam_line_out_put(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->line_out_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->line_out_source = ucontrol->value.enumerated.item[0];
return 1;
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->line_out_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->line_out_source = ucontrol->value.enumerated.item[0];
return 1;
}
/**
@ -90,15 +128,28 @@ static int tascam_line_out_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele
* 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
* 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 handling.
* information and `tascam_line_out_get`/`tascam_line_out_put` for value
* handling.
*/
static const struct snd_kcontrol_new tascam_line_out_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line OUTPUTS Source",
.info = tascam_playback_source_info, .get = tascam_line_out_get, .put = tascam_line_out_put,
<<<<<<< HEAD
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Line OUTPUTS Source",
.info = tascam_playback_source_info,
.get = tascam_line_out_get,
.put = tascam_line_out_put,
=======
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Line OUTPUTS Source",
.info = tascam_playback_source_info,
.get = tascam_line_out_get,
.put = tascam_line_out_put,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
/**
* tascam_digital_out_get() - ALSA control get callback for Digital Outputs Source.
* tascam_digital_out_get() - ALSA control get callback for Digital Outputs
* Source.
* @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill.
*
@ -108,16 +159,23 @@ static const struct snd_kcontrol_new tascam_line_out_control = {
*
* Return: 0 on success.
*/
static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
static int tascam_digital_out_get(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
ucontrol->value.enumerated.item[0] = tascam->digital_out_source;
return 0;
ucontrol->value.enumerated.item[0] = tascam->digital_out_source;
return 0;
}
/**
* tascam_digital_out_put() - ALSA control put callback for Digital Outputs Source.
* tascam_digital_out_put() - ALSA control put callback for Digital Outputs
* Source.
* @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure containing the new value.
*
@ -127,29 +185,48 @@ static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, struct snd_ctl_
*
* 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, struct snd_ctl_elem_value *ucontrol)
static int tascam_digital_out_put(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->digital_out_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->digital_out_source = ucontrol->value.enumerated.item[0];
return 1;
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->digital_out_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->digital_out_source = ucontrol->value.enumerated.item[0];
return 1;
}
/**
* tascam_digital_out_control - ALSA kcontrol definition for Digital Outputs Source.
* tascam_digital_out_control - ALSA kcontrol definition for Digital Outputs
* Source.
*
* This defines a new ALSA mixer control named "Digital OUTPUTS Source" that allows
* the user to select between "Playback 1-2" and "Playback 3-4" for the digital
* outputs of the device. It uses the `tascam_playback_source_info` for
* information and `tascam_digital_out_get`/`tascam_digital_out_put` for value handling.
* This defines a new ALSA mixer control named "Digital OUTPUTS Source" that
* allows the user to select between "Playback 1-2" and "Playback 3-4" for the
* digital outputs of the device. It uses the `tascam_playback_source_info` for
* information and `tascam_digital_out_get`/`tascam_digital_out_put` for value
* handling.
*/
static const struct snd_kcontrol_new tascam_digital_out_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Digital OUTPUTS Source",
.info = tascam_playback_source_info, .get = tascam_digital_out_get, .put = tascam_digital_out_put,
<<<<<<< HEAD
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Digital OUTPUTS Source",
.info = tascam_playback_source_info,
.get = tascam_digital_out_get,
.put = tascam_digital_out_put,
=======
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Digital OUTPUTS Source",
.info = tascam_playback_source_info,
.get = tascam_digital_out_get,
.put = tascam_digital_out_put,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
/**
@ -158,11 +235,25 @@ static const struct snd_kcontrol_new tascam_digital_out_control = {
* @uinfo: The ALSA control element info structure to fill.
*
* This function provides information about the enumerated capture source
* control, including its type, count, and available items (Analog In, Digital In).
* control, including its type, count, and available items (Analog In, Digital
* In).
*
* Return: 0 on success.
*/
static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
static int tascam_capture_source_info(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
uinfo->value.enumerated.items = 2;
if (uinfo->value.enumerated.item >= 2)
uinfo->value.enumerated.item = 1;
strscpy(uinfo->value.enumerated.name,
capture_source_texts[uinfo->value.enumerated.item],
sizeof(uinfo->value.enumerated.name));
return 0;
=======
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
@ -173,116 +264,171 @@ static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_
capture_source_texts[uinfo->value.enumerated.item],
sizeof(uinfo->value.enumerated.name));
return 0;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
* tascam_capture_12_get() - ALSA control get callback for Capture channels 1 and 2 Source.
* tascam_capture_12_get() - ALSA control get callback for Capture channels 1
* and 2 Source.
* @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill.
*
* This function retrieves the current selection for the Capture channels 1 and 2 source
* (Analog In or Digital In) from the driver's private data and populates
* the ALSA control element value.
* This function retrieves the current selection for the Capture channels 1 and
* 2 source (Analog In or Digital In) from the driver's private data and
* populates the ALSA control element value.
*
* Return: 0 on success.
*/
static int tascam_capture_12_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
static int tascam_capture_12_get(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
ucontrol->value.enumerated.item[0] = tascam->capture_12_source;
return 0;
ucontrol->value.enumerated.item[0] = tascam->capture_12_source;
return 0;
}
/**
* tascam_capture_12_put() - ALSA control put callback for Capture channels 1 and 2 Source.
* tascam_capture_12_put() - ALSA control put callback for Capture channels 1
* and 2 Source.
* @kcontrol: The ALSA kcontrol instance.
* @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 In)
* based on the user's selection from the ALSA control element. It validates
* This function sets the Capture channels 1 and 2 source (Analog In or Digital
* In) based on the user's selection from the ALSA control element. It validates
* the input and updates the driver's private data.
*
* 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, struct snd_ctl_elem_value *ucontrol)
static int tascam_capture_12_put(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->capture_12_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->capture_12_source = ucontrol->value.enumerated.item[0];
return 1;
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->capture_12_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->capture_12_source = ucontrol->value.enumerated.item[0];
return 1;
}
/**
* tascam_capture_12_control - ALSA kcontrol definition for Capture channels 1 and 2 Source.
* tascam_capture_12_control - ALSA kcontrol definition for Capture channels 1
* and 2 Source.
*
* 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
* 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 handling.
* information and `tascam_capture_12_get`/`tascam_capture_12_put` for value
* handling.
*/
static const struct snd_kcontrol_new tascam_capture_12_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "ch1 and ch2 Source",
.info = tascam_capture_source_info, .get = tascam_capture_12_get, .put = tascam_capture_12_put,
<<<<<<< HEAD
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch1 and ch2 Source",
.info = tascam_capture_source_info,
.get = tascam_capture_12_get,
.put = tascam_capture_12_put,
=======
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch1 and ch2 Source",
.info = tascam_capture_source_info,
.get = tascam_capture_12_get,
.put = tascam_capture_12_put,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
/**
* tascam_capture_34_get() - ALSA control get callback for Capture channels 3 and 4 Source.
* tascam_capture_34_get() - ALSA control get callback for Capture channels 3
* and 4 Source.
* @kcontrol: The ALSA kcontrol instance.
* @ucontrol: The ALSA control element value structure to fill.
*
* This function retrieves the current selection for the Capture channels 3 and 4 source
* (Analog In or Digital In) from the driver's private data and populates
* the ALSA control element value.
* This function retrieves the current selection for the Capture channels 3 and
* 4 source (Analog In or Digital In) from the driver's private data and
* populates the ALSA control element value.
*
* Return: 0 on success.
*/
static int tascam_capture_34_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
static int tascam_capture_34_get(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
ucontrol->value.enumerated.item[0] = tascam->capture_34_source;
return 0;
ucontrol->value.enumerated.item[0] = tascam->capture_34_source;
return 0;
}
/**
* tascam_capture_34_put() - ALSA control put callback for Capture channels 3 and 4 Source.
* tascam_capture_34_put() - ALSA control put callback for Capture channels 3
* and 4 Source.
* @kcontrol: The ALSA kcontrol instance.
* @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 In)
* based on the user's selection from the ALSA control element. It validates
* This function sets the Capture channels 3 and 4 source (Analog In or Digital
* In) based on the user's selection from the ALSA control element. It validates
* the input and updates the driver's private data.
*
* 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, struct snd_ctl_elem_value *ucontrol)
static int tascam_capture_34_put(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->capture_34_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->capture_34_source = ucontrol->value.enumerated.item[0];
return 1;
if (ucontrol->value.enumerated.item[0] > 1)
return -EINVAL;
if (tascam->capture_34_source == ucontrol->value.enumerated.item[0])
return 0;
tascam->capture_34_source = ucontrol->value.enumerated.item[0];
return 1;
}
/**
* tascam_capture_34_control - ALSA kcontrol definition for Capture channels 3 and 4 Source.
* tascam_capture_34_control - ALSA kcontrol definition for Capture channels 3
* and 4 Source.
*
* 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 fourth
* capture channels of the device. It uses the `tascam_capture_source_info` for
* information and `tascam_capture_34_get`/`tascam_capture_34_put` for value handling.
* the user to select between "Analog In" and "Digital In" for the third and
* fourth capture channels of the device. It uses the
* `tascam_capture_source_info` for information and
* `tascam_capture_34_get`/`tascam_capture_34_put` for value handling.
*/
static const struct snd_kcontrol_new tascam_capture_34_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "ch3 and ch4 Source",
.info = tascam_capture_source_info, .get = tascam_capture_34_get, .put = tascam_capture_34_put,
<<<<<<< HEAD
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch3 and ch4 Source",
.info = tascam_capture_source_info,
.get = tascam_capture_34_get,
.put = tascam_capture_34_put,
=======
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "ch3 and ch4 Source",
.info = tascam_capture_source_info,
.get = tascam_capture_34_get,
.put = tascam_capture_34_put,
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
};
/**
@ -295,13 +441,23 @@ static const struct snd_kcontrol_new tascam_capture_34_control = {
*
* Return: 0 on success.
*/
static int tascam_samplerate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
static int tascam_samplerate_info(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 96000;
return 0;
=======
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 96000;
return 0;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
@ -311,37 +467,55 @@ static int tascam_samplerate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_
*
* 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
* is already known (i.e., `current_rate` is set), it returns that value directly.
* is already known (i.e., `current_rate` is set), it returns that value
* directly.
*
* Return: 0 on success, or a negative error code on failure.
*/
static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
static int tascam_samplerate_get(struct snd_kcontrol *kcontrol,
<<<<<<< HEAD
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam =
(struct tascam_card *)snd_kcontrol_chip(kcontrol);
u8 *buf;
int err;
u32 rate = 0;
=======
struct snd_ctl_elem_value *ucontrol)
{
struct tascam_card *tascam = (struct tascam_card *)snd_kcontrol_chip(kcontrol);
struct tascam_card *tascam =
(struct tascam_card *)snd_kcontrol_chip(kcontrol);
u8 *buf;
int err;
u32 rate = 0;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (tascam->current_rate > 0) {
ucontrol->value.integer.value[0] = tascam->current_rate;
return 0;
}
if (tascam->current_rate > 0) {
ucontrol->value.integer.value[0] = tascam->current_rate;
return 0;
}
buf = kmalloc(3, GFP_KERNEL);
if (!buf)
return -ENOMEM;
buf = kmalloc(3, GFP_KERNEL);
if (!buf)
return -ENOMEM;
<<<<<<< HEAD
err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0),
UAC_GET_CUR, RT_D2H_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL,
EP_AUDIO_IN, buf, 3, USB_CTRL_TIMEOUT_MS);
=======
err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0),
UAC_GET_CUR, RT_D2H_CLASS_EP,
UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN,
buf, 3, USB_CTRL_TIMEOUT_MS);
UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, buf, 3,
USB_CTRL_TIMEOUT_MS);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (err >= 3)
rate = buf[0] | (buf[1] << 8) | (buf[2] << 16);
if (err >= 3)
rate = buf[0] | (buf[1] << 8) | (buf[2] << 16);
ucontrol->value.integer.value[0] = rate;
kfree(buf);
return 0;
ucontrol->value.integer.value[0] = rate;
kfree(buf);
return 0;
}
/**
@ -351,15 +525,16 @@ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
* the current sample rate of the device. It is a read-only control.
*/
static const struct snd_kcontrol_new tascam_samplerate_control = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Sample Rate",
.info = tascam_samplerate_info,
.get = tascam_samplerate_get,
.access = SNDRV_CTL_ELEM_ACCESS_READ,
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Sample Rate",
.info = tascam_samplerate_info,
.get = tascam_samplerate_get,
.access = SNDRV_CTL_ELEM_ACCESS_READ,
};
/**
* tascam_create_controls() - Creates and adds ALSA mixer controls for the device.
* tascam_create_controls() - Creates and adds ALSA mixer controls for the
* device.
* @tascam: The driver instance.
*
* This function registers custom ALSA controls for managing audio routing
@ -368,26 +543,54 @@ static const struct snd_kcontrol_new tascam_samplerate_control = {
*
* Return: 0 on success, or a negative error code on failure.
*/
int tascam_create_controls(struct tascam_card *tascam)
{
int err;
int tascam_create_controls(struct tascam_card *tascam) {
int err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_line_out_control, tascam));
<<<<<<< HEAD
err =
snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_line_out_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_digital_out_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_12_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_34_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_samplerate_control, tascam));
if (err < 0)
return err;
=======
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_line_out_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_digital_out_control, tascam));
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_digital_out_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_capture_12_control, tascam));
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_12_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_capture_34_control, tascam));
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_capture_34_control, tascam));
if (err < 0)
return err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_samplerate_control, tascam));
err = snd_ctl_add(tascam->card,
snd_ctl_new1(&tascam_samplerate_control, tascam));
if (err < 0)
return err;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
return 0;
return 0;
}

469
us144mkii_midi.c
View File

@ -11,39 +11,68 @@
* the kfifo, processes it by stripping protocol-specific padding bytes, and
* passes the clean MIDI data to the ALSA rawmidi subsystem.
*/
<<<<<<< HEAD
static void tascam_midi_in_work_handler(struct work_struct *work) {
struct tascam_card *tascam =
container_of(work, struct tascam_card, midi_in_work);
u8 buf[MIDI_IN_BUF_SIZE];
unsigned int len;
int i;
=======
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 =
container_of(work, struct tascam_card, midi_in_work);
u8 buf[MIDI_IN_BUF_SIZE];
unsigned int len;
int i;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (!tascam->midi_in_substream)
return;
if (!tascam->midi_in_substream)
return;
<<<<<<< HEAD
while (!kfifo_is_empty(&tascam->midi_in_fifo)) {
len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf, sizeof(buf),
&tascam->midi_in_lock);
=======
while (!kfifo_is_empty(&tascam->midi_in_fifo)) {
len = kfifo_out_spinlocked(&tascam->midi_in_fifo,
buf, sizeof(buf), &tascam->midi_in_lock);
len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf,
sizeof(buf), &tascam->midi_in_lock);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (len == 0)
continue;
if (len == 0)
continue;
if (!tascam->midi_in_substream)
continue;
if (!tascam->midi_in_substream)
continue;
for (i = 0; i < len; ++i) {
/* Skip padding bytes */
if (buf[i] == 0xfd)
continue;
for (i = 0; i < len; ++i) {
/* Skip padding bytes */
if (buf[i] == 0xfd)
continue;
<<<<<<< HEAD
/* The last byte is often a terminator (0x00, 0xFF). Ignore it. */
if (i == (len - 1) && (buf[i] == 0x00 || buf[i] == 0xff))
continue;
/* Submit valid MIDI bytes one by one */
snd_rawmidi_receive(tascam->midi_in_substream, &buf[i], 1);
}
}
=======
/* 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) &&
(buf[i] == 0x00 || buf[i] == 0xff))
continue;
/* 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);
}
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
@ -54,39 +83,45 @@ 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,
* ensuring the interrupt handler remains fast.
*/
void tascam_midi_in_urb_complete(struct urb *urb)
{
struct tascam_card *tascam = urb->context;
int ret;
void tascam_midi_in_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 != -EPROTO)
dev_err_ratelimited(tascam->card->dev,
"MIDI IN URB failed: status %d\n",
urb->status);
goto out;
}
if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN && urb->status != -EPROTO)
dev_err_ratelimited(tascam->card->dev, "MIDI IN URB failed: status %d\n",
urb->status);
goto out;
}
if (tascam && atomic_read(&tascam->midi_in_active) && urb->actual_length > 0) {
kfifo_in_spinlocked(&tascam->midi_in_fifo,
urb->transfer_buffer,
urb->actual_length,
&tascam->midi_in_lock);
<<<<<<< HEAD
if (tascam && atomic_read(&tascam->midi_in_active) &&
urb->actual_length > 0) {
kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer,
urb->actual_length, &tascam->midi_in_lock);
schedule_work(&tascam->midi_in_work);
}
=======
if (tascam && atomic_read(&tascam->midi_in_active) &&
urb->actual_length > 0) {
kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer,
urb->actual_length, &tascam->midi_in_lock);
schedule_work(&tascam->midi_in_work);
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_in_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) {
dev_err(tascam->card->dev,
"Failed to resubmit MIDI IN URB: error %d\n", ret);
usb_unanchor_urb(urb);
usb_put_urb(urb);
}
usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_in_anchor);
ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret < 0) {
dev_err(tascam->card->dev, "Failed to resubmit MIDI IN URB: error %d\n",
ret);
usb_unanchor_urb(urb);
usb_put_urb(urb);
}
out:
usb_put_urb(urb);
usb_put_urb(urb);
}
/**
@ -98,12 +133,11 @@ out:
*
* Return: 0 on success.
*/
static int tascam_midi_in_open(struct snd_rawmidi_substream *substream)
{
struct tascam_card *tascam = substream->rmidi->private_data;
static int tascam_midi_in_open(struct snd_rawmidi_substream *substream) {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_in_substream = substream;
return 0;
tascam->midi_in_substream = substream;
return 0;
}
/**
@ -112,9 +146,8 @@ static int tascam_midi_in_open(struct snd_rawmidi_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_midi_in_close(struct snd_rawmidi_substream *substream)
{
return 0;
static int tascam_midi_in_close(struct snd_rawmidi_substream *substream) {
return 0;
}
/**
@ -122,30 +155,63 @@ static int tascam_midi_in_close(struct snd_rawmidi_substream *substream)
* @substream: The ALSA rawmidi substream.
* @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' parameter.
* When starting, it resets the kfifo and submits all MIDI input URBs.
* When stopping, it kills all anchored MIDI input URBs and cancels the
* This function starts or stops the MIDI input URBs based on the 'up'
* parameter. When starting, it resets the kfifo and submits all MIDI input
* URBs. When stopping, it kills all anchored MIDI input URBs and cancels the
* associated workqueue.
*/
static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int up)
static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream,
<<<<<<< HEAD
int up) {
struct tascam_card *tascam = substream->rmidi->private_data;
int i, err;
unsigned long flags;
=======
int up)
{
struct tascam_card *tascam = substream->rmidi->private_data;
int i, err;
unsigned long flags;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (up) {
if (atomic_xchg(&tascam->midi_in_active, 1) == 0) {
spin_lock_irqsave(&tascam->midi_in_lock, flags);
kfifo_reset(&tascam->midi_in_fifo);
spin_unlock_irqrestore(&tascam->midi_in_lock, flags);
if (up) {
if (atomic_xchg(&tascam->midi_in_active, 1) == 0) {
spin_lock_irqsave(&tascam->midi_in_lock, flags);
kfifo_reset(&tascam->midi_in_fifo);
spin_unlock_irqrestore(&tascam->midi_in_lock, flags);
<<<<<<< HEAD
for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
usb_get_urb(tascam->midi_in_urbs[i]);
usb_anchor_urb(tascam->midi_in_urbs[i], &tascam->midi_in_anchor);
err = usb_submit_urb(tascam->midi_in_urbs[i], GFP_KERNEL);
if (err < 0) {
dev_err(tascam->card->dev, "Failed to submit MIDI IN URB %d: %d\n", i,
err);
usb_unanchor_urb(tascam->midi_in_urbs[i]);
usb_put_urb(tascam->midi_in_urbs[i]);
}
}
}
} 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);
}
}
=======
for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
usb_get_urb(tascam->midi_in_urbs[i]);
usb_anchor_urb(tascam->midi_in_urbs[i], &tascam->midi_in_anchor);
err = usb_submit_urb(tascam->midi_in_urbs[i], GFP_KERNEL);
usb_anchor_urb(tascam->midi_in_urbs[i],
&tascam->midi_in_anchor);
err = usb_submit_urb(tascam->midi_in_urbs[i],
GFP_KERNEL);
if (err < 0) {
dev_err(tascam->card->dev, "Failed to submit MIDI IN URB %d: %d\n", i, err);
usb_unanchor_urb(tascam->midi_in_urbs[i]);
dev_err(tascam->card->dev,
"Failed to submit MIDI IN URB %d: %d\n",
i, err);
usb_unanchor_urb(
tascam->midi_in_urbs[i]);
usb_put_urb(tascam->midi_in_urbs[i]);
}
}
@ -156,18 +222,19 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int
cancel_work_sync(&tascam->midi_in_work);
}
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
* tascam_midi_in_ops - ALSA rawmidi operations for MIDI input.
*
* This structure defines the callback functions for MIDI input stream operations,
* including open, close, and trigger.
* This structure defines the callback functions for MIDI input stream
* operations, including open, close, and trigger.
*/
static const struct snd_rawmidi_ops tascam_midi_in_ops = {
.open = tascam_midi_in_open,
.close = tascam_midi_in_close,
.trigger = tascam_midi_in_trigger,
.open = tascam_midi_in_open,
.close = tascam_midi_in_close,
.trigger = tascam_midi_in_trigger,
};
/**
@ -179,40 +246,59 @@ 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
* way to continue the data transmission chain.
*/
void tascam_midi_out_urb_complete(struct urb *urb)
{
struct tascam_card *tascam = urb->context;
unsigned long flags;
int i, urb_index = -1;
void tascam_midi_out_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
unsigned long flags;
int i, urb_index = -1;
<<<<<<< HEAD
if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN)
dev_err_ratelimited(tascam->card->dev, "MIDI OUT URB failed: %d\n",
urb->status);
}
=======
if (urb->status) {
if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN)
dev_err_ratelimited(tascam->card->dev, "MIDI OUT URB failed: %d\n", urb->status);
if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
urb->status != -ESHUTDOWN)
dev_err_ratelimited(tascam->card->dev,
"MIDI OUT URB failed: %d\n",
urb->status);
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (!tascam)
goto out;
if (!tascam)
goto out;
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (tascam->midi_out_urbs[i] == urb) {
urb_index = i;
break;
}
}
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (tascam->midi_out_urbs[i] == urb) {
urb_index = i;
break;
}
}
<<<<<<< HEAD
if (urb_index < 0) {
dev_err_ratelimited(tascam->card->dev, "Unknown MIDI OUT URB completed!\n");
goto out;
}
=======
if (urb_index < 0) {
dev_err_ratelimited(tascam->card->dev, "Unknown MIDI OUT URB completed!\n");
dev_err_ratelimited(tascam->card->dev,
"Unknown MIDI OUT URB completed!\n");
goto out;
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
spin_lock_irqsave(&tascam->midi_out_lock, flags);
clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
spin_lock_irqsave(&tascam->midi_out_lock, flags);
clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
if (atomic_read(&tascam->midi_out_active))
schedule_work(&tascam->midi_out_work);
if (atomic_read(&tascam->midi_out_active))
schedule_work(&tascam->midi_out_work);
out:
usb_put_urb(urb);
usb_put_urb(urb);
}
/**
@ -225,73 +311,87 @@ out:
* This function pulls as many bytes as will fit into one packet from the
* ALSA buffer and sends them.
*/
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 snd_rawmidi_substream *substream = tascam->midi_out_substream;
int i;
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 snd_rawmidi_substream *substream = tascam->midi_out_substream;
int i;
if (!substream || !atomic_read(&tascam->midi_out_active))
return;
if (!substream || !atomic_read(&tascam->midi_out_active))
return;
while (snd_rawmidi_transmit_peek(substream, (u8[]){ 0 }, 1) == 1) {
unsigned long flags;
int urb_index;
struct urb *urb;
u8 *buf;
int bytes_to_send;
while (snd_rawmidi_transmit_peek(substream, (u8[]){0}, 1) == 1) {
unsigned long flags;
int urb_index;
struct urb *urb;
u8 *buf;
int bytes_to_send;
spin_lock_irqsave(&tascam->midi_out_lock, flags);
spin_lock_irqsave(&tascam->midi_out_lock, flags);
urb_index = -1;
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (!test_bit(i, &tascam->midi_out_urbs_in_flight)) {
urb_index = i;
break;
}
}
urb_index = -1;
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (!test_bit(i, &tascam->midi_out_urbs_in_flight)) {
urb_index = i;
break;
}
}
if (urb_index < 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
return; /* No free URBs, will be rescheduled by completion handler */
}
if (urb_index < 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
return; /* No free URBs, will be rescheduled by completion handler */
}
urb = tascam->midi_out_urbs[urb_index];
buf = urb->transfer_buffer;
bytes_to_send = snd_rawmidi_transmit(substream, buf, 8);
urb = tascam->midi_out_urbs[urb_index];
buf = urb->transfer_buffer;
bytes_to_send = snd_rawmidi_transmit(substream, buf, 8);
if (bytes_to_send <= 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
break; /* No more data */
}
if (bytes_to_send <= 0) {
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
break; /* No more data */
}
if (bytes_to_send < 9)
memset(buf + bytes_to_send, 0xfd, 9 - bytes_to_send);
buf[8] = 0x00;
if (bytes_to_send < 9)
memset(buf + bytes_to_send, 0xfd, 9 - bytes_to_send);
buf[8] = 0x00;
set_bit(urb_index, &tascam->midi_out_urbs_in_flight);
urb->transfer_buffer_length = 9;
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
set_bit(urb_index, &tascam->midi_out_urbs_in_flight);
urb->transfer_buffer_length = 9;
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
<<<<<<< HEAD
usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_out_anchor);
if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
dev_err_ratelimited(tascam->card->dev,
"Failed to submit MIDI OUT URB %d\n", urb_index);
spin_lock_irqsave(&tascam->midi_out_lock, flags);
clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
spin_unlock_irqrestore(&tascam->midi_out_lock, flags);
usb_unanchor_urb(urb);
usb_put_urb(urb);
break; /* Stop on error */
}
}
=======
usb_get_urb(urb);
usb_anchor_urb(urb, &tascam->midi_out_anchor);
if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
dev_err_ratelimited(
tascam->card->dev,
"Failed to submit MIDI OUT URB %d\n", urb_index);
"Failed to submit MIDI OUT URB %d\n",
urb_index);
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);
usb_unanchor_urb(urb);
usb_put_urb(urb);
break; /* Stop on error */
}
}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
}
/**
* tascam_midi_out_open() - Opens the MIDI output substream.
* @substream: The ALSA rawmidi substream to open.
@ -301,14 +401,13 @@ static void tascam_midi_out_work_handler(struct work_struct *work)
*
* Return: 0 on success.
*/
static int tascam_midi_out_open(struct snd_rawmidi_substream *substream)
{
struct tascam_card *tascam = substream->rmidi->private_data;
static int tascam_midi_out_open(struct snd_rawmidi_substream *substream) {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_out_substream = substream;
/* Initialize the running status state for the packet packer. */
tascam->midi_running_status = 0;
return 0;
tascam->midi_out_substream = substream;
/* Initialize the running status state for the packet packer. */
tascam->midi_running_status = 0;
return 0;
}
/**
@ -317,9 +416,8 @@ static int tascam_midi_out_open(struct snd_rawmidi_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_midi_out_close(struct snd_rawmidi_substream *substream)
{
return 0;
static int tascam_midi_out_close(struct snd_rawmidi_substream *substream) {
return 0;
}
/**
@ -329,12 +427,11 @@ static int tascam_midi_out_close(struct snd_rawmidi_substream *substream)
* This function cancels any pending MIDI output work and kills all
* anchored MIDI output URBs, ensuring all data is sent or discarded.
*/
static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream)
{
struct tascam_card *tascam = substream->rmidi->private_data;
static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream) {
struct tascam_card *tascam = substream->rmidi->private_data;
cancel_work_sync(&tascam->midi_out_work);
usb_kill_anchored_urbs(&tascam->midi_out_anchor);
cancel_work_sync(&tascam->midi_out_work);
usb_kill_anchored_urbs(&tascam->midi_out_anchor);
}
/**
@ -345,29 +442,35 @@ static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream)
* This function starts or stops the MIDI output workqueue based on the
* 'up' parameter.
*/
static void tascam_midi_out_trigger(struct snd_rawmidi_substream *substream, int up)
static void tascam_midi_out_trigger(struct snd_rawmidi_substream *substream,
<<<<<<< HEAD
int up) {
struct tascam_card *tascam = substream->rmidi->private_data;
=======
int up)
{
struct tascam_card *tascam = substream->rmidi->private_data;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
if (up) {
atomic_set(&tascam->midi_out_active, 1);
schedule_work(&tascam->midi_out_work);
} else {
atomic_set(&tascam->midi_out_active, 0);
}
if (up) {
atomic_set(&tascam->midi_out_active, 1);
schedule_work(&tascam->midi_out_work);
} else {
atomic_set(&tascam->midi_out_active, 0);
}
}
/**
* tascam_midi_out_ops - ALSA rawmidi operations for MIDI output.
*
* This structure defines the callback functions for MIDI output stream operations,
* including open, close, trigger, and drain.
* This structure defines the callback functions for MIDI output stream
* operations, including open, close, trigger, and drain.
*/
static const struct snd_rawmidi_ops tascam_midi_out_ops = {
.open = tascam_midi_out_open,
.close = tascam_midi_out_close,
.trigger = tascam_midi_out_trigger,
.drain = tascam_midi_out_drain,
.open = tascam_midi_out_open,
.close = tascam_midi_out_close,
.trigger = tascam_midi_out_trigger,
.drain = tascam_midi_out_drain,
};
/**
@ -376,26 +479,44 @@ static const struct snd_rawmidi_ops tascam_midi_out_ops = {
*
* Return: 0 on success, or a negative error code on failure.
*/
int tascam_create_midi(struct tascam_card *tascam)
{
int err;
int tascam_create_midi(struct tascam_card *tascam) {
int err;
err = snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1, &tascam->rmidi);
<<<<<<< HEAD
err =
snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1, &tascam->rmidi);
if (err < 0)
return err;
strscpy(tascam->rmidi->name, "US144MKII MIDI", sizeof(tascam->rmidi->name));
tascam->rmidi->private_data = tascam;
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
&tascam_midi_in_ops);
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
&tascam_midi_out_ops);
=======
err = snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1,
&tascam->rmidi);
if (err < 0)
return err;
strscpy(tascam->rmidi->name, "US144MKII MIDI", sizeof(tascam->rmidi->name));
strscpy(tascam->rmidi->name, "US144MKII MIDI",
sizeof(tascam->rmidi->name));
tascam->rmidi->private_data = tascam;
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &tascam_midi_in_ops);
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &tascam_midi_out_ops);
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
&tascam_midi_in_ops);
snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
&tascam_midi_out_ops);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT |
SNDRV_RAWMIDI_INFO_OUTPUT |
SNDRV_RAWMIDI_INFO_DUPLEX;
tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT |
SNDRV_RAWMIDI_INFO_OUTPUT |
SNDRV_RAWMIDI_INFO_DUPLEX;
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_in_work, tascam_midi_in_work_handler);
INIT_WORK(&tascam->midi_out_work, tascam_midi_out_work_handler);
return 0;
return 0;
}

616
us144mkii_pcm.c
View File

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

28
us144mkii_pcm.h
View File

@ -96,7 +96,14 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate);
* @dst_buffer: Buffer to be filled for the USB device.
* @frames: Number of frames to process.
*/
void process_playback_routing_us144mkii(struct tascam_card *tascam, const u8 *src_buffer, u8 *dst_buffer, size_t frames);
void process_playback_routing_us144mkii(struct tascam_card *tascam,
<<<<<<< HEAD
const u8 *src_buffer, u8 *dst_buffer,
size_t frames);
=======
const u8 *src_buffer, u8 *dst_buffer,
size_t frames);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
/**
* process_capture_routing_us144mkii() - Apply capture routing matrix
@ -104,7 +111,14 @@ void process_playback_routing_us144mkii(struct tascam_card *tascam, const u8 *sr
* @decoded_block: Buffer containing 4 channels of S32LE decoded audio.
* @routed_block: Buffer to be filled for ALSA.
*/
void process_capture_routing_us144mkii(struct tascam_card *tascam, const s32 *decoded_block, s32 *routed_block);
void process_capture_routing_us144mkii(struct tascam_card *tascam,
<<<<<<< HEAD
const s32 *decoded_block,
s32 *routed_block);
=======
const s32 *decoded_block,
s32 *routed_block);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
/**
* tascam_pcm_hw_params() - Configures hardware parameters for PCM streams.
@ -118,7 +132,12 @@ void process_capture_routing_us144mkii(struct tascam_card *tascam, const s32 *de
*
* Return: 0 on success, or a negative error code on failure.
*/
int tascam_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
int tascam_pcm_hw_params(struct snd_pcm_substream *substream,
<<<<<<< HEAD
struct snd_pcm_hw_params *params);
=======
struct snd_pcm_hw_params *params);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
/**
* tascam_pcm_hw_free() - Frees hardware parameters for PCM streams.
@ -133,7 +152,8 @@ int tascam_pcm_hw_free(struct snd_pcm_substream *substream);
/**
* tascam_pcm_trigger() - Triggers the start or stop of PCM streams.
* @substream: The ALSA PCM substream.
* @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START, SNDRV_PCM_TRIGGER_STOP).
* @cmd: The trigger command (e.g., SNDRV_PCM_TRIGGER_START,
* SNDRV_PCM_TRIGGER_STOP).
*
* This function handles starting and stopping of playback and capture streams
* by submitting or killing the associated URBs. It ensures that both streams

593
us144mkii_playback.c
View File

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