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

GUI fixes

This commit is contained in:
serifpersia 2025-08-05 18:32:06 +02:00 committed by Šerif Rami
parent 1f8b9c3fd9
commit 81c133fb52
12 changed files with 1723 additions and 1672 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

19
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) {
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 (long_name) free(long_name);
}
if (!found_match_and_freed) {
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;
}

146
us144mkii.c
View File

@ -16,8 +16,8 @@ MODULE_LICENSE("GPL");
* These parameters allow users to configure how the ALSA sound card
* for the TASCAM US-144MKII is instantiated.
*
* @param index: Array of integers specifying the ALSA card index for each device.
* Defaults to -1 (automatic).
* @param index: Array of integers specifying the ALSA card index for each
* device. Defaults to -1 (automatic).
* @param id: Array of strings specifying the ALSA card ID for each device.
* Defaults to "US144MKII".
* @param enable: Array of booleans to enable or disable each device.
@ -50,8 +50,7 @@ static int tascam_resume(struct usb_interface *intf);
* Return: The number of bytes written to the buffer.
*/
static ssize_t driver_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct device_attribute *attr, char *buf) {
return sysfs_emit(buf, "%s\n", DRIVER_VERSION);
}
static DEVICE_ATTR_RO(driver_version);
@ -64,15 +63,13 @@ static DEVICE_ATTR_RO(driver_version);
* capture, and MIDI URBs, along with their transfer buffers and the
* capture ring/decode buffers.
*/
void tascam_free_urbs(struct tascam_card *tascam)
{
void tascam_free_urbs(struct tascam_card *tascam) {
int i;
usb_kill_anchored_urbs(&tascam->playback_anchor);
for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
if (tascam->playback_urbs[i]) {
usb_free_coherent(
tascam->dev, tascam->playback_urb_alloc_size,
usb_free_coherent(tascam->dev, tascam->playback_urb_alloc_size,
tascam->playback_urbs[i]->transfer_buffer,
tascam->playback_urbs[i]->transfer_dma);
usb_free_urb(tascam->playback_urbs[i]);
@ -83,8 +80,7 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->feedback_anchor);
for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
if (tascam->feedback_urbs[i]) {
usb_free_coherent(
tascam->dev, tascam->feedback_urb_alloc_size,
usb_free_coherent(tascam->dev, tascam->feedback_urb_alloc_size,
tascam->feedback_urbs[i]->transfer_buffer,
tascam->feedback_urbs[i]->transfer_dma);
usb_free_urb(tascam->feedback_urbs[i]);
@ -95,8 +91,7 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->capture_anchor);
for (i = 0; i < NUM_CAPTURE_URBS; i++) {
if (tascam->capture_urbs[i]) {
usb_free_coherent(
tascam->dev, tascam->capture_urb_alloc_size,
usb_free_coherent(tascam->dev, tascam->capture_urb_alloc_size,
tascam->capture_urbs[i]->transfer_buffer,
tascam->capture_urbs[i]->transfer_dma);
usb_free_urb(tascam->capture_urbs[i]);
@ -107,8 +102,7 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->midi_in_anchor);
for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
if (tascam->midi_in_urbs[i]) {
usb_free_coherent(
tascam->dev, MIDI_IN_BUF_SIZE,
usb_free_coherent(tascam->dev, MIDI_IN_BUF_SIZE,
tascam->midi_in_urbs[i]->transfer_buffer,
tascam->midi_in_urbs[i]->transfer_dma);
usb_free_urb(tascam->midi_in_urbs[i]);
@ -119,8 +113,7 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->midi_out_anchor);
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (tascam->midi_out_urbs[i]) {
usb_free_coherent(
tascam->dev, MIDI_OUT_BUF_SIZE,
usb_free_coherent(tascam->dev, MIDI_OUT_BUF_SIZE,
tascam->midi_out_urbs[i]->transfer_buffer,
tascam->midi_out_urbs[i]->transfer_dma);
usb_free_urb(tascam->midi_out_urbs[i]);
@ -149,25 +142,22 @@ void tascam_free_urbs(struct tascam_card *tascam)
*
* Return: 0 on success, or a negative error code on failure.
*/
int tascam_alloc_urbs(struct tascam_card *tascam)
{
int tascam_alloc_urbs(struct tascam_card *tascam) {
int i;
size_t max_packet_size;
max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME;
tascam->playback_urb_alloc_size =
max_packet_size * PLAYBACK_URB_PACKETS;
tascam->playback_urb_alloc_size = max_packet_size * PLAYBACK_URB_PACKETS;
for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
struct urb *urb =
usb_alloc_urb(PLAYBACK_URB_PACKETS, GFP_KERNEL);
struct urb *urb = usb_alloc_urb(PLAYBACK_URB_PACKETS, GFP_KERNEL);
if (!urb)
goto error;
tascam->playback_urbs[i] = urb;
urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, tascam->playback_urb_alloc_size,
urb->transfer_buffer =
usb_alloc_coherent(tascam->dev, tascam->playback_urb_alloc_size,
GFP_KERNEL, &urb->transfer_dma);
if (!urb->transfer_buffer)
goto error;
@ -180,26 +170,23 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
urb->complete = playback_urb_complete;
}
tascam->feedback_urb_alloc_size =
FEEDBACK_PACKET_SIZE * MAX_FEEDBACK_PACKETS;
tascam->feedback_urb_alloc_size = FEEDBACK_PACKET_SIZE * MAX_FEEDBACK_PACKETS;
for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
struct urb *f_urb =
usb_alloc_urb(MAX_FEEDBACK_PACKETS, GFP_KERNEL);
struct urb *f_urb = usb_alloc_urb(MAX_FEEDBACK_PACKETS, GFP_KERNEL);
if (!f_urb)
goto error;
tascam->feedback_urbs[i] = f_urb;
f_urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, tascam->feedback_urb_alloc_size,
f_urb->transfer_buffer =
usb_alloc_coherent(tascam->dev, tascam->feedback_urb_alloc_size,
GFP_KERNEL, &f_urb->transfer_dma);
if (!f_urb->transfer_buffer)
goto error;
f_urb->dev = tascam->dev;
f_urb->pipe =
usb_rcvisocpipe(tascam->dev, EP_PLAYBACK_FEEDBACK);
f_urb->pipe = usb_rcvisocpipe(tascam->dev, EP_PLAYBACK_FEEDBACK);
f_urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
f_urb->interval = 4;
f_urb->context = tascam;
@ -214,16 +201,15 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
goto error;
tascam->capture_urbs[i] = c_urb;
c_urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, tascam->capture_urb_alloc_size, GFP_KERNEL,
&c_urb->transfer_dma);
c_urb->transfer_buffer =
usb_alloc_coherent(tascam->dev, tascam->capture_urb_alloc_size,
GFP_KERNEL, &c_urb->transfer_dma);
if (!c_urb->transfer_buffer)
goto error;
usb_fill_bulk_urb(c_urb, tascam->dev,
usb_rcvbulkpipe(tascam->dev, EP_AUDIO_IN),
c_urb->transfer_buffer,
tascam->capture_urb_alloc_size,
c_urb->transfer_buffer, tascam->capture_urb_alloc_size,
capture_urb_complete, tascam);
c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
}
@ -235,9 +221,8 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
if (!m_urb)
goto error;
tascam->midi_in_urbs[i] = m_urb;
m_urb->transfer_buffer =
usb_alloc_coherent(tascam->dev, MIDI_IN_BUF_SIZE,
GFP_KERNEL, &m_urb->transfer_dma);
m_urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, MIDI_IN_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma);
if (!m_urb->transfer_buffer)
goto error;
usb_fill_bulk_urb(m_urb, tascam->dev,
@ -253,21 +238,18 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
if (!m_urb)
goto error;
tascam->midi_out_urbs[i] = m_urb;
m_urb->transfer_buffer =
usb_alloc_coherent(tascam->dev, MIDI_OUT_BUF_SIZE,
GFP_KERNEL, &m_urb->transfer_dma);
m_urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, MIDI_OUT_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma);
if (!m_urb->transfer_buffer)
goto error;
usb_fill_bulk_urb(m_urb, tascam->dev,
usb_sndbulkpipe(tascam->dev, EP_MIDI_OUT),
m_urb->transfer_buffer,
0, /* length set later */
m_urb->transfer_buffer, 0, /* length set later */
tascam_midi_out_urb_complete, tascam);
m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
}
tascam->capture_ring_buffer =
kmalloc(CAPTURE_RING_BUFFER_SIZE, GFP_KERNEL);
tascam->capture_ring_buffer = kmalloc(CAPTURE_RING_BUFFER_SIZE, GFP_KERNEL);
if (!tascam->capture_ring_buffer)
goto error;
@ -303,8 +285,7 @@ error:
return -ENOMEM;
}
void tascam_stop_work_handler(struct work_struct *work)
{
void tascam_stop_work_handler(struct work_struct *work) {
struct tascam_card *tascam =
container_of(work, struct tascam_card, stop_work);
@ -316,15 +297,15 @@ void tascam_stop_work_handler(struct work_struct *work)
}
/**
* tascam_card_private_free() - Frees private data associated with the sound card.
* tascam_card_private_free() - Frees private data associated with the sound
* card.
* @card: Pointer to the ALSA sound card instance.
*
* This function is called when the sound card is being freed. It releases
* resources allocated for the tascam_card structure, including the MIDI
* input FIFO and decrements the USB device reference count.
*/
static void tascam_card_private_free(struct snd_card *card)
{
static void tascam_card_private_free(struct snd_card *card) {
struct tascam_card *tascam = card->private_data;
if (tascam) {
@ -347,8 +328,7 @@ static void tascam_card_private_free(struct snd_card *card)
*
* Return: 0 on success.
*/
static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
{
static int tascam_suspend(struct usb_interface *intf, pm_message_t message) {
struct tascam_card *tascam = usb_get_intfdata(intf);
int err;
@ -391,8 +371,7 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
0, /* size */
1000); /* timeout */
if (err < 0)
dev_err(&intf->dev, "failed to send deep sleep command: %d\n",
err);
dev_err(&intf->dev, "failed to send deep sleep command: %d\n", err);
return 0;
}
@ -401,14 +380,13 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
* tascam_resume() - Handles device resumption from suspend.
* @intf: The USB interface being resumed.
*
* This function is called when the device resumes from suspend. It re-establishes
* the active USB interface settings and re-configures the sample rate if it
* was previously active.
* This function is called when the device resumes from suspend. It
* re-establishes the active USB interface settings and re-configures the sample
* rate if it was previously active.
*
* Return: 0 on success, or a negative error code on failure.
*/
static int tascam_resume(struct usb_interface *intf)
{
static int tascam_resume(struct usb_interface *intf) {
struct tascam_card *tascam = usb_get_intfdata(intf);
int err;
@ -423,23 +401,20 @@ static int tascam_resume(struct usb_interface *intf)
*/
err = usb_set_interface(tascam->dev, 0, 1);
if (err < 0) {
dev_err(&intf->dev,
"resume: failed to set alt setting on intf 0: %d\n",
dev_err(&intf->dev, "resume: failed to set alt setting on intf 0: %d\n",
err);
return err;
}
err = usb_set_interface(tascam->dev, 1, 1);
if (err < 0) {
dev_err(&intf->dev,
"resume: failed to set alt setting on intf 1: %d\n",
dev_err(&intf->dev, "resume: failed to set alt setting on intf 1: %d\n",
err);
return err;
}
/* Re-configure the sample rate if one was previously active */
if (tascam->current_rate > 0)
us144mkii_configure_device_for_rate(tascam,
tascam->current_rate);
us144mkii_configure_device_for_rate(tascam, tascam->current_rate);
return 0;
}
@ -460,8 +435,7 @@ static int tascam_resume(struct usb_interface *intf)
* Return: 0 on success, or a negative error code on failure.
*/
static int tascam_probe(struct usb_interface *intf,
const struct usb_device_id *usb_id)
{
const struct usb_device_id *usb_id) {
struct usb_device *dev = interface_to_usbdev(intf);
struct snd_card *card;
struct tascam_card *tascam;
@ -469,8 +443,7 @@ static int tascam_probe(struct usb_interface *intf,
char *handshake_buf;
if (dev->speed != USB_SPEED_HIGH)
dev_info(
&dev->dev,
dev_info(&dev->dev,
"Device is connected to a USB 1.1 port, this is not supported.\n");
if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
@ -496,10 +469,9 @@ static int tascam_probe(struct usb_interface *intf,
if (!handshake_buf)
return -ENOMEM;
err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
VENDOR_REQ_MODE_CONTROL, RT_D2H_VENDOR_DEV,
MODE_VAL_HANDSHAKE_READ, 0x0000, handshake_buf, 1,
USB_CTRL_TIMEOUT_MS);
err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), VENDOR_REQ_MODE_CONTROL,
RT_D2H_VENDOR_DEV, MODE_VAL_HANDSHAKE_READ, 0x0000,
handshake_buf, 1, USB_CTRL_TIMEOUT_MS);
if (err < 0) {
dev_err(&dev->dev, "Handshake read failed with %d\n", err);
kfree(handshake_buf);
@ -508,8 +480,7 @@ static int tascam_probe(struct usb_interface *intf,
if (handshake_buf[0] != 0x12 && handshake_buf[0] != 0x16 &&
handshake_buf[0] != 0x30) {
dev_err(&dev->dev, "Unexpected handshake value: 0x%x\n",
handshake_buf[0]);
dev_err(&dev->dev, "Unexpected handshake value: 0x%x\n", handshake_buf[0]);
kfree(handshake_buf);
return -ENODEV;
}
@ -517,17 +488,13 @@ static int tascam_probe(struct usb_interface *intf,
err = usb_set_interface(dev, 0, 1);
if (err < 0) {
dev_err(&dev->dev,
"Failed to set alt setting 1 on interface 0: %d\n",
err);
dev_err(&dev->dev, "Failed to set alt setting 1 on interface 0: %d\n", err);
return err;
}
err = usb_set_interface(dev, 1, 1);
if (err < 0) {
dev_err(&dev->dev,
"Failed to set alt setting 1 on interface 1: %d\n",
err);
dev_err(&dev->dev, "Failed to set alt setting 1 on interface 1: %d\n", err);
return err;
}
@ -561,9 +528,9 @@ static int tascam_probe(struct usb_interface *intf,
strscpy(card->driver, DRIVER_NAME, sizeof(card->driver));
if (dev->descriptor.idProduct == USB_PID_TASCAM_US144) {
strscpy(card->shortname, "TASCAM US144", sizeof(card->shortname));
strscpy(card->shortname, "TASCAM US-144", sizeof(card->shortname));
} else if (dev->descriptor.idProduct == USB_PID_TASCAM_US144MKII) {
strscpy(card->shortname, "TASCAM US144MKII", sizeof(card->shortname));
strscpy(card->shortname, "TASCAM US-144MKII", sizeof(card->shortname));
} else {
strscpy(card->shortname, "TASCAM Unknown", sizeof(card->shortname));
}
@ -573,8 +540,7 @@ static int tascam_probe(struct usb_interface *intf,
err = device_create_file(&dev->dev, &dev_attr_driver_version);
if (err < 0)
dev_warn(&dev->dev,
"could not create driver_version attribute, err: %d\n",
dev_warn(&dev->dev, "could not create driver_version attribute, err: %d\n",
err);
err = snd_pcm_new(card, "US144MKII PCM", 0, 1, 1, &tascam->pcm);
@ -621,8 +587,7 @@ free_card:
* It cleans up all allocated resources, including killing URBs, freeing
* the sound card, and releasing memory.
*/
static void tascam_disconnect(struct usb_interface *intf)
{
static void tascam_disconnect(struct usb_interface *intf) {
struct tascam_card *tascam = usb_get_intfdata(intf);
if (!tascam)
@ -646,8 +611,7 @@ static void tascam_disconnect(struct usb_interface *intf)
static const struct usb_device_id tascam_usb_ids[] = {
{USB_DEVICE(USB_VID_TASCAM, USB_PID_TASCAM_US144)},
{USB_DEVICE(USB_VID_TASCAM, USB_PID_TASCAM_US144MKII)},
{ /* Terminating entry */ }
};
{/* Terminating entry */}};
MODULE_DEVICE_TABLE(usb, tascam_usb_ids);
static struct usb_driver tascam_alsa_driver = {

35
us144mkii.h
View File

@ -4,17 +4,17 @@
#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"
#define DRIVER_VERSION "1.7.5"
/* --- USB Device Identification --- */
#define USB_VID_TASCAM 0x0644
@ -152,17 +152,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.
*
@ -277,9 +283,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);
@ -318,7 +324,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

62
us144mkii_capture.c
View File

@ -12,8 +12,7 @@
*
* Return: 0 on success.
*/
static int tascam_capture_open(struct snd_pcm_substream *substream)
{
static int tascam_capture_open(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
substream->runtime->hw = tascam_pcm_hw;
@ -32,8 +31,7 @@ static int tascam_capture_open(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_capture_close(struct snd_pcm_substream *substream)
{
static int tascam_capture_close(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->capture_substream = NULL;
@ -49,8 +47,7 @@ static int tascam_capture_close(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_capture_prepare(struct snd_pcm_substream *substream)
{
static int tascam_capture_prepare(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->driver_capture_pos = 0;
@ -71,8 +68,8 @@ 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
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;
@ -85,10 +82,8 @@ static snd_pcm_uframes_t tascam_capture_pointer(struct snd_pcm_substream *substr
pos = tascam->capture_frames_processed;
spin_unlock_irqrestore(&tascam->lock, flags);
u64 remainder = do_div(pos, runtime->buffer_size);
return runtime ? remainder : 0;
}
/**
@ -118,11 +113,12 @@ 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)
{
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);
memset(dst_block, 0,
FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
DECODED_SAMPLE_SIZE);
for (frame = 0; frame < FRAMES_PER_DECODE_BLOCK; ++frame) {
const u8 *p_src_frame_base = src_block + frame * 64;
@ -161,9 +157,9 @@ 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.
*/
void tascam_capture_work_handler(struct work_struct *work)
{
struct tascam_card *tascam = container_of(work, struct tascam_card, capture_work);
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;
@ -176,7 +172,8 @@ void tascam_capture_work_handler(struct work_struct *work)
runtime = substream->runtime;
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;
}
@ -187,15 +184,19 @@ void tascam_capture_work_handler(struct work_struct *work)
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);
if (can_process) {
size_t i;
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);
@ -210,7 +211,9 @@ void tascam_capture_work_handler(struct work_struct *work)
int f;
for (f = 0; f < FRAMES_PER_DECODE_BLOCK; ++f) {
u8 *dst_frame_start = runtime->dma_area + frames_to_bytes(runtime, tascam->driver_capture_pos);
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;
@ -221,7 +224,8 @@ void tascam_capture_work_handler(struct work_struct *work)
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);
@ -236,16 +240,17 @@ 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)
{
void capture_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
int ret;
unsigned long flags;
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))
@ -271,7 +276,8 @@ void capture_urb_complete(struct 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);
}

189
us144mkii_controls.c
View File

@ -9,7 +9,8 @@
* 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"};
static const char *const playback_source_texts[] = {"Playback 1-2",
"Playback 3-4"};
/**
* @brief Text descriptions for capture input source options.
@ -20,17 +21,19 @@ static const char * const playback_source_texts[] = {"Playback 1-2", "Playback 3
static const char *const capture_source_texts[] = {"Analog In", "Digital In"};
/**
* 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,
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
uinfo->value.enumerated.items = 2;
@ -53,8 +56,8 @@ 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->line_out_source;
@ -72,8 +75,8 @@ 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1)
@ -90,15 +93,20 @@ 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,
.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,
};
/**
* 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,8 +116,8 @@ 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->digital_out_source;
@ -117,7 +125,8 @@ static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, struct snd_ctl_
}
/**
* 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,8 +136,8 @@ 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1)
@ -140,16 +149,21 @@ static int tascam_digital_out_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
}
/**
* 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,
.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,
};
/**
@ -158,12 +172,13 @@ 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,
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
uinfo->count = 1;
uinfo->value.enumerated.items = 2;
@ -176,18 +191,19 @@ static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_
}
/**
* 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->capture_12_source;
@ -195,18 +211,19 @@ static int tascam_capture_12_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
}
/**
* 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1)
@ -218,31 +235,37 @@ static int tascam_capture_12_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
}
/**
* 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,
.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,
};
/**
* 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
ucontrol->value.enumerated.item[0] = tascam->capture_34_source;
@ -250,18 +273,19 @@ static int tascam_capture_34_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
}
/**
* 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,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam = snd_kcontrol_chip(kcontrol);
if (ucontrol->value.enumerated.item[0] > 1)
@ -273,16 +297,21 @@ static int tascam_capture_34_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e
}
/**
* 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,
.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,
};
/**
@ -295,8 +324,8 @@ 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,
struct snd_ctl_elem_info *uinfo) {
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
uinfo->value.integer.min = 0;
@ -311,13 +340,15 @@ 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)
{
struct tascam_card *tascam = (struct tascam_card *)snd_kcontrol_chip(kcontrol);
static int tascam_samplerate_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) {
struct tascam_card *tascam =
(struct tascam_card *)snd_kcontrol_chip(kcontrol);
u8 *buf;
int err;
u32 rate = 0;
@ -332,9 +363,8 @@ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
return -ENOMEM;
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_GET_CUR, RT_D2H_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL,
EP_AUDIO_IN, buf, 3, USB_CTRL_TIMEOUT_MS);
if (err >= 3)
rate = buf[0] | (buf[1] << 8) | (buf[2] << 16);
@ -359,7 +389,8 @@ static const struct snd_kcontrol_new tascam_samplerate_control = {
};
/**
* 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,24 +399,28 @@ 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 tascam_create_controls(struct tascam_card *tascam) {
int err;
err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_line_out_control, tascam));
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;

100
us144mkii_midi.c
View File

@ -11,9 +11,9 @@
* the kfifo, processes it by stripping protocol-specific padding bytes, and
* passes the clean MIDI data to the ALSA rawmidi subsystem.
*/
static void tascam_midi_in_work_handler(struct work_struct *work)
{
struct tascam_card *tascam = container_of(work, struct tascam_card, midi_in_work);
static void tascam_midi_in_work_handler(struct work_struct *work) {
struct tascam_card *tascam =
container_of(work, struct tascam_card, midi_in_work);
u8 buf[MIDI_IN_BUF_SIZE];
unsigned int len;
int i;
@ -22,8 +22,8 @@ static void tascam_midi_in_work_handler(struct work_struct *work)
return;
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);
if (len == 0)
continue;
@ -54,25 +54,22 @@ 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)
{
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",
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);
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);
}
@ -80,8 +77,8 @@ void tascam_midi_in_urb_complete(struct 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);
dev_err(tascam->card->dev, "Failed to resubmit MIDI IN URB: error %d\n",
ret);
usb_unanchor_urb(urb);
usb_put_urb(urb);
}
@ -98,8 +95,7 @@ out:
*
* Return: 0 on success.
*/
static int tascam_midi_in_open(struct snd_rawmidi_substream *substream)
{
static int tascam_midi_in_open(struct snd_rawmidi_substream *substream) {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_in_substream = substream;
@ -112,8 +108,7 @@ 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)
{
static int tascam_midi_in_close(struct snd_rawmidi_substream *substream) {
return 0;
}
@ -122,13 +117,13 @@ 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,
int up) {
struct tascam_card *tascam = substream->rmidi->private_data;
int i, err;
unsigned long flags;
@ -144,7 +139,8 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int
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);
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]);
}
@ -161,8 +157,8 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int
/**
* 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,
@ -179,15 +175,16 @@ 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)
{
void tascam_midi_out_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
unsigned long flags;
int i, urb_index = -1;
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);
}
if (!tascam)
@ -225,8 +222,7 @@ 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)
{
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;
@ -277,12 +273,10 @@ static void tascam_midi_out_work_handler(struct work_struct *work)
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,
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);
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);
@ -291,7 +285,6 @@ static void tascam_midi_out_work_handler(struct work_struct *work)
}
}
/**
* tascam_midi_out_open() - Opens the MIDI output substream.
* @substream: The ALSA rawmidi substream to open.
@ -301,8 +294,7 @@ 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)
{
static int tascam_midi_out_open(struct snd_rawmidi_substream *substream) {
struct tascam_card *tascam = substream->rmidi->private_data;
tascam->midi_out_substream = substream;
@ -317,8 +309,7 @@ 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)
{
static int tascam_midi_out_close(struct snd_rawmidi_substream *substream) {
return 0;
}
@ -329,8 +320,7 @@ 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)
{
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);
@ -345,8 +335,8 @@ 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,
int up) {
struct tascam_card *tascam = substream->rmidi->private_data;
if (up) {
@ -360,8 +350,8 @@ static void tascam_midi_out_trigger(struct snd_rawmidi_substream *substream, int
/**
* 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,
@ -376,19 +366,21 @@ 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 tascam_create_midi(struct tascam_card *tascam) {
int err;
err = snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1, &tascam->rmidi);
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);
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);
tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT |
SNDRV_RAWMIDI_INFO_OUTPUT |

96
us144mkii_pcm.c
View File

@ -15,34 +15,28 @@
* 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},
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}
};
{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}
};
{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},
{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}
};
{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 +45,15 @@ 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,
};
/**
@ -68,9 +64,8 @@ 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)
{
const u8 *src_buffer, u8 *dst_buffer,
size_t frames) {
size_t f;
const u8 *src_12, *src_34;
u8 *dst_line, *dst_digital;
@ -103,8 +98,7 @@ void process_playback_routing_us144mkii(struct tascam_card *tascam,
*/
void process_capture_routing_us144mkii(struct tascam_card *tascam,
const s32 *decoded_block,
s32 *routed_block)
{
s32 *routed_block) {
int f;
const s32 *src_frame;
s32 *dst_frame;
@ -143,8 +137,7 @@ 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)
{
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;
@ -184,31 +177,49 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int 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);
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;
@ -216,7 +227,8 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate)
return 0;
fail:
dev_err(&dev->dev, "Device configuration failed at rate %d with error %d\n", rate, err);
dev_err(&dev->dev, "Device configuration failed at rate %d with error %d\n",
rate, err);
kfree(rate_payload_buf);
return err;
}
@ -234,8 +246,7 @@ 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)
{
struct snd_pcm_hw_params *params) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
int err;
unsigned int rate = params_rate(params);
@ -291,16 +302,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)
{
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,8 +318,7 @@ 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)
{
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;
@ -384,7 +393,8 @@ 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;
}
@ -404,15 +414,13 @@ start_rollback:
*
* Return: 0 on success.
*/
int tascam_init_pcm(struct snd_pcm *pcm)
{
int tascam_init_pcm(struct snd_pcm *pcm) {
struct tascam_card *tascam = pcm->private_data;
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->dev->dev.parent, 64 * 1024,
tascam_pcm_hw.buffer_bytes_max);
INIT_WORK(&tascam->capture_work, tascam_capture_work_handler);

14
us144mkii_pcm.h
View File

@ -96,7 +96,9 @@ 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,
const u8 *src_buffer, u8 *dst_buffer,
size_t frames);
/**
* process_capture_routing_us144mkii() - Apply capture routing matrix
@ -104,7 +106,9 @@ 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,
const s32 *decoded_block,
s32 *routed_block);
/**
* tascam_pcm_hw_params() - Configures hardware parameters for PCM streams.
@ -118,7 +122,8 @@ 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,
struct snd_pcm_hw_params *params);
/**
* tascam_pcm_hw_free() - Frees hardware parameters for PCM streams.
@ -133,7 +138,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

98
us144mkii_playback.c
View File

@ -12,8 +12,7 @@
*
* Return: 0 on success.
*/
static int tascam_playback_open(struct snd_pcm_substream *substream)
{
static int tascam_playback_open(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
substream->runtime->hw = tascam_pcm_hw;
@ -32,8 +31,7 @@ static int tascam_playback_open(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_playback_close(struct snd_pcm_substream *substream)
{
static int tascam_playback_close(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
tascam->playback_substream = NULL;
@ -51,8 +49,7 @@ static int tascam_playback_close(struct snd_pcm_substream *substream)
*
* Return: 0 on success.
*/
static int tascam_playback_prepare(struct snd_pcm_substream *substream)
{
static int tascam_playback_prepare(struct snd_pcm_substream *substream) {
struct tascam_card *tascam = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
int i, u;
@ -114,8 +111,8 @@ 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
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;
@ -159,8 +156,7 @@ 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)
{
void playback_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
struct snd_pcm_substream *substream;
struct snd_pcm_runtime *runtime;
@ -172,9 +168,10 @@ void playback_urb_complete(struct urb *urb)
int ret, i;
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))
@ -192,8 +189,11 @@ void playback_urb_complete(struct urb *urb)
size_t bytes_for_packet;
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;
}
@ -207,7 +207,8 @@ void playback_urb_complete(struct urb *urb)
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;
spin_unlock_irqrestore(&tascam->lock, flags);
@ -217,17 +218,20 @@ void playback_urb_complete(struct urb *urb)
/* 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 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);
}
@ -236,7 +240,8 @@ 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);
}
@ -255,8 +260,7 @@ out:
* streams in sync. It then calls snd_pcm_period_elapsed if necessary and
* resubmits itself.
*/
void feedback_urb_complete(struct urb *urb)
{
void feedback_urb_complete(struct urb *urb) {
struct tascam_card *tascam = urb->context;
struct snd_pcm_substream *playback_ss, *capture_ss;
struct snd_pcm_runtime *playback_rt, *capture_rt;
@ -268,9 +272,10 @@ void feedback_urb_complete(struct urb *urb)
bool capture_period_elapsed = false;
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))
@ -300,16 +305,20 @@ void feedback_urb_complete(struct urb *urb)
urb->iso_frame_desc[p].actual_length >= 1);
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 &&
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];
total_frames_in_urb += pattern[i];
@ -320,8 +329,10 @@ 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);
if (capture_ss)
@ -331,24 +342,29 @@ void feedback_urb_complete(struct urb *urb)
}
}
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;
total_frames_in_urb += nominal_frames;
}
}
tascam->feedback_pattern_in_idx = (tascam->feedback_pattern_in_idx + 8) % FEEDBACK_ACCUMULATOR_SIZE;
tascam->feedback_pattern_in_idx =
(tascam->feedback_pattern_in_idx + 8) % FEEDBACK_ACCUMULATOR_SIZE;
}
new_in_idx = tascam->feedback_pattern_in_idx;
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;
}
@ -361,7 +377,8 @@ void feedback_urb_complete(struct urb *urb)
}
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);
if (current_period > tascam->last_period_pos) {
tascam->last_period_pos = current_period;
@ -369,8 +386,10 @@ void feedback_urb_complete(struct urb *urb)
}
}
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 (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;
@ -391,7 +410,8 @@ unlock_and_continue:
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);
}