proper kernel code formatting

README.md

@@ -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
 

tascam_controls/src/alsacontroller.cpp

@@ -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;
     }
 }
 

tascam_controls/src/alsacontroller.h

@@ -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;

tascam_controls/src/mainwindow.cpp

@@ -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;
     }

us144mkii.c

@@ -8,7 +8,7 @@
 
 MODULE_AUTHOR("Šerif Rami <ramiserifpersia@gmail.com>");
 MODULE_DESCRIPTION("ALSA Driver for TASCAM US-144MKII");
-MODULE_LICENSE("GPL v2");
+MODULE_LICENSE("GPL");
 
 /**
  * @brief Module parameters for ALSA card instantiation.
@@ -16,8 +16,8 @@ MODULE_LICENSE("GPL v2");
  * 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.
+ * @param index: Array of integers specifying the ALSA card index for each
- *               Defaults to -1 (automatic).
+ * 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.
@@ -26,13 +26,22 @@ MODULE_LICENSE("GPL v2");
  */
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+<<<<<<< HEAD
 static bool enable[SNDRV_CARDS] = {1, [1 ...(SNDRV_CARDS - 1)] = 0};
+=======
+static bool enable[SNDRV_CARDS] = { 1, [1 ...(SNDRV_CARDS - 1)] = 0 };
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 static int dev_idx;
 
 static struct usb_driver tascam_alsa_driver;
 
 /* --- Forward Declarations --- */
-static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *usb_id);
+static int tascam_probe(struct usb_interface *intf,
+<<<<<<< HEAD
+                        const struct usb_device_id *usb_id);
+=======
+			const struct usb_device_id *usb_id);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 static void tascam_disconnect(struct usb_interface *intf);
 static int tascam_suspend(struct usb_interface *intf, pm_message_t message);
 static int tascam_resume(struct usb_interface *intf);
@@ -49,13 +58,11 @@ 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);
 
-
 /**
  * tascam_free_urbs() - Free all allocated URBs and associated buffers.
  * @tascam: the tascam_card instance
@@ -64,10 +71,10 @@ 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;
 
+<<<<<<< HEAD
   usb_kill_anchored_urbs(&tascam->playback_anchor);
   for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
     if (tascam->playback_urbs[i]) {
@@ -122,6 +129,67 @@ void tascam_free_urbs(struct tascam_card *tascam)
       tascam->midi_out_urbs[i] = NULL;
     }
   }
+=======
+	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,
+				tascam->playback_urbs[i]->transfer_buffer,
+				tascam->playback_urbs[i]->transfer_dma);
+			usb_free_urb(tascam->playback_urbs[i]);
+			tascam->playback_urbs[i] = NULL;
+		}
+	}
+
+	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,
+				tascam->feedback_urbs[i]->transfer_buffer,
+				tascam->feedback_urbs[i]->transfer_dma);
+			usb_free_urb(tascam->feedback_urbs[i]);
+			tascam->feedback_urbs[i] = NULL;
+		}
+	}
+
+	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,
+				tascam->capture_urbs[i]->transfer_buffer,
+				tascam->capture_urbs[i]->transfer_dma);
+			usb_free_urb(tascam->capture_urbs[i]);
+			tascam->capture_urbs[i] = NULL;
+		}
+	}
+
+	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,
+				tascam->midi_in_urbs[i]->transfer_buffer,
+				tascam->midi_in_urbs[i]->transfer_dma);
+			usb_free_urb(tascam->midi_in_urbs[i]);
+			tascam->midi_in_urbs[i] = NULL;
+		}
+	}
+
+	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,
+				tascam->midi_out_urbs[i]->transfer_buffer,
+				tascam->midi_out_urbs[i]->transfer_dma);
+			usb_free_urb(tascam->midi_out_urbs[i]);
+			tascam->midi_out_urbs[i] = NULL;
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   kfree(tascam->playback_routing_buffer);
   tascam->playback_routing_buffer = NULL;
@@ -144,25 +212,43 @@ 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;
 
+<<<<<<< HEAD
   max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME;
   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);
+=======
+	max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME;
+	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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     if (!urb)
       goto error;
     tascam->playback_urbs[i] = urb;
 
-		urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->playback_urb_alloc_size,
+<<<<<<< HEAD
+    urb->transfer_buffer =
+        usb_alloc_coherent(tascam->dev, tascam->playback_urb_alloc_size,
                            GFP_KERNEL, &urb->transfer_dma);
     if (!urb->transfer_buffer)
       goto error;
+=======
+		urb->transfer_buffer = usb_alloc_coherent(
+			tascam->dev, tascam->playback_urb_alloc_size,
+			GFP_KERNEL, &urb->transfer_dma);
+		if (!urb->transfer_buffer)
+			goto error;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     urb->dev = tascam->dev;
     urb->pipe = usb_sndisocpipe(tascam->dev, EP_AUDIO_OUT);
@@ -172,16 +258,27 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
     urb->complete = playback_urb_complete;
   }
 
+<<<<<<< HEAD
   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);
+=======
+	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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     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,
+<<<<<<< HEAD
+    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;
@@ -193,6 +290,22 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
     f_urb->context = tascam;
     f_urb->complete = feedback_urb_complete;
   }
+=======
+		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->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+		f_urb->interval = 4;
+		f_urb->context = tascam;
+		f_urb->complete = feedback_urb_complete;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   tascam->capture_urb_alloc_size = CAPTURE_URB_SIZE;
   for (i = 0; i < NUM_CAPTURE_URBS; i++) {
@@ -202,53 +315,85 @@ 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,
+<<<<<<< HEAD
+    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,
+                      capture_urb_complete, tascam);
+    c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+  }
+=======
+		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,
-				  capture_urb_complete,
+				  capture_urb_complete, tascam);
-				  tascam);
 		c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   /* MIDI URB and buffer allocation */
   for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
     struct urb *m_urb = usb_alloc_urb(0, GFP_KERNEL);
 
+<<<<<<< HEAD
     if (!m_urb)
       goto error;
     tascam->midi_in_urbs[i] = m_urb;
-		m_urb->transfer_buffer = usb_alloc_coherent(tascam->dev,
+    m_urb->transfer_buffer = usb_alloc_coherent(
-			MIDI_IN_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma);
+        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, usb_rcvbulkpipe(tascam->dev, EP_MIDI_IN),
+    usb_fill_bulk_urb(m_urb, tascam->dev,
+                      usb_rcvbulkpipe(tascam->dev, EP_MIDI_IN),
                       m_urb->transfer_buffer, MIDI_IN_BUF_SIZE,
-				  tascam_midi_in_urb_complete,
+                      tascam_midi_in_urb_complete, tascam);
-				  tascam);
     m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
   }
+=======
+		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);
+		if (!m_urb->transfer_buffer)
+			goto error;
+		usb_fill_bulk_urb(m_urb, tascam->dev,
+				  usb_rcvbulkpipe(tascam->dev, EP_MIDI_IN),
+				  m_urb->transfer_buffer, MIDI_IN_BUF_SIZE,
+				  tascam_midi_in_urb_complete, tascam);
+		m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
     struct urb *m_urb = usb_alloc_urb(0, GFP_KERNEL);
 
+<<<<<<< HEAD
     if (!m_urb)
       goto error;
     tascam->midi_out_urbs[i] = m_urb;
-		m_urb->transfer_buffer = usb_alloc_coherent(tascam->dev,
+    m_urb->transfer_buffer = usb_alloc_coherent(
-			MIDI_OUT_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma);
+        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 */
-				  tascam_midi_out_urb_complete,
+                      tascam_midi_out_urb_complete, tascam);
-				  tascam);
     m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
   }
 
@@ -256,21 +401,75 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
   if (!tascam->capture_ring_buffer)
     goto error;
 
-	tascam->capture_decode_raw_block = kmalloc(RAW_BYTES_PER_DECODE_BLOCK, GFP_KERNEL);
+  tascam->capture_decode_raw_block =
+      kmalloc(RAW_BYTES_PER_DECODE_BLOCK, GFP_KERNEL);
   if (!tascam->capture_decode_raw_block)
     goto error;
 
-	tascam->capture_decode_dst_block = kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME * DECODED_SAMPLE_SIZE, GFP_KERNEL);
+  tascam->capture_decode_dst_block =
+      kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
+                  DECODED_SAMPLE_SIZE,
+              GFP_KERNEL);
   if (!tascam->capture_decode_dst_block)
     goto error;
 
-	tascam->playback_routing_buffer = kmalloc(tascam->playback_urb_alloc_size, GFP_KERNEL);
+  tascam->playback_routing_buffer =
+      kmalloc(tascam->playback_urb_alloc_size, GFP_KERNEL);
   if (!tascam->playback_routing_buffer)
     goto error;
 
-	tascam->capture_routing_buffer = kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME * DECODED_SAMPLE_SIZE, GFP_KERNEL);
+  tascam->capture_routing_buffer =
+      kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
+                  DECODED_SAMPLE_SIZE,
+              GFP_KERNEL);
   if (!tascam->capture_routing_buffer)
     goto error;
+=======
+		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);
+		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 */
+				  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);
+	if (!tascam->capture_ring_buffer)
+		goto error;
+
+	tascam->capture_decode_raw_block =
+		kmalloc(RAW_BYTES_PER_DECODE_BLOCK, GFP_KERNEL);
+	if (!tascam->capture_decode_raw_block)
+		goto error;
+
+	tascam->capture_decode_dst_block =
+		kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
+				DECODED_SAMPLE_SIZE,
+			GFP_KERNEL);
+	if (!tascam->capture_decode_dst_block)
+		goto error;
+
+	tascam->playback_routing_buffer =
+		kmalloc(tascam->playback_urb_alloc_size, GFP_KERNEL);
+	if (!tascam->playback_routing_buffer)
+		goto error;
+
+	tascam->capture_routing_buffer =
+		kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME *
+				DECODED_SAMPLE_SIZE,
+			GFP_KERNEL);
+	if (!tascam->capture_routing_buffer)
+		goto error;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   return 0;
 
@@ -280,9 +479,16 @@ error:
   return -ENOMEM;
 }
 
+<<<<<<< HEAD
+void tascam_stop_work_handler(struct work_struct *work) {
+  struct tascam_card *tascam =
+      container_of(work, struct tascam_card, stop_work);
+=======
 void tascam_stop_work_handler(struct work_struct *work)
 {
-	struct tascam_card *tascam = container_of(work, struct tascam_card, stop_work);
+	struct tascam_card *tascam =
+		container_of(work, struct tascam_card, stop_work);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   usb_kill_anchored_urbs(&tascam->playback_anchor);
   usb_kill_anchored_urbs(&tascam->feedback_anchor);
@@ -292,15 +498,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) {
@@ -323,8 +529,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;
 
@@ -353,13 +558,13 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
   usb_kill_anchored_urbs(&tascam->midi_in_anchor);
   usb_kill_anchored_urbs(&tascam->midi_out_anchor);
 
+<<<<<<< HEAD
   /*
    * Send the vendor-specific "Deep Sleep" command. Failure to send this
    * command before host-initiated suspend can leave the device in an
    * unstable state, leading to system freezes on idle (autosuspend).
    */
-	err = usb_control_msg(tascam->dev,
+  err = usb_control_msg(tascam->dev, usb_sndctrlpipe(tascam->dev, 0),
-			      usb_sndctrlpipe(tascam->dev, 0),
                         0x00,   /* bRequest */
                         0x40,   /* bmRequestType: H2D, Vendor, Device */
                         0x0044, /* wValue */
@@ -369,6 +574,24 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
                         1000);  /* timeout */
   if (err < 0)
     dev_err(&intf->dev, "failed to send deep sleep command: %d\n", err);
+=======
+	/*
+	 * Send the vendor-specific "Deep Sleep" command. Failure to send this
+	 * command before host-initiated suspend can leave the device in an
+	 * unstable state, leading to system freezes on idle (autosuspend).
+	 */
+	err = usb_control_msg(tascam->dev, usb_sndctrlpipe(tascam->dev, 0),
+			      0x00, /* bRequest */
+			      0x40, /* bmRequestType: H2D, Vendor, Device */
+			      0x0044, /* wValue */
+			      0x0000, /* wIndex */
+			      NULL, /* data */
+			      0, /* size */
+			      1000); /* timeout */
+	if (err < 0)
+		dev_err(&intf->dev, "failed to send deep sleep command: %d\n",
+			err);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   return 0;
 }
@@ -377,14 +600,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
+ * This function is called when the device resumes from suspend. It
- * the active USB interface settings and re-configures the sample rate if it
+ * re-establishes the active USB interface settings and re-configures the sample
- * was previously active.
+ * 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;
 
@@ -393,6 +615,7 @@ static int tascam_resume(struct usb_interface *intf)
 
   dev_info(&intf->dev, "resuming TASCAM US-144MKII\n");
 
+<<<<<<< HEAD
   /*
    * The device requires a full re-initialization sequence upon resume.
    * First, re-establish the active USB interface settings.
@@ -413,6 +636,31 @@ static int tascam_resume(struct usb_interface *intf)
   /* Re-configure the sample rate if one was previously active */
   if (tascam->current_rate > 0)
     us144mkii_configure_device_for_rate(tascam, tascam->current_rate);
+=======
+	/*
+	 * The device requires a full re-initialization sequence upon resume.
+	 * First, re-establish the active USB interface settings.
+	 */
+	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",
+			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",
+			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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   return 0;
 }
@@ -432,8 +680,9 @@ 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)
+static int tascam_probe(struct usb_interface *intf,
-{
+<<<<<<< HEAD
+                        const struct usb_device_id *usb_id) {
   struct usb_device *dev = interface_to_usbdev(intf);
   struct snd_card *card;
   struct tascam_card *tascam;
@@ -441,10 +690,10 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
   char *handshake_buf;
 
   if (dev->speed != USB_SPEED_HIGH)
-		dev_info(&dev->dev, "Device is connected to a USB 1.1 port, this is not supported.\n");
+    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) {
-
     tascam = usb_get_intfdata(usb_ifnum_to_if(dev, 0));
     if (tascam) {
       usb_set_intfdata(intf, tascam);
@@ -457,6 +706,29 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
     dev_err(&dev->dev, "Too many TASCAM devices present");
     return -ENODEV;
   }
+=======
+			const struct usb_device_id *usb_id)
+{
+	struct usb_device *dev = interface_to_usbdev(intf);
+	struct snd_card *card;
+	struct tascam_card *tascam;
+	int err;
+	char *handshake_buf;
+
+	if (dev->speed != USB_SPEED_HIGH)
+		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) {
+		tascam = usb_get_intfdata(usb_ifnum_to_if(dev, 0));
+		if (tascam) {
+			usb_set_intfdata(intf, tascam);
+			tascam->iface1 = intf;
+		}
+		return 0;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (!enable[dev_idx]) {
     dev_info(&dev->dev, "TASCAM US-144MKII device disabled");
@@ -467,14 +739,18 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
   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);
     return err;
   }
 
-	if (handshake_buf[0] != 0x12 && handshake_buf[0] != 0x16 && handshake_buf[0] != 0x30) {
+<<<<<<< HEAD
+  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]);
     kfree(handshake_buf);
     return -ENODEV;
@@ -493,7 +769,8 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
     return err;
   }
 
-	err = snd_card_new(&dev->dev, index[dev_idx], id[dev_idx], THIS_MODULE, sizeof(struct tascam_card), &card);
+  err = snd_card_new(&dev->dev, index[dev_idx], id[dev_idx], THIS_MODULE,
+                     sizeof(struct tascam_card), &card);
   if (err < 0) {
     dev_err(&dev->dev, "Failed to create sound card instance\n");
     return err;
@@ -503,6 +780,49 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
   tascam->dev = usb_get_dev(dev);
   tascam->card = card;
   tascam->iface0 = intf;
+=======
+	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);
+		return err;
+	}
+
+	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]);
+		kfree(handshake_buf);
+		return -ENODEV;
+	}
+	kfree(handshake_buf);
+
+	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);
+		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);
+		return err;
+	}
+
+	err = snd_card_new(&dev->dev, index[dev_idx], id[dev_idx], THIS_MODULE,
+			   sizeof(struct tascam_card), &card);
+	if (err < 0) {
+		dev_err(&dev->dev, "Failed to create sound card instance\n");
+		return err;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   spin_lock_init(&tascam->lock);
   spin_lock_init(&tascam->midi_in_lock);
@@ -521,15 +841,22 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
   card->private_free = tascam_card_private_free;
 
   strscpy(card->driver, DRIVER_NAME, sizeof(card->driver));
-	strscpy(card->shortname, "TASCAM US-144MKII", sizeof(card->shortname));
+  if (dev->descriptor.idProduct == USB_PID_TASCAM_US144) {
+    strscpy(card->shortname, "TASCAM US144", sizeof(card->shortname));
+  } else if (dev->descriptor.idProduct == USB_PID_TASCAM_US144MKII) {
+    strscpy(card->shortname, "TASCAM US144MKII", sizeof(card->shortname));
+  } else {
+    strscpy(card->shortname, "TASCAM Unknown", sizeof(card->shortname));
+  }
   snprintf(card->longname, sizeof(card->longname), "%s (%04x:%04x) at %s",
-		 card->shortname, USB_VID_TASCAM, USB_PID_TASCAM_US144MKII, dev_name(&dev->dev));
+           card->shortname, USB_VID_TASCAM, dev->descriptor.idProduct,
+           dev_name(&dev->dev));
 
+<<<<<<< HEAD
   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", err);
+    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);
   if (err < 0)
@@ -544,6 +871,19 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
   err = tascam_create_midi(tascam);
   if (err < 0)
     goto free_card;
+=======
+	strscpy(card->driver, DRIVER_NAME, sizeof(card->driver));
+	strscpy(card->shortname, "TASCAM US-144MKII", sizeof(card->shortname));
+	snprintf(card->longname, sizeof(card->longname), "%s (%04x:%04x) at %s",
+		 card->shortname, USB_VID_TASCAM, USB_PID_TASCAM_US144MKII,
+		 dev_name(&dev->dev));
+
+	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",
+			 err);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   err = tascam_create_controls(tascam);
   if (err < 0)
@@ -575,8 +915,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)
@@ -598,9 +937,9 @@ 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 = {

us144mkii.h

@@ -4,20 +4,24 @@
 #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
+<<<<<<< HEAD
+#define USB_PID_TASCAM_US144 0x800f
+=======
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 #define USB_PID_TASCAM_US144MKII 0x8020
 
 /* --- USB Endpoints (Alternate Setting 1) --- */
@@ -34,6 +38,7 @@
 #define RT_D2H_VENDOR_DEV (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
 
 enum uac_request {
+<<<<<<< HEAD
   UAC_SET_CUR = 0x01,
   UAC_GET_CUR = 0x81,
 };
@@ -51,11 +56,31 @@ enum tascam_mode_value {
   MODE_VAL_HANDSHAKE_READ = 0x0000,
   MODE_VAL_CONFIG = 0x0010,
   MODE_VAL_STREAM_START = 0x0030,
+=======
+	UAC_SET_CUR = 0x01,
+	UAC_GET_CUR = 0x81,
+};
+
+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 {
+<<<<<<< HEAD
   REG_ADDR_UNKNOWN_0D = 0x0d04,
   REG_ADDR_UNKNOWN_0E = 0x0e00,
   REG_ADDR_UNKNOWN_0F = 0x0f00,
@@ -64,12 +89,20 @@ enum tascam_register {
   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
 
-
-
 /* --- URB Configuration --- */
 #define NUM_PLAYBACK_URBS 8
 #define PLAYBACK_URB_PACKETS 4
@@ -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).
+ * @digital_out_source: Source for Digital Outputs (0: Playback 1-2, 1: Playback
- * @capture_12_source: Source for Capture channels 1-2 (0: Analog In, 1: Digital In).
+ * 3-4).
- * @capture_34_source: Source for Capture channels 3-4 (0: Analog In, 1: Digital In).
+ * @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_urb_skip_count: Number of feedback URBs to skip initially for
- * @feedback_patterns: Pointer to the current feedback patterns based on sample rate.
+ * 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.
  *
@@ -225,6 +264,7 @@ struct tascam_card {
   spinlock_t midi_out_lock;
   u8 midi_running_status;
 
+<<<<<<< HEAD
   /* Shared state & Routing Matrix */
   spinlock_t lock;
   atomic_t active_urbs;
@@ -233,6 +273,16 @@ struct tascam_card {
   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 */
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   unsigned int feedback_accumulator_pattern[FEEDBACK_ACCUMULATOR_SIZE];
   unsigned int feedback_pattern_out_idx;
@@ -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)
+ * This function is scheduled to stop all active URBs (playback, feedback,
- * and reset the active_urbs counter. It is used to gracefully stop streams
+ * capture) and reset the active_urbs counter. It is used to gracefully stop
- * from a workqueue context.
+ * 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

us144mkii_capture.c

@@ -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,12 +68,21 @@ 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;
@@ -85,7 +91,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);
 
-	return runtime ? pos % runtime->buffer_size : 0;
+  u64 remainder = do_div(pos, runtime->buffer_size);
+  return runtime ? remainder : 0;
 }
 
 /**
@@ -115,17 +122,28 @@ 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);
+<<<<<<< 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;
 
+<<<<<<< HEAD
     s32 ch[4] = {0};
+=======
+		s32 ch[4] = { 0 };
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     for (bit = 0; bit < 24; ++bit) {
       u8 byte1 = p_src_frame_base[bit];
@@ -158,56 +176,115 @@ 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)
+<<<<<<< HEAD
-{
+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;
+=======
+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;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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");
+    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");
+		return;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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);
+    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);
+		can_process = (available_data >= RAW_BYTES_PER_DECODE_BLOCK);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     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];
+        raw_block[i] = tascam->capture_ring_buffer[(read_ptr + i) %
-			tascam->capture_ring_buffer_read_ptr = (read_ptr + RAW_BYTES_PER_DECODE_BLOCK) % CAPTURE_RING_BUFFER_SIZE;
+                                                   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;
+		}
+		spin_unlock_irqrestore(&tascam->lock, flags);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     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);
+        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;
 
@@ -218,11 +295,43 @@ 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);
   }
+=======
+			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);
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 }
 
 /**
@@ -233,25 +342,41 @@ 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;
 
+<<<<<<< HEAD
   if (urb->status) {
-		if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN &&
+    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
-		    urb->status != -ENODEV && urb->status != -EPROTO)
+        urb->status != -ESHUTDOWN && urb->status != -ENODEV &&
-			dev_err_ratelimited(tascam->card->dev, "Capture URB failed: %d\n", urb->status);
+        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);
+		goto out;
+	}
+	if (!tascam || !atomic_read(&tascam->capture_active))
+		goto out;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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++) {
@@ -260,18 +385,43 @@ void capture_urb_complete(struct urb *urb)
     }
     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];
+			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);
   }
 
+<<<<<<< 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);
+    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);
+		usb_unanchor_urb(urb);
+		usb_put_urb(urb);
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 out:
   usb_put_urb(urb);
 }

us144mkii_controls.c

@@ -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").
  */
+<<<<<<< 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,9 +79,15 @@ 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;
@@ -72,9 +104,15 @@ 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;
@@ -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",
+<<<<<<< HEAD
-	.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,
+=======
+	.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;
 }
 
 /**
- * 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,9 +185,15 @@ 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;
@@ -140,16 +204,29 @@ 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
+ * This defines a new ALSA mixer control named "Digital OUTPUTS Source" that
- * the user to select between "Playback 1-2" and "Playback 3-4" for the digital
+ * allows the user to select between "Playback 1-2" and "Playback 3-4" for the
- * outputs of the device. It uses the `tascam_playback_source_info` for
+ * 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.
+ * 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",
+<<<<<<< HEAD
-	.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,
+=======
+	.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,41 +264,56 @@ 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
+ * This function retrieves the current selection for the Capture channels 1 and
- * (Analog In or Digital In) from the driver's private data and populates
+ * 2 source (Analog In or Digital In) from the driver's private data and
- * the ALSA control element value.
+ * 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;
 }
 
 /**
- * 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)
+ * This function sets the Capture channels 1 and 2 source (Analog In or Digital
- * based on the user's selection from the ALSA control element. It validates
+ * 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;
@@ -218,51 +324,78 @@ 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",
+<<<<<<< HEAD
-	.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,
+=======
+	.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
+ * This function retrieves the current selection for the Capture channels 3 and
- * (Analog In or Digital In) from the driver's private data and populates
+ * 4 source (Analog In or Digital In) from the driver's private data and
- * the ALSA control element value.
+ * 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;
 }
 
 /**
- * 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)
+ * This function sets the Capture channels 3 and 4 source (Analog In or Digital
- * based on the user's selection from the ALSA control element. It validates
+ * 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;
@@ -273,16 +406,29 @@ 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
+ * the user to select between "Analog In" and "Digital In" for the third and
- * capture channels of the device. It uses the `tascam_capture_source_info` for
+ * fourth capture channels of the device. It uses the
- * information and `tascam_capture_34_get`/`tascam_capture_34_put` for value handling.
+ * `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",
+<<<<<<< HEAD
-	.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,
+=======
+	.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,16 +467,28 @@ 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 tascam_card *tascam = (struct tascam_card *)snd_kcontrol_chip(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;
+=======
+				 struct snd_ctl_elem_value *ucontrol)
+{
+	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;
@@ -331,10 +499,16 @@ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e
   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,
+			      UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, buf, 3,
-			      buf, 3, USB_CTRL_TIMEOUT_MS);
+			      USB_CTRL_TIMEOUT_MS);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (err >= 3)
     rate = buf[0] | (buf[1] << 8) | (buf[2] << 16);
@@ -359,7 +533,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,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 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));
+  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;
+=======
+	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;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   return 0;
 }

us144mkii_midi.c

@@ -11,19 +11,35 @@
  * 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)
+<<<<<<< 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);
+  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);
+	u8 buf[MIDI_IN_BUF_SIZE];
+	unsigned int len;
+	int i;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (!tascam->midi_in_substream)
     return;
 
+<<<<<<< HEAD
   while (!kfifo_is_empty(&tascam->midi_in_fifo)) {
-		len = kfifo_out_spinlocked(&tascam->midi_in_fifo,
+    len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf, sizeof(buf),
-					   buf, sizeof(buf), &tascam->midi_in_lock);
+                               &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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     if (len == 0)
       continue;
@@ -36,6 +52,7 @@ static void tascam_midi_in_work_handler(struct work_struct *work)
       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;
@@ -44,6 +61,18 @@ static void tascam_midi_in_work_handler(struct work_struct *work)
       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))
+				continue;
+
+			/* Submit valid MIDI bytes one by one */
+			snd_rawmidi_receive(tascam->midi_in_substream, &buf[i],
+					    1);
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 }
 
 /**
@@ -54,34 +83,40 @@ 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,
+      dev_err_ratelimited(tascam->card->dev, "MIDI IN URB failed: status %d\n",
-					    "MIDI IN URB failed: status %d\n",
                           urb->status);
     goto out;
   }
 
-	if (tascam && atomic_read(&tascam->midi_in_active) && urb->actual_length > 0) {
+<<<<<<< HEAD
-		kfifo_in_spinlocked(&tascam->midi_in_fifo,
+  if (tascam && atomic_read(&tascam->midi_in_active) &&
-				    urb->transfer_buffer,
+      urb->actual_length > 0) {
-				    urb->actual_length,
+    kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer,
-				    &tascam->midi_in_lock);
+                        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,
+    dev_err(tascam->card->dev, "Failed to resubmit MIDI IN URB: error %d\n",
-			"Failed to resubmit MIDI IN URB: error %d\n", ret);
+            ret);
     usb_unanchor_urb(urb);
     usb_put_urb(urb);
   }
@@ -98,8 +133,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 +146,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,16 +155,24 @@ 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.
+ * This function starts or stops the MIDI input URBs based on the 'up'
- * When starting, it resets the kfifo and submits all MIDI input URBs.
+ * parameter. When starting, it resets the kfifo and submits all MIDI input
- * When stopping, it kills all anchored MIDI input URBs and cancels the
+ * 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) {
@@ -139,12 +180,14 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int
       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);
+          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,13 +199,37 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, int
       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);
+				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);
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 }
 
 /**
  * tascam_midi_in_ops - ALSA rawmidi operations for MIDI input.
  *
- * This structure defines the callback functions for MIDI input stream operations,
+ * This structure defines the callback functions for MIDI input stream
- * including open, close, and trigger.
+ * operations, including open, close, and trigger.
  */
 static const struct snd_rawmidi_ops tascam_midi_in_ops = {
     .open = tascam_midi_in_open,
@@ -179,16 +246,27 @@ 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;
 
+<<<<<<< HEAD
   if (urb->status) {
-		if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN)
+    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
-			dev_err_ratelimited(tascam->card->dev, "MIDI OUT URB failed: %d\n", urb->status);
+        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);
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (!tascam)
     goto out;
@@ -200,10 +278,18 @@ void tascam_midi_out_urb_complete(struct urb *urb)
     }
   }
 
+<<<<<<< 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");
+		goto out;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   spin_lock_irqsave(&tascam->midi_out_lock, flags);
   clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
@@ -225,8 +311,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;
@@ -274,23 +359,38 @@ static void tascam_midi_out_work_handler(struct work_struct *work)
     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(
+      dev_err_ratelimited(tascam->card->dev,
-				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,
+      clear_bit(urb_index, &tascam->midi_out_urbs_in_flight);
-				  &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);
+			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 */
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 }
-
 
 /**
  * tascam_midi_out_open() - Opens the MIDI output substream.
@@ -301,8 +401,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 +416,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 +427,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,9 +442,15 @@ 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);
@@ -360,8 +463,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,
+ * This structure defines the callback functions for MIDI output stream
- * including open, close, trigger, and drain.
+ * operations, including open, close, trigger, and drain.
  */
 static const struct snd_rawmidi_ops tascam_midi_out_ops = {
     .open = tascam_midi_out_open,
@@ -376,19 +479,37 @@ 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);
+<<<<<<< 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_INPUT,
-	snd_rawmidi_set_ops(tascam->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &tascam_midi_out_ops);
+                      &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));
+	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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   tascam->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT |
                                SNDRV_RAWMIDI_INFO_OUTPUT |

us144mkii_pcm.c

@@ -15,13 +15,52 @@
  * which helps the driver adjust the packet size dynamically to match the
  * device's consumption rate.
  */
-static const unsigned int patterns_48khz[5][8] = {
+<<<<<<< HEAD
-	{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}};
+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 },
@@ -36,13 +75,11 @@ static const unsigned int patterns_88khz[5][8] = {
 	{ 11, 11, 12, 11, 11, 11, 11, 11 },
 	{ 12, 11, 11, 12, 11, 11, 12, 11 }
 };
-static const unsigned int patterns_44khz[5][8] = {
+static const unsigned int patterns_44khz[5][8] = { { 5, 5, 5, 5, 5, 5, 5, 6 },
-	{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 +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,12 +108,20 @@ 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,
+<<<<<<< HEAD
-				       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;
+=======
+					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;
@@ -102,12 +150,20 @@ 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,
+<<<<<<< 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);
@@ -143,14 +199,14 @@ 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;
   int err = 0;
   const u8 *current_payload_src;
 
+<<<<<<< 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};
@@ -177,6 +233,35 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate)
     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:
+		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;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   rate_payload_buf = kmemdup(current_payload_src, 3, GFP_KERNEL);
   if (!rate_payload_buf)
@@ -184,41 +269,125 @@ 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);
+<<<<<<< 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);
+  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;
+=======
+	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;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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,11 +403,18 @@ fail:
  * Return: 0 on success, or a negative error code on failure.
  */
 int tascam_pcm_hw_params(struct snd_pcm_substream *substream,
+<<<<<<< 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)
@@ -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)
+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 +483,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;
@@ -342,6 +516,7 @@ int tascam_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
   }
   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");
@@ -384,9 +559,65 @@ 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;
   }
+=======
+	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;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (do_stop)
     schedule_work(&tascam->stop_work);
@@ -404,16 +635,23 @@ 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;
 
+<<<<<<< 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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   INIT_WORK(&tascam->capture_work, tascam_capture_work_handler);
 

us144mkii_pcm.h

@@ -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

us144mkii_playback.c

@@ -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;
@@ -69,9 +66,16 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream)
   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;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   feedback_packets = 1;
 
@@ -79,6 +83,7 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream)
     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++) {
@@ -86,6 +91,17 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream)
       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;
+		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;
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME;
   total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS;
@@ -93,6 +109,7 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream)
   for (u = 0; u < NUM_PLAYBACK_URBS; u++) {
     struct urb *urb = tascam->playback_urbs[u];
 
+<<<<<<< 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;
@@ -101,6 +118,19 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream)
       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;
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   return 0;
 }
@@ -114,12 +144,21 @@ 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;
@@ -128,7 +167,8 @@ static snd_pcm_uframes_t tascam_playback_pointer(struct snd_pcm_substream *subst
   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;
 }
 
 /**
@@ -158,8 +198,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;
@@ -170,14 +209,28 @@ void playback_urb_complete(struct urb *urb)
   snd_pcm_uframes_t frames_to_copy;
   int ret, i;
 
+<<<<<<< HEAD
   if (urb->status) {
-		if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN &&
+    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
-		    urb->status != -ENODEV)
+        urb->status != -ESHUTDOWN && urb->status != -ENODEV)
-			dev_err_ratelimited(tascam->card->dev, "Playback URB failed: %d\n", urb->status);
+      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);
+		goto out;
+	}
+	if (!tascam || !atomic_read(&tascam->playback_active))
+		goto out;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   substream = tascam->playback_substream;
   if (!substream || !substream->runtime)
@@ -190,13 +243,30 @@ void playback_urb_complete(struct urb *urb)
     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];
+      frames_for_packet =
-			tascam->feedback_pattern_out_idx = (tascam->feedback_pattern_out_idx + 1) % FEEDBACK_ACCUMULATOR_SIZE;
+          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;
+		} 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;
@@ -204,29 +274,41 @@ void playback_urb_complete(struct urb *urb)
   }
   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;
+  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;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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 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,10 +317,49 @@ 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);
   }
+=======
+	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);
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 out:
   usb_put_urb(urb);
 }
@@ -254,8 +375,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;
@@ -266,14 +386,28 @@ void feedback_urb_complete(struct urb *urb)
   bool playback_period_elapsed = false;
   bool capture_period_elapsed = false;
 
+<<<<<<< HEAD
   if (urb->status) {
-		if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN &&
+    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
-		    urb->status != -ENODEV)
+        urb->status != -ESHUTDOWN && urb->status != -ENODEV)
-			dev_err_ratelimited(tascam->card->dev, "Feedback URB failed: %d\n", urb->status);
+      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);
+		goto out;
+	}
+	if (!tascam || !atomic_read(&tascam->playback_active))
+		goto out;
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   playback_ss = tascam->playback_substream;
   if (!playback_ss || !playback_ss->runtime)
@@ -298,17 +432,22 @@ void feedback_urb_complete(struct urb *urb)
     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);
+      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];
@@ -319,8 +458,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) {
+        if (tascam->feedback_consecutive_errors >
-					dev_err(tascam->card->dev, "Fatal: Feedback sync lost. Stopping stream.\n");
+            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)
@@ -330,28 +471,113 @@ 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;
   }
+=======
+		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;
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   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 is_ahead = (new_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE <
-		bool was_behind = (old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >= (FEEDBACK_ACCUMULATOR_SIZE / 2);
+                    (FEEDBACK_ACCUMULATOR_SIZE / 2);
+    bool was_behind = (old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >=
+                      (FEEDBACK_ACCUMULATOR_SIZE / 2);
 
     if (is_ahead && was_behind) {
-			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;
     }
   }
+=======
+	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;
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
   if (total_frames_in_urb > 0) {
     tascam->playback_frames_consumed += total_frames_in_urb;
@@ -359,8 +585,15 @@ void feedback_urb_complete(struct urb *urb)
       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);
+    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);
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
     if (current_period > tascam->last_period_pos) {
       tascam->last_period_pos = current_period;
@@ -368,14 +601,31 @@ void feedback_urb_complete(struct urb *urb)
     }
   }
 
-	if (atomic_read(&tascam->capture_active) && capture_rt && capture_rt->period_size > 0) {
+<<<<<<< HEAD
-		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;
       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;
+			capture_period_elapsed = true;
+		}
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 
 unlock_and_continue:
   spin_unlock_irqrestore(&tascam->lock, flags);
@@ -385,15 +635,30 @@ unlock_and_continue:
   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);
+    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);
+		usb_unanchor_urb(urb);
+		usb_put_urb(urb);
+	}
+>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
 out:
   usb_put_urb(urb);
 }