Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de>
0004  */
0005 
0006 #include <linux/slab.h>
0007 #include <linux/usb.h>
0008 #include <linux/usb/audio.h>
0009 #include <linux/module.h>
0010 #include <sound/core.h>
0011 #include <sound/hwdep.h>
0012 #include <sound/pcm.h>
0013 #include <sound/initval.h>
0014 #define MODNAME "US122L"
0015 #include "usb_stream.c"
0016 #include "../usbaudio.h"
0017 #include "../midi.h"
0018 #include "us122l.h"
0019 
0020 MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>");
0021 MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS" Version 0.5");
0022 MODULE_LICENSE("GPL");
0023 
0024 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;  /* Index 0-max */
0025 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;   /* Id for this card */
0026                             /* Enable this card */
0027 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
0028 
0029 module_param_array(index, int, NULL, 0444);
0030 MODULE_PARM_DESC(index, "Index value for "NAME_ALLCAPS".");
0031 module_param_array(id, charp, NULL, 0444);
0032 MODULE_PARM_DESC(id, "ID string for "NAME_ALLCAPS".");
0033 module_param_array(enable, bool, NULL, 0444);
0034 MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS".");
0035 
0036 /* driver_info flags */
0037 #define US122L_FLAG_US144   BIT(0)
0038 
0039 static int snd_us122l_card_used[SNDRV_CARDS];
0040 
0041 static int us122l_create_usbmidi(struct snd_card *card)
0042 {
0043     static const struct snd_usb_midi_endpoint_info quirk_data = {
0044         .out_ep = 4,
0045         .in_ep = 3,
0046         .out_cables =   0x001,
0047         .in_cables =    0x001
0048     };
0049     static const struct snd_usb_audio_quirk quirk = {
0050         .vendor_name =  "US122L",
0051         .product_name = NAME_ALLCAPS,
0052         .ifnum =    1,
0053         .type = QUIRK_MIDI_US122L,
0054         .data = &quirk_data
0055     };
0056     struct usb_device *dev = US122L(card)->dev;
0057     struct usb_interface *iface = usb_ifnum_to_if(dev, 1);
0058 
0059     return snd_usbmidi_create(card, iface,
0060                   &US122L(card)->midi_list, &quirk);
0061 }
0062 
0063 static int us144_create_usbmidi(struct snd_card *card)
0064 {
0065     static const struct snd_usb_midi_endpoint_info quirk_data = {
0066         .out_ep = 4,
0067         .in_ep = 3,
0068         .out_cables =   0x001,
0069         .in_cables =    0x001
0070     };
0071     static const struct snd_usb_audio_quirk quirk = {
0072         .vendor_name =  "US144",
0073         .product_name = NAME_ALLCAPS,
0074         .ifnum =    0,
0075         .type = QUIRK_MIDI_US122L,
0076         .data = &quirk_data
0077     };
0078     struct usb_device *dev = US122L(card)->dev;
0079     struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
0080 
0081     return snd_usbmidi_create(card, iface,
0082                   &US122L(card)->midi_list, &quirk);
0083 }
0084 
0085 static void pt_info_set(struct usb_device *dev, u8 v)
0086 {
0087     int ret;
0088 
0089     ret = usb_control_msg_send(dev, 0, 'I',
0090                    USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0091                    v, 0, NULL, 0, 1000, GFP_NOIO);
0092     snd_printdd(KERN_DEBUG "%i\n", ret);
0093 }
0094 
0095 static void usb_stream_hwdep_vm_open(struct vm_area_struct *area)
0096 {
0097     struct us122l *us122l = area->vm_private_data;
0098 
0099     atomic_inc(&us122l->mmap_count);
0100     snd_printdd(KERN_DEBUG "%i\n", atomic_read(&us122l->mmap_count));
0101 }
0102 
0103 static vm_fault_t usb_stream_hwdep_vm_fault(struct vm_fault *vmf)
0104 {
0105     unsigned long offset;
0106     struct page *page;
0107     void *vaddr;
0108     struct us122l *us122l = vmf->vma->vm_private_data;
0109     struct usb_stream *s;
0110 
0111     mutex_lock(&us122l->mutex);
0112     s = us122l->sk.s;
0113     if (!s)
0114         goto unlock;
0115 
0116     offset = vmf->pgoff << PAGE_SHIFT;
0117     if (offset < PAGE_ALIGN(s->read_size)) {
0118         vaddr = (char *)s + offset;
0119     } else {
0120         offset -= PAGE_ALIGN(s->read_size);
0121         if (offset >= PAGE_ALIGN(s->write_size))
0122             goto unlock;
0123 
0124         vaddr = us122l->sk.write_page + offset;
0125     }
0126     page = virt_to_page(vaddr);
0127 
0128     get_page(page);
0129     mutex_unlock(&us122l->mutex);
0130 
0131     vmf->page = page;
0132 
0133     return 0;
0134 unlock:
0135     mutex_unlock(&us122l->mutex);
0136     return VM_FAULT_SIGBUS;
0137 }
0138 
0139 static void usb_stream_hwdep_vm_close(struct vm_area_struct *area)
0140 {
0141     struct us122l *us122l = area->vm_private_data;
0142 
0143     atomic_dec(&us122l->mmap_count);
0144     snd_printdd(KERN_DEBUG "%i\n", atomic_read(&us122l->mmap_count));
0145 }
0146 
0147 static const struct vm_operations_struct usb_stream_hwdep_vm_ops = {
0148     .open = usb_stream_hwdep_vm_open,
0149     .fault = usb_stream_hwdep_vm_fault,
0150     .close = usb_stream_hwdep_vm_close,
0151 };
0152 
0153 static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
0154 {
0155     struct us122l   *us122l = hw->private_data;
0156     struct usb_interface *iface;
0157 
0158     snd_printdd(KERN_DEBUG "%p %p\n", hw, file);
0159     if (hw->used >= 2)
0160         return -EBUSY;
0161 
0162     if (!us122l->first)
0163         us122l->first = file;
0164 
0165     if (us122l->is_us144) {
0166         iface = usb_ifnum_to_if(us122l->dev, 0);
0167         usb_autopm_get_interface(iface);
0168     }
0169     iface = usb_ifnum_to_if(us122l->dev, 1);
0170     usb_autopm_get_interface(iface);
0171     return 0;
0172 }
0173 
0174 static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file)
0175 {
0176     struct us122l   *us122l = hw->private_data;
0177     struct usb_interface *iface;
0178 
0179     snd_printdd(KERN_DEBUG "%p %p\n", hw, file);
0180 
0181     if (us122l->is_us144) {
0182         iface = usb_ifnum_to_if(us122l->dev, 0);
0183         usb_autopm_put_interface(iface);
0184     }
0185     iface = usb_ifnum_to_if(us122l->dev, 1);
0186     usb_autopm_put_interface(iface);
0187     if (us122l->first == file)
0188         us122l->first = NULL;
0189     mutex_lock(&us122l->mutex);
0190     if (us122l->master == file)
0191         us122l->master = us122l->slave;
0192 
0193     us122l->slave = NULL;
0194     mutex_unlock(&us122l->mutex);
0195     return 0;
0196 }
0197 
0198 static int usb_stream_hwdep_mmap(struct snd_hwdep *hw,
0199                  struct file *filp, struct vm_area_struct *area)
0200 {
0201     unsigned long   size = area->vm_end - area->vm_start;
0202     struct us122l   *us122l = hw->private_data;
0203     unsigned long offset;
0204     struct usb_stream *s;
0205     int err = 0;
0206     bool read;
0207 
0208     offset = area->vm_pgoff << PAGE_SHIFT;
0209     mutex_lock(&us122l->mutex);
0210     s = us122l->sk.s;
0211     read = offset < s->read_size;
0212     if (read && area->vm_flags & VM_WRITE) {
0213         err = -EPERM;
0214         goto out;
0215     }
0216     snd_printdd(KERN_DEBUG "%lu %u\n", size,
0217             read ? s->read_size : s->write_size);
0218     /* if userspace tries to mmap beyond end of our buffer, fail */
0219     if (size > PAGE_ALIGN(read ? s->read_size : s->write_size)) {
0220         snd_printk(KERN_WARNING "%lu > %u\n", size,
0221                read ? s->read_size : s->write_size);
0222         err = -EINVAL;
0223         goto out;
0224     }
0225 
0226     area->vm_ops = &usb_stream_hwdep_vm_ops;
0227     area->vm_flags |= VM_DONTDUMP;
0228     if (!read)
0229         area->vm_flags |= VM_DONTEXPAND;
0230     area->vm_private_data = us122l;
0231     atomic_inc(&us122l->mmap_count);
0232 out:
0233     mutex_unlock(&us122l->mutex);
0234     return err;
0235 }
0236 
0237 static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw,
0238                       struct file *file, poll_table *wait)
0239 {
0240     struct us122l   *us122l = hw->private_data;
0241     unsigned int    *polled;
0242     __poll_t    mask;
0243 
0244     poll_wait(file, &us122l->sk.sleep, wait);
0245 
0246     mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM | EPOLLERR;
0247     if (mutex_trylock(&us122l->mutex)) {
0248         struct usb_stream *s = us122l->sk.s;
0249 
0250         if (s && s->state == usb_stream_ready) {
0251             if (us122l->first == file)
0252                 polled = &s->periods_polled;
0253             else
0254                 polled = &us122l->second_periods_polled;
0255             if (*polled != s->periods_done) {
0256                 *polled = s->periods_done;
0257                 mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM;
0258             } else {
0259                 mask = 0;
0260             }
0261         }
0262         mutex_unlock(&us122l->mutex);
0263     }
0264     return mask;
0265 }
0266 
0267 static void us122l_stop(struct us122l *us122l)
0268 {
0269     struct list_head *p;
0270 
0271     list_for_each(p, &us122l->midi_list)
0272         snd_usbmidi_input_stop(p);
0273 
0274     usb_stream_stop(&us122l->sk);
0275     usb_stream_free(&us122l->sk);
0276 }
0277 
0278 static int us122l_set_sample_rate(struct usb_device *dev, int rate)
0279 {
0280     unsigned int ep = 0x81;
0281     unsigned char data[3];
0282     int err;
0283 
0284     data[0] = rate;
0285     data[1] = rate >> 8;
0286     data[2] = rate >> 16;
0287     err = usb_control_msg_send(dev, 0, UAC_SET_CUR,
0288                    USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
0289                    UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3,
0290                    1000, GFP_NOIO);
0291     if (err)
0292         snd_printk(KERN_ERR "%d: cannot set freq %d to ep 0x%x\n",
0293                dev->devnum, rate, ep);
0294     return err;
0295 }
0296 
0297 static bool us122l_start(struct us122l *us122l,
0298              unsigned int rate, unsigned int period_frames)
0299 {
0300     struct list_head *p;
0301     int err;
0302     unsigned int use_packsize = 0;
0303     bool success = false;
0304 
0305     if (us122l->dev->speed == USB_SPEED_HIGH) {
0306         /* The us-122l's descriptor defaults to iso max_packsize 78,
0307            which isn't needed for samplerates <= 48000.
0308            Lets save some memory:
0309         */
0310         switch (rate) {
0311         case 44100:
0312             use_packsize = 36;
0313             break;
0314         case 48000:
0315             use_packsize = 42;
0316             break;
0317         case 88200:
0318             use_packsize = 72;
0319             break;
0320         }
0321     }
0322     if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2,
0323                 rate, use_packsize, period_frames, 6))
0324         goto out;
0325 
0326     err = us122l_set_sample_rate(us122l->dev, rate);
0327     if (err < 0) {
0328         us122l_stop(us122l);
0329         snd_printk(KERN_ERR "us122l_set_sample_rate error\n");
0330         goto out;
0331     }
0332     err = usb_stream_start(&us122l->sk);
0333     if (err < 0) {
0334         us122l_stop(us122l);
0335         snd_printk(KERN_ERR "%s error %i\n", __func__, err);
0336         goto out;
0337     }
0338     list_for_each(p, &us122l->midi_list)
0339         snd_usbmidi_input_start(p);
0340     success = true;
0341 out:
0342     return success;
0343 }
0344 
0345 static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
0346                   unsigned int cmd, unsigned long arg)
0347 {
0348     struct usb_stream_config cfg;
0349     struct us122l *us122l = hw->private_data;
0350     struct usb_stream *s;
0351     unsigned int min_period_frames;
0352     int err = 0;
0353     bool high_speed;
0354 
0355     if (cmd != SNDRV_USB_STREAM_IOCTL_SET_PARAMS)
0356         return -ENOTTY;
0357 
0358     if (copy_from_user(&cfg, (void __user *)arg, sizeof(cfg)))
0359         return -EFAULT;
0360 
0361     if (cfg.version != USB_STREAM_INTERFACE_VERSION)
0362         return -ENXIO;
0363 
0364     high_speed = us122l->dev->speed == USB_SPEED_HIGH;
0365     if ((cfg.sample_rate != 44100 && cfg.sample_rate != 48000  &&
0366          (!high_speed ||
0367           (cfg.sample_rate != 88200 && cfg.sample_rate != 96000))) ||
0368         cfg.frame_size != 6 ||
0369         cfg.period_frames > 0x3000)
0370         return -EINVAL;
0371 
0372     switch (cfg.sample_rate) {
0373     case 44100:
0374         min_period_frames = 48;
0375         break;
0376     case 48000:
0377         min_period_frames = 52;
0378         break;
0379     default:
0380         min_period_frames = 104;
0381         break;
0382     }
0383     if (!high_speed)
0384         min_period_frames <<= 1;
0385     if (cfg.period_frames < min_period_frames)
0386         return -EINVAL;
0387 
0388     snd_power_wait(hw->card);
0389 
0390     mutex_lock(&us122l->mutex);
0391     s = us122l->sk.s;
0392     if (!us122l->master) {
0393         us122l->master = file;
0394     } else if (us122l->master != file) {
0395         if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg))) {
0396             err = -EIO;
0397             goto unlock;
0398         }
0399         us122l->slave = file;
0400     }
0401     if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg)) ||
0402         s->state == usb_stream_xrun) {
0403         us122l_stop(us122l);
0404         if (!us122l_start(us122l, cfg.sample_rate, cfg.period_frames))
0405             err = -EIO;
0406         else
0407             err = 1;
0408     }
0409 unlock:
0410     mutex_unlock(&us122l->mutex);
0411     wake_up_all(&us122l->sk.sleep);
0412     return err;
0413 }
0414 
0415 #define SND_USB_STREAM_ID "USB STREAM"
0416 static int usb_stream_hwdep_new(struct snd_card *card)
0417 {
0418     int err;
0419     struct snd_hwdep *hw;
0420     struct usb_device *dev = US122L(card)->dev;
0421 
0422     err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw);
0423     if (err < 0)
0424         return err;
0425 
0426     hw->iface = SNDRV_HWDEP_IFACE_USB_STREAM;
0427     hw->private_data = US122L(card);
0428     hw->ops.open = usb_stream_hwdep_open;
0429     hw->ops.release = usb_stream_hwdep_release;
0430     hw->ops.ioctl = usb_stream_hwdep_ioctl;
0431     hw->ops.ioctl_compat = usb_stream_hwdep_ioctl;
0432     hw->ops.mmap = usb_stream_hwdep_mmap;
0433     hw->ops.poll = usb_stream_hwdep_poll;
0434 
0435     sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm",
0436         dev->bus->busnum, dev->devnum);
0437     return 0;
0438 }
0439 
0440 static bool us122l_create_card(struct snd_card *card)
0441 {
0442     int err;
0443     struct us122l *us122l = US122L(card);
0444 
0445     if (us122l->is_us144) {
0446         err = usb_set_interface(us122l->dev, 0, 1);
0447         if (err) {
0448             snd_printk(KERN_ERR "usb_set_interface error\n");
0449             return false;
0450         }
0451     }
0452     err = usb_set_interface(us122l->dev, 1, 1);
0453     if (err) {
0454         snd_printk(KERN_ERR "usb_set_interface error\n");
0455         return false;
0456     }
0457 
0458     pt_info_set(us122l->dev, 0x11);
0459     pt_info_set(us122l->dev, 0x10);
0460 
0461     if (!us122l_start(us122l, 44100, 256))
0462         return false;
0463 
0464     if (us122l->is_us144)
0465         err = us144_create_usbmidi(card);
0466     else
0467         err = us122l_create_usbmidi(card);
0468     if (err < 0) {
0469         snd_printk(KERN_ERR "us122l_create_usbmidi error %i\n", err);
0470         goto stop;
0471     }
0472     err = usb_stream_hwdep_new(card);
0473     if (err < 0) {
0474         /* release the midi resources */
0475         struct list_head *p;
0476 
0477         list_for_each(p, &us122l->midi_list)
0478             snd_usbmidi_disconnect(p);
0479 
0480         goto stop;
0481     }
0482     return true;
0483 
0484 stop:
0485     us122l_stop(us122l);
0486     return false;
0487 }
0488 
0489 static void snd_us122l_free(struct snd_card *card)
0490 {
0491     struct us122l   *us122l = US122L(card);
0492     int     index = us122l->card_index;
0493 
0494     if (index >= 0 && index < SNDRV_CARDS)
0495         snd_us122l_card_used[index] = 0;
0496 }
0497 
0498 static int usx2y_create_card(struct usb_device *device,
0499                  struct usb_interface *intf,
0500                  struct snd_card **cardp,
0501                  unsigned long flags)
0502 {
0503     int     dev;
0504     struct snd_card *card;
0505     int err;
0506 
0507     for (dev = 0; dev < SNDRV_CARDS; ++dev)
0508         if (enable[dev] && !snd_us122l_card_used[dev])
0509             break;
0510     if (dev >= SNDRV_CARDS)
0511         return -ENODEV;
0512     err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,
0513                sizeof(struct us122l), &card);
0514     if (err < 0)
0515         return err;
0516     snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
0517     card->private_free = snd_us122l_free;
0518     US122L(card)->dev = device;
0519     mutex_init(&US122L(card)->mutex);
0520     init_waitqueue_head(&US122L(card)->sk.sleep);
0521     US122L(card)->is_us144 = flags & US122L_FLAG_US144;
0522     INIT_LIST_HEAD(&US122L(card)->midi_list);
0523     strcpy(card->driver, "USB "NAME_ALLCAPS"");
0524     sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
0525     sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
0526         card->shortname,
0527         le16_to_cpu(device->descriptor.idVendor),
0528         le16_to_cpu(device->descriptor.idProduct),
0529         0,
0530         US122L(card)->dev->bus->busnum,
0531         US122L(card)->dev->devnum
0532         );
0533     *cardp = card;
0534     return 0;
0535 }
0536 
0537 static int us122l_usb_probe(struct usb_interface *intf,
0538                 const struct usb_device_id *device_id,
0539                 struct snd_card **cardp)
0540 {
0541     struct usb_device *device = interface_to_usbdev(intf);
0542     struct snd_card *card;
0543     int err;
0544 
0545     err = usx2y_create_card(device, intf, &card, device_id->driver_info);
0546     if (err < 0)
0547         return err;
0548 
0549     if (!us122l_create_card(card)) {
0550         snd_card_free(card);
0551         return -EINVAL;
0552     }
0553 
0554     err = snd_card_register(card);
0555     if (err < 0) {
0556         snd_card_free(card);
0557         return err;
0558     }
0559 
0560     usb_get_intf(usb_ifnum_to_if(device, 0));
0561     usb_get_dev(device);
0562     *cardp = card;
0563     return 0;
0564 }
0565 
0566 static int snd_us122l_probe(struct usb_interface *intf,
0567                 const struct usb_device_id *id)
0568 {
0569     struct usb_device *device = interface_to_usbdev(intf);
0570     struct snd_card *card;
0571     int err;
0572 
0573     if (id->driver_info & US122L_FLAG_US144 &&
0574             device->speed == USB_SPEED_HIGH) {
0575         snd_printk(KERN_ERR "disable ehci-hcd to run US-144\n");
0576         return -ENODEV;
0577     }
0578 
0579     snd_printdd(KERN_DEBUG"%p:%i\n",
0580             intf, intf->cur_altsetting->desc.bInterfaceNumber);
0581     if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
0582         return 0;
0583 
0584     err = us122l_usb_probe(usb_get_intf(intf), id, &card);
0585     if (err < 0) {
0586         usb_put_intf(intf);
0587         return err;
0588     }
0589 
0590     usb_set_intfdata(intf, card);
0591     return 0;
0592 }
0593 
0594 static void snd_us122l_disconnect(struct usb_interface *intf)
0595 {
0596     struct snd_card *card;
0597     struct us122l *us122l;
0598     struct list_head *p;
0599 
0600     card = usb_get_intfdata(intf);
0601     if (!card)
0602         return;
0603 
0604     snd_card_disconnect(card);
0605 
0606     us122l = US122L(card);
0607     mutex_lock(&us122l->mutex);
0608     us122l_stop(us122l);
0609     mutex_unlock(&us122l->mutex);
0610 
0611     /* release the midi resources */
0612     list_for_each(p, &us122l->midi_list) {
0613         snd_usbmidi_disconnect(p);
0614     }
0615 
0616     usb_put_intf(usb_ifnum_to_if(us122l->dev, 0));
0617     usb_put_intf(usb_ifnum_to_if(us122l->dev, 1));
0618     usb_put_dev(us122l->dev);
0619 
0620     while (atomic_read(&us122l->mmap_count))
0621         msleep(500);
0622 
0623     snd_card_free(card);
0624 }
0625 
0626 static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message)
0627 {
0628     struct snd_card *card;
0629     struct us122l *us122l;
0630     struct list_head *p;
0631 
0632     card = usb_get_intfdata(intf);
0633     if (!card)
0634         return 0;
0635     snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
0636 
0637     us122l = US122L(card);
0638     if (!us122l)
0639         return 0;
0640 
0641     list_for_each(p, &us122l->midi_list)
0642         snd_usbmidi_input_stop(p);
0643 
0644     mutex_lock(&us122l->mutex);
0645     usb_stream_stop(&us122l->sk);
0646     mutex_unlock(&us122l->mutex);
0647 
0648     return 0;
0649 }
0650 
0651 static int snd_us122l_resume(struct usb_interface *intf)
0652 {
0653     struct snd_card *card;
0654     struct us122l *us122l;
0655     struct list_head *p;
0656     int err;
0657 
0658     card = usb_get_intfdata(intf);
0659     if (!card)
0660         return 0;
0661 
0662     us122l = US122L(card);
0663     if (!us122l)
0664         return 0;
0665 
0666     mutex_lock(&us122l->mutex);
0667     /* needed, doesn't restart without: */
0668     if (us122l->is_us144) {
0669         err = usb_set_interface(us122l->dev, 0, 1);
0670         if (err) {
0671             snd_printk(KERN_ERR "usb_set_interface error\n");
0672             goto unlock;
0673         }
0674     }
0675     err = usb_set_interface(us122l->dev, 1, 1);
0676     if (err) {
0677         snd_printk(KERN_ERR "usb_set_interface error\n");
0678         goto unlock;
0679     }
0680 
0681     pt_info_set(us122l->dev, 0x11);
0682     pt_info_set(us122l->dev, 0x10);
0683 
0684     err = us122l_set_sample_rate(us122l->dev,
0685                      us122l->sk.s->cfg.sample_rate);
0686     if (err < 0) {
0687         snd_printk(KERN_ERR "us122l_set_sample_rate error\n");
0688         goto unlock;
0689     }
0690     err = usb_stream_start(&us122l->sk);
0691     if (err)
0692         goto unlock;
0693 
0694     list_for_each(p, &us122l->midi_list)
0695         snd_usbmidi_input_start(p);
0696 unlock:
0697     mutex_unlock(&us122l->mutex);
0698     snd_power_change_state(card, SNDRV_CTL_POWER_D0);
0699     return err;
0700 }
0701 
0702 static const struct usb_device_id snd_us122l_usb_id_table[] = {
0703     {
0704         .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
0705         .idVendor = 0x0644,
0706         .idProduct =    USB_ID_US122L
0707     },
0708     {   /* US-144 only works at USB1.1! Disable module ehci-hcd. */
0709         .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
0710         .idVendor = 0x0644,
0711         .idProduct =    USB_ID_US144,
0712         .driver_info =  US122L_FLAG_US144
0713     },
0714     {
0715         .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
0716         .idVendor = 0x0644,
0717         .idProduct =    USB_ID_US122MKII
0718     },
0719     {
0720         .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
0721         .idVendor = 0x0644,
0722         .idProduct =    USB_ID_US144MKII,
0723         .driver_info =  US122L_FLAG_US144
0724     },
0725     { /* terminator */ }
0726 };
0727 MODULE_DEVICE_TABLE(usb, snd_us122l_usb_id_table);
0728 
0729 static struct usb_driver snd_us122l_usb_driver = {
0730     .name =     "snd-usb-us122l",
0731     .probe =    snd_us122l_probe,
0732     .disconnect =   snd_us122l_disconnect,
0733     .suspend =  snd_us122l_suspend,
0734     .resume =   snd_us122l_resume,
0735     .reset_resume = snd_us122l_resume,
0736     .id_table = snd_us122l_usb_id_table,
0737     .supports_autosuspend = 1
0738 };
0739 
0740 module_usb_driver(snd_us122l_usb_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!