diff --git a/us144mkii.c b/us144mkii.c index cee36d1..db5d8f1 100644 --- a/us144mkii.c +++ b/us144mkii.c @@ -26,22 +26,14 @@ MODULE_LICENSE("GPL"); */ 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, -<<<<<<< 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); @@ -74,7 +66,6 @@ static DEVICE_ATTR_RO(driver_version); 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]) { @@ -129,67 +120,6 @@ 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; @@ -216,39 +146,21 @@ 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; -<<<<<<< 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); @@ -258,25 +170,15 @@ 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; -<<<<<<< HEAD f_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->feedback_urb_alloc_size, GFP_KERNEL, &f_urb->transfer_dma); @@ -290,22 +192,6 @@ 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++) { @@ -315,7 +201,6 @@ int tascam_alloc_urbs(struct tascam_card *tascam) { goto error; tascam->capture_urbs[i] = c_urb; -<<<<<<< HEAD c_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->capture_urb_alloc_size, GFP_KERNEL, &c_urb->transfer_dma); @@ -328,27 +213,11 @@ int tascam_alloc_urbs(struct tascam_card *tascam) { 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, 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; @@ -362,27 +231,10 @@ int tascam_alloc_urbs(struct tascam_card *tascam) { tascam_midi_in_urb_complete, 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; @@ -424,52 +276,6 @@ int tascam_alloc_urbs(struct tascam_card *tascam) { 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; @@ -479,16 +285,9 @@ 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); ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b usb_kill_anchored_urbs(&tascam->playback_anchor); usb_kill_anchored_urbs(&tascam->feedback_anchor); @@ -558,7 +357,6 @@ 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 @@ -574,24 +372,6 @@ 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; } @@ -615,7 +395,6 @@ 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. @@ -636,31 +415,6 @@ 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; } @@ -681,7 +435,6 @@ 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, -<<<<<<< HEAD const struct usb_device_id *usb_id) { struct usb_device *dev = interface_to_usbdev(intf); struct snd_card *card; @@ -706,29 +459,6 @@ static int tascam_probe(struct usb_interface *intf, 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"); @@ -748,7 +478,6 @@ static int tascam_probe(struct usb_interface *intf, return err; } -<<<<<<< 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]); @@ -780,49 +509,6 @@ static int tascam_probe(struct usb_interface *intf, 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); @@ -842,9 +528,9 @@ static int tascam_probe(struct usb_interface *intf, strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); if (dev->descriptor.idProduct == USB_PID_TASCAM_US144) { - strscpy(card->shortname, "TASCAM US144", sizeof(card->shortname)); + strscpy(card->shortname, "TASCAM US-144", sizeof(card->shortname)); } else if (dev->descriptor.idProduct == USB_PID_TASCAM_US144MKII) { - strscpy(card->shortname, "TASCAM US144MKII", sizeof(card->shortname)); + strscpy(card->shortname, "TASCAM US-144MKII", sizeof(card->shortname)); } else { strscpy(card->shortname, "TASCAM Unknown", sizeof(card->shortname)); } @@ -852,7 +538,6 @@ static int tascam_probe(struct usb_interface *intf, 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", @@ -871,19 +556,6 @@ static int tascam_probe(struct usb_interface *intf, 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) diff --git a/us144mkii.h b/us144mkii.h index 7313c59..01ad035 100644 --- a/us144mkii.h +++ b/us144mkii.h @@ -14,14 +14,11 @@ #include #define DRIVER_NAME "us144mkii" -#define DRIVER_VERSION "1.7.4" +#define DRIVER_VERSION "1.7.5" /* --- 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) --- */ @@ -38,7 +35,6 @@ #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, }; @@ -56,31 +52,11 @@ 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, @@ -89,16 +65,6 @@ 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 @@ -264,7 +230,6 @@ struct tascam_card { spinlock_t midi_out_lock; u8 midi_running_status; -<<<<<<< HEAD /* Shared state & Routing Matrix */ spinlock_t lock; atomic_t active_urbs; @@ -273,16 +238,6 @@ 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; diff --git a/us144mkii_capture.c b/us144mkii_capture.c index d215e39..6e42dda 100644 --- a/us144mkii_capture.c +++ b/us144mkii_capture.c @@ -69,20 +69,11 @@ static int tascam_capture_prepare(struct snd_pcm_substream *substream) { * Return: The current capture pointer position in frames. */ 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; @@ -125,25 +116,15 @@ const struct snd_pcm_ops tascam_capture_ops = { static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block) { int frame, bit; -<<<<<<< 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]; @@ -176,7 +157,6 @@ static void decode_tascam_capture_block(const u8 *src_block, s32 *dst_block) { * copies the final audio data into the ALSA capture ring buffer. This offloads * * the CPU-intensive decoding from the time-sensitive URB completion handlers. */ -<<<<<<< HEAD void tascam_capture_work_handler(struct work_struct *work) { struct tascam_card *tascam = container_of(work, struct tascam_card, capture_work); @@ -186,42 +166,21 @@ void tascam_capture_work_handler(struct work_struct *work) { 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"); 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; @@ -229,21 +188,10 @@ void tascam_capture_work_handler(struct work_struct *work) ? (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]; @@ -251,36 +199,17 @@ void tascam_capture_work_handler(struct work_struct *work) (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 + @@ -301,37 +230,6 @@ void tascam_capture_work_handler(struct work_struct *work) } 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 } /** @@ -347,7 +245,6 @@ void capture_urb_complete(struct urb *urb) { int ret; unsigned long flags; -<<<<<<< HEAD if (urb->status) { if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN && urb->status != -ENODEV && @@ -358,25 +255,11 @@ void capture_urb_complete(struct urb *urb) { } 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++) { @@ -385,22 +268,10 @@ 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); @@ -410,18 +281,6 @@ void capture_urb_complete(struct urb *urb) { 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); } diff --git a/us144mkii_controls.c b/us144mkii_controls.c index 4c365a2..05deb40 100644 --- a/us144mkii_controls.c +++ b/us144mkii_controls.c @@ -9,13 +9,8 @@ * Used by ALSA kcontrol elements to provide user-friendly names for * the playback routing options (e.g., "Playback 1-2", "Playback 3-4"). */ -<<<<<<< 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. @@ -23,11 +18,7 @@ static const char *const playback_source_texts[] = { "Playback 1-2", * 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 @@ -42,7 +33,6 @@ static const char *const capture_source_texts[] = { "Analog In", "Digital In" }; * Return: 0 on success. */ 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; @@ -53,19 +43,6 @@ static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, 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; - 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; ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b } /** @@ -80,14 +57,8 @@ static int tascam_playback_source_info(struct snd_kcontrol *kcontrol, * Return: 0 on success. */ 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; @@ -105,14 +76,8 @@ static int tascam_line_out_get(struct snd_kcontrol *kcontrol, * 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, -<<<<<<< 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; @@ -132,19 +97,11 @@ static int tascam_line_out_put(struct snd_kcontrol *kcontrol, * handling. */ static const struct snd_kcontrol_new tascam_line_out_control = { -<<<<<<< HEAD .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line OUTPUTS Source", .info = tascam_playback_source_info, .get = tascam_line_out_get, .put = tascam_line_out_put, -======= - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Line OUTPUTS Source", - .info = tascam_playback_source_info, - .get = tascam_line_out_get, - .put = tascam_line_out_put, ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b }; /** @@ -160,14 +117,8 @@ static const struct snd_kcontrol_new tascam_line_out_control = { * Return: 0 on success. */ static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, -<<<<<<< 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; @@ -186,14 +137,8 @@ static int tascam_digital_out_get(struct snd_kcontrol *kcontrol, * 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, -<<<<<<< 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; @@ -214,19 +159,11 @@ static int tascam_digital_out_put(struct snd_kcontrol *kcontrol, * handling. */ static const struct snd_kcontrol_new tascam_digital_out_control = { -<<<<<<< HEAD .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Digital OUTPUTS Source", .info = tascam_playback_source_info, .get = tascam_digital_out_get, .put = tascam_digital_out_put, -======= - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Digital OUTPUTS Source", - .info = tascam_playback_source_info, - .get = tascam_digital_out_get, - .put = tascam_digital_out_put, ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b }; /** @@ -241,7 +178,6 @@ static const struct snd_kcontrol_new tascam_digital_out_control = { * Return: 0 on success. */ 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; @@ -252,19 +188,6 @@ static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, 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; - 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; ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b } /** @@ -280,14 +203,8 @@ static int tascam_capture_source_info(struct snd_kcontrol *kcontrol, * Return: 0 on success. */ 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; @@ -306,14 +223,8 @@ static int tascam_capture_12_get(struct snd_kcontrol *kcontrol, * 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, -<<<<<<< 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; @@ -334,19 +245,11 @@ static int tascam_capture_12_put(struct snd_kcontrol *kcontrol, * handling. */ static const struct snd_kcontrol_new tascam_capture_12_control = { -<<<<<<< HEAD .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "ch1 and ch2 Source", .info = tascam_capture_source_info, .get = tascam_capture_12_get, .put = tascam_capture_12_put, -======= - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "ch1 and ch2 Source", - .info = tascam_capture_source_info, - .get = tascam_capture_12_get, - .put = tascam_capture_12_put, ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b }; /** @@ -362,14 +265,8 @@ static const struct snd_kcontrol_new tascam_capture_12_control = { * Return: 0 on success. */ 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; @@ -388,14 +285,8 @@ static int tascam_capture_34_get(struct snd_kcontrol *kcontrol, * 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, -<<<<<<< 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; @@ -416,19 +307,11 @@ static int tascam_capture_34_put(struct snd_kcontrol *kcontrol, * `tascam_capture_34_get`/`tascam_capture_34_put` for value handling. */ static const struct snd_kcontrol_new tascam_capture_34_control = { -<<<<<<< HEAD .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "ch3 and ch4 Source", .info = tascam_capture_source_info, .get = tascam_capture_34_get, .put = tascam_capture_34_put, -======= - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "ch3 and ch4 Source", - .info = tascam_capture_source_info, - .get = tascam_capture_34_get, - .put = tascam_capture_34_put, ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b }; /** @@ -442,22 +325,12 @@ static const struct snd_kcontrol_new tascam_capture_34_control = { * Return: 0 on success. */ 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 } /** @@ -473,22 +346,12 @@ static int tascam_samplerate_info(struct snd_kcontrol *kcontrol, * Return: 0 on success, or a negative error code on failure. */ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, -<<<<<<< HEAD struct snd_ctl_elem_value *ucontrol) { struct tascam_card *tascam = (struct tascam_card *)snd_kcontrol_chip(kcontrol); u8 *buf; int err; u32 rate = 0; -======= - struct snd_ctl_elem_value *ucontrol) -{ - struct tascam_card *tascam = - (struct tascam_card *)snd_kcontrol_chip(kcontrol); - u8 *buf; - int err; - u32 rate = 0; ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b if (tascam->current_rate > 0) { ucontrol->value.integer.value[0] = tascam->current_rate; @@ -499,16 +362,9 @@ static int tascam_samplerate_get(struct snd_kcontrol *kcontrol, if (!buf) return -ENOMEM; -<<<<<<< HEAD err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0), UAC_GET_CUR, RT_D2H_CLASS_EP, UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, buf, 3, USB_CTRL_TIMEOUT_MS); -======= - err = usb_control_msg(tascam->dev, usb_rcvctrlpipe(tascam->dev, 0), - UAC_GET_CUR, RT_D2H_CLASS_EP, - UAC_SAMPLING_FREQ_CONTROL, EP_AUDIO_IN, buf, 3, - USB_CTRL_TIMEOUT_MS); ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b if (err >= 3) rate = buf[0] | (buf[1] << 8) | (buf[2] << 16); @@ -546,7 +402,6 @@ static const struct snd_kcontrol_new tascam_samplerate_control = { int tascam_create_controls(struct tascam_card *tascam) { int err; -<<<<<<< HEAD err = snd_ctl_add(tascam->card, snd_ctl_new1(&tascam_line_out_control, tascam)); if (err < 0) @@ -568,29 +423,6 @@ int tascam_create_controls(struct tascam_card *tascam) { 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; } diff --git a/us144mkii_midi.c b/us144mkii_midi.c index 9f057f3..cfa7ab5 100644 --- a/us144mkii_midi.c +++ b/us144mkii_midi.c @@ -11,35 +11,19 @@ * the kfifo, processes it by stripping protocol-specific padding bytes, and * passes the clean MIDI data to the ALSA rawmidi subsystem. */ -<<<<<<< HEAD static void tascam_midi_in_work_handler(struct work_struct *work) { struct tascam_card *tascam = container_of(work, struct tascam_card, midi_in_work); u8 buf[MIDI_IN_BUF_SIZE]; unsigned int len; int i; -======= -static void tascam_midi_in_work_handler(struct work_struct *work) -{ - struct tascam_card *tascam = - container_of(work, struct tascam_card, midi_in_work); - 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, buf, sizeof(buf), &tascam->midi_in_lock); -======= - while (!kfifo_is_empty(&tascam->midi_in_fifo)) { - len = kfifo_out_spinlocked(&tascam->midi_in_fifo, buf, - sizeof(buf), &tascam->midi_in_lock); ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b if (len == 0) continue; @@ -52,7 +36,6 @@ 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; @@ -61,18 +44,6 @@ 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 } /** @@ -95,21 +66,12 @@ void tascam_midi_in_urb_complete(struct urb *urb) { goto out; } -<<<<<<< HEAD if (tascam && atomic_read(&tascam->midi_in_active) && urb->actual_length > 0) { kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer, urb->actual_length, &tascam->midi_in_lock); schedule_work(&tascam->midi_in_work); } -======= - if (tascam && atomic_read(&tascam->midi_in_active) && - urb->actual_length > 0) { - kfifo_in_spinlocked(&tascam->midi_in_fifo, urb->transfer_buffer, - urb->actual_length, &tascam->midi_in_lock); - schedule_work(&tascam->midi_in_work); - } ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b usb_get_urb(urb); usb_anchor_urb(urb, &tascam->midi_in_anchor); @@ -161,18 +123,10 @@ static int tascam_midi_in_close(struct snd_rawmidi_substream *substream) { * associated workqueue. */ 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) { @@ -180,7 +134,6 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, 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); @@ -199,30 +152,6 @@ static void tascam_midi_in_trigger(struct snd_rawmidi_substream *substream, 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 } /** @@ -251,22 +180,12 @@ void tascam_midi_out_urb_complete(struct urb *urb) { unsigned long flags; int i, urb_index = -1; -<<<<<<< HEAD if (urb->status) { if (urb->status != -ENOENT && urb->status != -ECONNRESET && urb->status != -ESHUTDOWN) dev_err_ratelimited(tascam->card->dev, "MIDI OUT URB failed: %d\n", urb->status); } -======= - if (urb->status) { - if (urb->status != -ENOENT && urb->status != -ECONNRESET && - urb->status != -ESHUTDOWN) - dev_err_ratelimited(tascam->card->dev, - "MIDI OUT URB failed: %d\n", - urb->status); - } ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b if (!tascam) goto out; @@ -278,18 +197,10 @@ 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); @@ -359,7 +270,6 @@ 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) { @@ -373,23 +283,6 @@ static void tascam_midi_out_work_handler(struct work_struct *work) { 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 } /** @@ -443,14 +336,8 @@ static void tascam_midi_out_drain(struct snd_rawmidi_substream *substream) { * 'up' parameter. */ 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); @@ -482,7 +369,6 @@ static const struct snd_rawmidi_ops tascam_midi_out_ops = { int tascam_create_midi(struct tascam_card *tascam) { int err; -<<<<<<< HEAD err = snd_rawmidi_new(tascam->card, "US144MKII MIDI", 0, 1, 1, &tascam->rmidi); if (err < 0) @@ -495,21 +381,6 @@ int tascam_create_midi(struct tascam_card *tascam) { &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 | diff --git a/us144mkii_pcm.c b/us144mkii_pcm.c index 164c36a..dd9a52d 100644 --- a/us144mkii_pcm.c +++ b/us144mkii_pcm.c @@ -15,7 +15,6 @@ * which helps the driver adjust the packet size dynamically to match the * device's consumption rate. */ -<<<<<<< HEAD static const unsigned int patterns_48khz[5][8] = {{5, 6, 6, 6, 6, 6, 6, 6}, {6, 6, 6, 6, 6, 6, 6, 6}, {6, 6, 6, 6, 6, 6, 6, 6}, @@ -55,49 +54,6 @@ const struct snd_pcm_hardware tascam_pcm_hw = { .period_bytes_max = 1024 * BYTES_PER_FRAME, .periods_min = 2, .periods_max = 1024, -======= -static const unsigned int patterns_48khz[5][8] = { { 5, 6, 6, 6, 6, 6, 6, 6 }, - { 6, 6, 6, 6, 6, 6, 6, 6 }, - { 6, 6, 6, 6, 6, 6, 6, 6 }, - { 6, 6, 6, 7, 6, 6, 6, 6 }, - { 7, 6, 6, 7, 6, 6, 7, 6 } }; -static const unsigned int patterns_96khz[5][8] = { - { 11, 12, 12, 12, 12, 12, 12, 12 }, - { 12, 12, 12, 12, 12, 12, 12, 12 }, - { 12, 12, 12, 12, 12, 12, 12, 12 }, - { 12, 12, 13, 12, 12, 12, 12, 12 }, - { 13, 12, 12, 13, 12, 12, 13, 12 } -}; -static const unsigned int patterns_88khz[5][8] = { - { 10, 11, 11, 11, 11, 11, 11, 11 }, - { 11, 11, 11, 11, 11, 11, 11, 11 }, - { 11, 11, 11, 11, 11, 11, 11, 11 }, - { 11, 11, 12, 11, 11, 11, 11, 11 }, - { 12, 11, 11, 12, 11, 11, 12, 11 } -}; -static const unsigned int patterns_44khz[5][8] = { { 5, 5, 5, 5, 5, 5, 5, 6 }, - { 5, 5, 5, 6, 5, 5, 5, 6 }, - { 5, 5, 6, 5, 6, 5, 5, 6 }, - { 5, 6, 5, 6, 5, 6, 5, 6 }, - { 6, 6, 6, 6, 6, 6, 6, 5 } }; - -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, ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b }; /** @@ -108,20 +64,11 @@ const struct snd_pcm_hardware tascam_pcm_hw = { * @frames: Number of frames to process. */ void process_playback_routing_us144mkii(struct tascam_card *tascam, -<<<<<<< HEAD const u8 *src_buffer, u8 *dst_buffer, size_t frames) { size_t f; const u8 *src_12, *src_34; u8 *dst_line, *dst_digital; -======= - const u8 *src_buffer, u8 *dst_buffer, - size_t frames) -{ - size_t f; - const u8 *src_12, *src_34; - u8 *dst_line, *dst_digital; ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b for (f = 0; f < frames; ++f) { src_12 = src_buffer + f * BYTES_PER_FRAME; @@ -150,20 +97,11 @@ 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); @@ -206,7 +144,6 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate) { 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}; @@ -233,35 +170,6 @@ 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) @@ -269,7 +177,6 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate) { dev_info(&dev->dev, "Configuring device for %d Hz\n", rate); -<<<<<<< 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); @@ -315,79 +222,15 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate) { 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: -<<<<<<< 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 } /** @@ -403,18 +246,10 @@ 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) @@ -516,7 +351,6 @@ 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"); @@ -563,61 +397,6 @@ int tascam_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { 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); @@ -638,20 +417,11 @@ start_rollback: 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); diff --git a/us144mkii_pcm.h b/us144mkii_pcm.h index c731087..3d026c7 100644 --- a/us144mkii_pcm.h +++ b/us144mkii_pcm.h @@ -97,13 +97,8 @@ int us144mkii_configure_device_for_rate(struct tascam_card *tascam, int rate); * @frames: Number of frames to process. */ 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 @@ -112,13 +107,8 @@ 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); -======= - const s32 *decoded_block, - s32 *routed_block); ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b /** * tascam_pcm_hw_params() - Configures hardware parameters for PCM streams. @@ -133,11 +123,7 @@ void process_capture_routing_us144mkii(struct tascam_card *tascam, * 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 snd_pcm_hw_params *params); ->>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b /** * tascam_pcm_hw_free() - Frees hardware parameters for PCM streams. diff --git a/us144mkii_playback.c b/us144mkii_playback.c index 9d2ef46..d93f703 100644 --- a/us144mkii_playback.c +++ b/us144mkii_playback.c @@ -66,16 +66,9 @@ 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; @@ -83,7 +76,6 @@ 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++) { @@ -91,17 +83,6 @@ 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; @@ -109,7 +90,6 @@ 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; @@ -118,19 +98,6 @@ 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; } @@ -145,20 +112,11 @@ static int tascam_playback_prepare(struct snd_pcm_substream *substream) { * Return: The current playback pointer position in frames. */ 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; @@ -209,7 +167,6 @@ 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 && urb->status != -ENODEV) @@ -219,18 +176,6 @@ void playback_urb_complete(struct urb *urb) { } 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) @@ -243,7 +188,6 @@ 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 @@ -254,19 +198,6 @@ void playback_urb_complete(struct urb *urb) { 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; @@ -274,21 +205,13 @@ 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; -======= - 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; @@ -322,44 +245,6 @@ void playback_urb_complete(struct urb *urb) { 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); } @@ -386,7 +271,6 @@ 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 && urb->status != -ENODEV) @@ -396,18 +280,6 @@ void feedback_urb_complete(struct urb *urb) { } 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) @@ -432,7 +304,6 @@ 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); @@ -481,70 +352,9 @@ void feedback_urb_complete(struct urb *urb) { 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 < @@ -559,25 +369,6 @@ void feedback_urb_complete(struct urb *urb) { 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; @@ -585,15 +376,9 @@ 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); -======= - 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; @@ -601,7 +386,6 @@ void feedback_urb_complete(struct urb *urb) { } } -<<<<<<< HEAD if (atomic_read(&tascam->capture_active) && capture_rt && capture_rt->period_size > 0) { u64 current_capture_period = @@ -612,20 +396,6 @@ void feedback_urb_complete(struct urb *urb) { 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); @@ -635,7 +405,6 @@ 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); @@ -646,19 +415,6 @@ unlock_and_continue: 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); }