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

potential support for US-144

This commit is contained in:
Šerif Rami 2025-08-03 22:59:41 +02:00
parent 652814585c
commit 1f8b9c3fd9
4 changed files with 185 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
us144mkii.c
View File

@ -8,7 +8,7 @@
MODULE_AUTHOR("Šerif Rami <ramiserifpersia@gmail.com>"); MODULE_AUTHOR("Šerif Rami <ramiserifpersia@gmail.com>");
MODULE_DESCRIPTION("ALSA Driver for TASCAM US-144MKII"); MODULE_DESCRIPTION("ALSA Driver for TASCAM US-144MKII");
MODULE_LICENSE("GPL v2"); MODULE_LICENSE("GPL");
/** /**
* @brief Module parameters for ALSA card instantiation. * @brief Module parameters for ALSA card instantiation.
@ -26,13 +26,14 @@ MODULE_LICENSE("GPL v2");
*/ */
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; static bool enable[SNDRV_CARDS] = { 1, [1 ...(SNDRV_CARDS - 1)] = 0 };
static int dev_idx; static int dev_idx;
static struct usb_driver tascam_alsa_driver; static struct usb_driver tascam_alsa_driver;
/* --- Forward Declarations --- */ /* --- 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,
const struct usb_device_id *usb_id);
static void tascam_disconnect(struct usb_interface *intf); static void tascam_disconnect(struct usb_interface *intf);
static int tascam_suspend(struct usb_interface *intf, pm_message_t message); static int tascam_suspend(struct usb_interface *intf, pm_message_t message);
static int tascam_resume(struct usb_interface *intf); static int tascam_resume(struct usb_interface *intf);
@ -55,7 +56,6 @@ static ssize_t driver_version_show(struct device *dev,
} }
static DEVICE_ATTR_RO(driver_version); static DEVICE_ATTR_RO(driver_version);
/** /**
* tascam_free_urbs() - Free all allocated URBs and associated buffers. * tascam_free_urbs() - Free all allocated URBs and associated buffers.
* @tascam: the tascam_card instance * @tascam: the tascam_card instance
@ -71,7 +71,8 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->playback_anchor); usb_kill_anchored_urbs(&tascam->playback_anchor);
for (i = 0; i < NUM_PLAYBACK_URBS; i++) { for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
if (tascam->playback_urbs[i]) { if (tascam->playback_urbs[i]) {
usb_free_coherent(tascam->dev, tascam->playback_urb_alloc_size, usb_free_coherent(
tascam->dev, tascam->playback_urb_alloc_size,
tascam->playback_urbs[i]->transfer_buffer, tascam->playback_urbs[i]->transfer_buffer,
tascam->playback_urbs[i]->transfer_dma); tascam->playback_urbs[i]->transfer_dma);
usb_free_urb(tascam->playback_urbs[i]); usb_free_urb(tascam->playback_urbs[i]);
@ -82,7 +83,8 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->feedback_anchor); usb_kill_anchored_urbs(&tascam->feedback_anchor);
for (i = 0; i < NUM_FEEDBACK_URBS; i++) { for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
if (tascam->feedback_urbs[i]) { if (tascam->feedback_urbs[i]) {
usb_free_coherent(tascam->dev, tascam->feedback_urb_alloc_size, usb_free_coherent(
tascam->dev, tascam->feedback_urb_alloc_size,
tascam->feedback_urbs[i]->transfer_buffer, tascam->feedback_urbs[i]->transfer_buffer,
tascam->feedback_urbs[i]->transfer_dma); tascam->feedback_urbs[i]->transfer_dma);
usb_free_urb(tascam->feedback_urbs[i]); usb_free_urb(tascam->feedback_urbs[i]);
@ -93,7 +95,8 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->capture_anchor); usb_kill_anchored_urbs(&tascam->capture_anchor);
for (i = 0; i < NUM_CAPTURE_URBS; i++) { for (i = 0; i < NUM_CAPTURE_URBS; i++) {
if (tascam->capture_urbs[i]) { if (tascam->capture_urbs[i]) {
usb_free_coherent(tascam->dev, tascam->capture_urb_alloc_size, usb_free_coherent(
tascam->dev, tascam->capture_urb_alloc_size,
tascam->capture_urbs[i]->transfer_buffer, tascam->capture_urbs[i]->transfer_buffer,
tascam->capture_urbs[i]->transfer_dma); tascam->capture_urbs[i]->transfer_dma);
usb_free_urb(tascam->capture_urbs[i]); usb_free_urb(tascam->capture_urbs[i]);
@ -104,7 +107,8 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->midi_in_anchor); usb_kill_anchored_urbs(&tascam->midi_in_anchor);
for (i = 0; i < NUM_MIDI_IN_URBS; i++) { for (i = 0; i < NUM_MIDI_IN_URBS; i++) {
if (tascam->midi_in_urbs[i]) { if (tascam->midi_in_urbs[i]) {
usb_free_coherent(tascam->dev, MIDI_IN_BUF_SIZE, usb_free_coherent(
tascam->dev, MIDI_IN_BUF_SIZE,
tascam->midi_in_urbs[i]->transfer_buffer, tascam->midi_in_urbs[i]->transfer_buffer,
tascam->midi_in_urbs[i]->transfer_dma); tascam->midi_in_urbs[i]->transfer_dma);
usb_free_urb(tascam->midi_in_urbs[i]); usb_free_urb(tascam->midi_in_urbs[i]);
@ -115,7 +119,8 @@ void tascam_free_urbs(struct tascam_card *tascam)
usb_kill_anchored_urbs(&tascam->midi_out_anchor); usb_kill_anchored_urbs(&tascam->midi_out_anchor);
for (i = 0; i < NUM_MIDI_OUT_URBS; i++) { for (i = 0; i < NUM_MIDI_OUT_URBS; i++) {
if (tascam->midi_out_urbs[i]) { if (tascam->midi_out_urbs[i]) {
usb_free_coherent(tascam->dev, MIDI_OUT_BUF_SIZE, usb_free_coherent(
tascam->dev, MIDI_OUT_BUF_SIZE,
tascam->midi_out_urbs[i]->transfer_buffer, tascam->midi_out_urbs[i]->transfer_buffer,
tascam->midi_out_urbs[i]->transfer_dma); tascam->midi_out_urbs[i]->transfer_dma);
usb_free_urb(tascam->midi_out_urbs[i]); usb_free_urb(tascam->midi_out_urbs[i]);
@ -150,16 +155,19 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
size_t max_packet_size; size_t max_packet_size;
max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME; max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME;
tascam->playback_urb_alloc_size = max_packet_size * PLAYBACK_URB_PACKETS; tascam->playback_urb_alloc_size =
max_packet_size * PLAYBACK_URB_PACKETS;
for (i = 0; i < NUM_PLAYBACK_URBS; i++) { for (i = 0; i < NUM_PLAYBACK_URBS; i++) {
struct urb *urb = usb_alloc_urb(PLAYBACK_URB_PACKETS, GFP_KERNEL); struct urb *urb =
usb_alloc_urb(PLAYBACK_URB_PACKETS, GFP_KERNEL);
if (!urb) if (!urb)
goto error; goto error;
tascam->playback_urbs[i] = urb; tascam->playback_urbs[i] = urb;
urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->playback_urb_alloc_size, urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, tascam->playback_urb_alloc_size,
GFP_KERNEL, &urb->transfer_dma); GFP_KERNEL, &urb->transfer_dma);
if (!urb->transfer_buffer) if (!urb->transfer_buffer)
goto error; goto error;
@ -172,22 +180,26 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
urb->complete = playback_urb_complete; urb->complete = playback_urb_complete;
} }
tascam->feedback_urb_alloc_size = FEEDBACK_PACKET_SIZE * MAX_FEEDBACK_PACKETS; tascam->feedback_urb_alloc_size =
FEEDBACK_PACKET_SIZE * MAX_FEEDBACK_PACKETS;
for (i = 0; i < NUM_FEEDBACK_URBS; i++) { for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
struct urb *f_urb = usb_alloc_urb(MAX_FEEDBACK_PACKETS, GFP_KERNEL); struct urb *f_urb =
usb_alloc_urb(MAX_FEEDBACK_PACKETS, GFP_KERNEL);
if (!f_urb) if (!f_urb)
goto error; goto error;
tascam->feedback_urbs[i] = f_urb; tascam->feedback_urbs[i] = f_urb;
f_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->feedback_urb_alloc_size, f_urb->transfer_buffer = usb_alloc_coherent(
tascam->dev, tascam->feedback_urb_alloc_size,
GFP_KERNEL, &f_urb->transfer_dma); GFP_KERNEL, &f_urb->transfer_dma);
if (!f_urb->transfer_buffer) if (!f_urb->transfer_buffer)
goto error; goto error;
f_urb->dev = tascam->dev; f_urb->dev = tascam->dev;
f_urb->pipe = usb_rcvisocpipe(tascam->dev, EP_PLAYBACK_FEEDBACK); f_urb->pipe =
usb_rcvisocpipe(tascam->dev, EP_PLAYBACK_FEEDBACK);
f_urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; f_urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
f_urb->interval = 4; f_urb->interval = 4;
f_urb->context = tascam; f_urb->context = tascam;
@ -202,8 +214,9 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
goto error; goto error;
tascam->capture_urbs[i] = c_urb; tascam->capture_urbs[i] = c_urb;
c_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, tascam->capture_urb_alloc_size, c_urb->transfer_buffer = usb_alloc_coherent(
GFP_KERNEL, &c_urb->transfer_dma); tascam->dev, tascam->capture_urb_alloc_size, GFP_KERNEL,
&c_urb->transfer_dma);
if (!c_urb->transfer_buffer) if (!c_urb->transfer_buffer)
goto error; goto error;
@ -211,8 +224,7 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
usb_rcvbulkpipe(tascam->dev, EP_AUDIO_IN), usb_rcvbulkpipe(tascam->dev, EP_AUDIO_IN),
c_urb->transfer_buffer, c_urb->transfer_buffer,
tascam->capture_urb_alloc_size, tascam->capture_urb_alloc_size,
capture_urb_complete, capture_urb_complete, tascam);
tascam);
c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
} }
@ -223,14 +235,15 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
if (!m_urb) if (!m_urb)
goto error; goto error;
tascam->midi_in_urbs[i] = m_urb; tascam->midi_in_urbs[i] = m_urb;
m_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, m_urb->transfer_buffer =
MIDI_IN_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma); usb_alloc_coherent(tascam->dev, MIDI_IN_BUF_SIZE,
GFP_KERNEL, &m_urb->transfer_dma);
if (!m_urb->transfer_buffer) if (!m_urb->transfer_buffer)
goto error; 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, 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; m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
} }
@ -240,35 +253,45 @@ int tascam_alloc_urbs(struct tascam_card *tascam)
if (!m_urb) if (!m_urb)
goto error; goto error;
tascam->midi_out_urbs[i] = m_urb; tascam->midi_out_urbs[i] = m_urb;
m_urb->transfer_buffer = usb_alloc_coherent(tascam->dev, m_urb->transfer_buffer =
MIDI_OUT_BUF_SIZE, GFP_KERNEL, &m_urb->transfer_dma); usb_alloc_coherent(tascam->dev, MIDI_OUT_BUF_SIZE,
GFP_KERNEL, &m_urb->transfer_dma);
if (!m_urb->transfer_buffer) if (!m_urb->transfer_buffer)
goto error; goto error;
usb_fill_bulk_urb(m_urb, tascam->dev, usb_fill_bulk_urb(m_urb, tascam->dev,
usb_sndbulkpipe(tascam->dev, EP_MIDI_OUT), usb_sndbulkpipe(tascam->dev, EP_MIDI_OUT),
m_urb->transfer_buffer, 0, /* length set later */ m_urb->transfer_buffer,
tascam_midi_out_urb_complete, 0, /* length set later */
tascam); tascam_midi_out_urb_complete, tascam);
m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
} }
tascam->capture_ring_buffer = kmalloc(CAPTURE_RING_BUFFER_SIZE, GFP_KERNEL); tascam->capture_ring_buffer =
kmalloc(CAPTURE_RING_BUFFER_SIZE, GFP_KERNEL);
if (!tascam->capture_ring_buffer) if (!tascam->capture_ring_buffer)
goto error; 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) if (!tascam->capture_decode_raw_block)
goto error; 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) if (!tascam->capture_decode_dst_block)
goto error; 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) if (!tascam->playback_routing_buffer)
goto error; 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) if (!tascam->capture_routing_buffer)
goto error; goto error;
@ -282,7 +305,8 @@ error:
void tascam_stop_work_handler(struct work_struct *work) void tascam_stop_work_handler(struct work_struct *work)
{ {
struct tascam_card *tascam = container_of(work, struct tascam_card, stop_work); struct tascam_card *tascam =
container_of(work, struct tascam_card, stop_work);
usb_kill_anchored_urbs(&tascam->playback_anchor); usb_kill_anchored_urbs(&tascam->playback_anchor);
usb_kill_anchored_urbs(&tascam->feedback_anchor); usb_kill_anchored_urbs(&tascam->feedback_anchor);
@ -358,8 +382,7 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
* command before host-initiated suspend can leave the device in an * command before host-initiated suspend can leave the device in an
* unstable state, leading to system freezes on idle (autosuspend). * 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 */ 0x00, /* bRequest */
0x40, /* bmRequestType: H2D, Vendor, Device */ 0x40, /* bmRequestType: H2D, Vendor, Device */
0x0044, /* wValue */ 0x0044, /* wValue */
@ -368,7 +391,8 @@ static int tascam_suspend(struct usb_interface *intf, pm_message_t message)
0, /* size */ 0, /* size */
1000); /* timeout */ 1000); /* timeout */
if (err < 0) if (err < 0)
dev_err(&intf->dev, "failed to send deep sleep command: %d\n", err); dev_err(&intf->dev, "failed to send deep sleep command: %d\n",
err);
return 0; return 0;
} }
@ -399,20 +423,23 @@ static int tascam_resume(struct usb_interface *intf)
*/ */
err = usb_set_interface(tascam->dev, 0, 1); err = usb_set_interface(tascam->dev, 0, 1);
if (err < 0) { if (err < 0) {
dev_err(&intf->dev, "resume: failed to set alt setting on intf 0: %d\n", dev_err(&intf->dev,
"resume: failed to set alt setting on intf 0: %d\n",
err); err);
return err; return err;
} }
err = usb_set_interface(tascam->dev, 1, 1); err = usb_set_interface(tascam->dev, 1, 1);
if (err < 0) { if (err < 0) {
dev_err(&intf->dev, "resume: failed to set alt setting on intf 1: %d\n", dev_err(&intf->dev,
"resume: failed to set alt setting on intf 1: %d\n",
err); err);
return err; return err;
} }
/* Re-configure the sample rate if one was previously active */ /* Re-configure the sample rate if one was previously active */
if (tascam->current_rate > 0) if (tascam->current_rate > 0)
us144mkii_configure_device_for_rate(tascam, tascam->current_rate); us144mkii_configure_device_for_rate(tascam,
tascam->current_rate);
return 0; return 0;
} }
@ -432,7 +459,8 @@ static int tascam_resume(struct usb_interface *intf)
* *
* Return: 0 on success, or a negative error code on failure. * 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,
const struct usb_device_id *usb_id)
{ {
struct usb_device *dev = interface_to_usbdev(intf); struct usb_device *dev = interface_to_usbdev(intf);
struct snd_card *card; struct snd_card *card;
@ -441,10 +469,11 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
char *handshake_buf; char *handshake_buf;
if (dev->speed != USB_SPEED_HIGH) 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) { if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
tascam = usb_get_intfdata(usb_ifnum_to_if(dev, 0)); tascam = usb_get_intfdata(usb_ifnum_to_if(dev, 0));
if (tascam) { if (tascam) {
usb_set_intfdata(intf, tascam); usb_set_intfdata(intf, tascam);
@ -467,15 +496,20 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
if (!handshake_buf) if (!handshake_buf)
return -ENOMEM; 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) { if (err < 0) {
dev_err(&dev->dev, "Handshake read failed with %d\n", err); dev_err(&dev->dev, "Handshake read failed with %d\n", err);
kfree(handshake_buf); kfree(handshake_buf);
return err; return err;
} }
if (handshake_buf[0] != 0x12 && handshake_buf[0] != 0x16 && handshake_buf[0] != 0x30) { if (handshake_buf[0] != 0x12 && handshake_buf[0] != 0x16 &&
dev_err(&dev->dev, "Unexpected handshake value: 0x%x\n", handshake_buf[0]); handshake_buf[0] != 0x30) {
dev_err(&dev->dev, "Unexpected handshake value: 0x%x\n",
handshake_buf[0]);
kfree(handshake_buf); kfree(handshake_buf);
return -ENODEV; return -ENODEV;
} }
@ -483,17 +517,22 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
err = usb_set_interface(dev, 0, 1); err = usb_set_interface(dev, 0, 1);
if (err < 0) { if (err < 0) {
dev_err(&dev->dev, "Failed to set alt setting 1 on interface 0: %d\n", err); dev_err(&dev->dev,
"Failed to set alt setting 1 on interface 0: %d\n",
err);
return err; return err;
} }
err = usb_set_interface(dev, 1, 1); err = usb_set_interface(dev, 1, 1);
if (err < 0) { if (err < 0) {
dev_err(&dev->dev, "Failed to set alt setting 1 on interface 1: %d\n", err); dev_err(&dev->dev,
"Failed to set alt setting 1 on interface 1: %d\n",
err);
return err; 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) { if (err < 0) {
dev_err(&dev->dev, "Failed to create sound card instance\n"); dev_err(&dev->dev, "Failed to create sound card instance\n");
return err; return err;
@ -521,15 +560,22 @@ static int tascam_probe(struct usb_interface *intf, const struct usb_device_id *
card->private_free = tascam_card_private_free; card->private_free = tascam_card_private_free;
strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 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", 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));
err = device_create_file(&dev->dev, &dev_attr_driver_version); err = device_create_file(&dev->dev, &dev_attr_driver_version);
if (err < 0) 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); err = snd_pcm_new(card, "US144MKII PCM", 0, 1, 1, &tascam->pcm);
if (err < 0) if (err < 0)
@ -598,6 +644,7 @@ static void tascam_disconnect(struct usb_interface *intf)
} }
static const struct usb_device_id tascam_usb_ids[] = { 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) }, { USB_DEVICE(USB_VID_TASCAM, USB_PID_TASCAM_US144MKII) },
{ /* Terminating entry */ } { /* Terminating entry */ }
}; };

3
us144mkii.h
View File

@ -18,6 +18,7 @@
/* --- USB Device Identification --- */ /* --- USB Device Identification --- */
#define USB_VID_TASCAM 0x0644 #define USB_VID_TASCAM 0x0644
#define USB_PID_TASCAM_US144 0x800f
#define USB_PID_TASCAM_US144MKII 0x8020 #define USB_PID_TASCAM_US144MKII 0x8020
/* --- USB Endpoints (Alternate Setting 1) --- */ /* --- USB Endpoints (Alternate Setting 1) --- */
@ -68,8 +69,6 @@ enum tascam_register {
#define REG_VAL_ENABLE 0x0101 #define REG_VAL_ENABLE 0x0101
/* --- URB Configuration --- */ /* --- URB Configuration --- */
#define NUM_PLAYBACK_URBS 8 #define NUM_PLAYBACK_URBS 8
#define PLAYBACK_URB_PACKETS 4 #define PLAYBACK_URB_PACKETS 4

5
us144mkii_capture.c
View File

@ -85,7 +85,10 @@ static snd_pcm_uframes_t tascam_capture_pointer(struct snd_pcm_substream *substr
pos = tascam->capture_frames_processed; pos = tascam->capture_frames_processed;
spin_unlock_irqrestore(&tascam->lock, flags); 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;
} }
/** /**

3
us144mkii_playback.c
View File

@ -128,7 +128,8 @@ static snd_pcm_uframes_t tascam_playback_pointer(struct snd_pcm_substream *subst
pos = tascam->playback_frames_consumed; pos = tascam->playback_frames_consumed;
spin_unlock_irqrestore(&tascam->lock, flags); 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;
} }
/** /**