Re: [PATCH v2 2/2] ALSA: usb: initial USB Audio Device Class 3.0 support

From: kbuild test robot
Date: Mon Mar 19 2018 - 09:44:25 EST

Hi Ruslan,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on linus/master]
[also build test WARNING on v4.16-rc6 next-20180316]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url: https://github.com/0day-ci/linux/commits/Ruslan-Bilovol/ALSA-usb-audio-move-audioformat-quirks-to-quirks-c/20180319-205541
config: i386-randconfig-x016-201811 (attached as .config)
compiler: gcc-7 (Debian 7.3.0-1) 7.3.0
reproduce:
# save the attached .config to linux build tree
make ARCH=i386

Note: it may well be a FALSE warning. FWIW you are at least aware of it now.
http://gcc.gnu.org/wiki/Better_Uninitialized_Warnings

All warnings (new ones prefixed by >>):

sound/usb/stream.c: In function 'snd_usb_parse_audio_interface':
>> sound/usb/stream.c:956:8: warning: 'fmt' may be used uninitialized in this function [-Wmaybe-uninitialized]
if (snd_usb_parse_audio_format(chip, fp, format,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fmt, stream) < 0) {
~~~~~~~~~~~~

vim +/fmt +956 sound/usb/stream.c

628
629 int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no)
630 {
631 struct usb_device *dev;
632 struct usb_interface *iface;
633 struct usb_host_interface *alts;
634 struct usb_interface_descriptor *altsd;
635 int i, altno, err, stream;
636 u64 format = 0;
637 unsigned int num_channels = 0;
638 struct audioformat *fp = NULL;
639 int num, protocol, clock = 0;
640 struct uac_format_type_i_continuous_descriptor *fmt;
641 struct snd_pcm_chmap_elem *chmap_v3 = NULL;
642 unsigned int chconfig;
643
644 dev = chip->dev;
645
646 /* parse the interface's altsettings */
647 iface = usb_ifnum_to_if(dev, iface_no);
648
649 num = iface->num_altsetting;
650
651 /*
652 * Dallas DS4201 workaround: It presents 5 altsettings, but the last
653 * one misses syncpipe, and does not produce any sound.
654 */
655 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
656 num = 4;
657
658 for (i = 0; i < num; i++) {
659 alts = &iface->altsetting[i];
660 altsd = get_iface_desc(alts);
661 protocol = altsd->bInterfaceProtocol;
662 /* skip invalid one */
663 if (((altsd->bInterfaceClass != USB_CLASS_AUDIO ||
664 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
665 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) &&
666 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
667 altsd->bNumEndpoints < 1 ||
668 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
669 continue;
670 /* must be isochronous */
671 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
672 USB_ENDPOINT_XFER_ISOC)
673 continue;
674 /* check direction */
675 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
676 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
677 altno = altsd->bAlternateSetting;
678
679 if (snd_usb_apply_interface_quirk(chip, iface_no, altno))
680 continue;
681
682 /*
683 * Roland audio streaming interfaces are marked with protocols
684 * 0/1/2, but are UAC 1 compatible.
685 */
686 if (USB_ID_VENDOR(chip->usb_id) == 0x0582 &&
687 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC &&
688 protocol <= 2)
689 protocol = UAC_VERSION_1;
690
691 chconfig = 0;
692 /* get audio formats */
693 switch (protocol) {
694 default:
695 dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n",
696 iface_no, altno, protocol);
697 protocol = UAC_VERSION_1;
698 /* fall through */
699
700 case UAC_VERSION_1: {
701 struct uac1_as_header_descriptor *as =
702 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
703 struct uac_input_terminal_descriptor *iterm;
704
705 if (!as) {
706 dev_err(&dev->dev,
707 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
708 iface_no, altno);
709 continue;
710 }
711
712 if (as->bLength < sizeof(*as)) {
713 dev_err(&dev->dev,
714 "%u:%d : invalid UAC_AS_GENERAL desc\n",
715 iface_no, altno);
716 continue;
717 }
718
719 format = le16_to_cpu(as->wFormatTag); /* remember the format value */
720
721 iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
722 as->bTerminalLink);
723 if (iterm) {
724 num_channels = iterm->bNrChannels;
725 chconfig = le16_to_cpu(iterm->wChannelConfig);
726 }
727
728 break;
729 }
730
731 case UAC_VERSION_2: {
732 struct uac2_input_terminal_descriptor *input_term;
733 struct uac2_output_terminal_descriptor *output_term;
734 struct uac2_as_header_descriptor *as =
735 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
736
737 if (!as) {
738 dev_err(&dev->dev,
739 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
740 iface_no, altno);
741 continue;
742 }
743
744 if (as->bLength < sizeof(*as)) {
745 dev_err(&dev->dev,
746 "%u:%d : invalid UAC_AS_GENERAL desc\n",
747 iface_no, altno);
748 continue;
749 }
750
751 num_channels = as->bNrChannels;
752 format = le32_to_cpu(as->bmFormats);
753 chconfig = le32_to_cpu(as->bmChannelConfig);
754
755 /* lookup the terminal associated to this interface
756 * to extract the clock */
757 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
758 as->bTerminalLink);
759 if (input_term) {
760 clock = input_term->bCSourceID;
761 if (!chconfig && (num_channels == input_term->bNrChannels))
762 chconfig = le32_to_cpu(input_term->bmChannelConfig);
763 break;
764 }
765
766 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
767 as->bTerminalLink);
768 if (output_term) {
769 clock = output_term->bCSourceID;
770 break;
771 }
772
773 dev_err(&dev->dev,
774 "%u:%d : bogus bTerminalLink %d\n",
775 iface_no, altno, as->bTerminalLink);
776 continue;
777 }
778
779 case UAC_VERSION_3: {
780 struct uac3_input_terminal_descriptor *input_term;
781 struct uac3_output_terminal_descriptor *output_term;
782 struct uac3_as_header_descriptor *as;
783 struct uac3_cluster_header_descriptor *cluster;
784 struct uac3_hc_descriptor_header hc_header;
785 u16 cluster_id, wLength;
786
787 as = snd_usb_find_csint_desc(alts->extra,
788 alts->extralen,
789 NULL, UAC_AS_GENERAL);
790
791 if (!as) {
792 dev_err(&dev->dev,
793 "%u:%d : UAC_AS_GENERAL descriptor not found\n",
794 iface_no, altno);
795 continue;
796 }
797
798 if (as->bLength < sizeof(*as)) {
799 dev_err(&dev->dev,
800 "%u:%d : invalid UAC_AS_GENERAL desc\n",
801 iface_no, altno);
802 continue;
803 }
804
805 cluster_id = le16_to_cpu(as->wClusterDescrID);
806 if (!cluster_id) {
807 dev_err(&dev->dev,
808 "%u:%d : no cluster descriptor\n",
809 iface_no, altno);
810 continue;
811 }
812
813 /*
814 * Get number of channels and channel map through
815 * High Capability Cluster Descriptor
816 *
817 * First step: get High Capability header and
818 * read size of Cluster Descriptor
819 */
820 err = snd_usb_ctl_msg(chip->dev,
821 usb_rcvctrlpipe(chip->dev, 0),
822 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
823 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
824 cluster_id,
825 snd_usb_ctrl_intf(chip),
826 &hc_header, sizeof(hc_header));
827 if (err < 0)
828 return err;
829 else if (err != sizeof(hc_header)) {
830 dev_err(&dev->dev,
831 "%u:%d : can't get High Capability descriptor\n",
832 iface_no, altno);
833 return -EIO;
834 }
835
836 /*
837 * Second step: allocate needed amount of memory
838 * and request Cluster Descriptor
839 */
840 wLength = le16_to_cpu(hc_header.wLength);
841 cluster = kzalloc(wLength, GFP_KERNEL);
842 if (!cluster)
843 return -ENOMEM;
844 err = snd_usb_ctl_msg(chip->dev,
845 usb_rcvctrlpipe(chip->dev, 0),
846 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
847 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
848 cluster_id,
849 snd_usb_ctrl_intf(chip),
850 cluster, wLength);
851 if (err < 0) {
852 kfree(cluster);
853 return err;
854 } else if (err != wLength) {
855 dev_err(&dev->dev,
856 "%u:%d : can't get Cluster Descriptor\n",
857 iface_no, altno);
858 kfree(cluster);
859 return -EIO;
860 }
861
862 num_channels = cluster->bNrChannels;
863 chmap_v3 = convert_chmap_v3(cluster);
864
865 kfree(cluster);
866
867 format = le64_to_cpu(as->bmFormats);
868
869 /* lookup the terminal associated to this interface
870 * to extract the clock */
871 input_term = snd_usb_find_input_terminal_descriptor(
872 chip->ctrl_intf,
873 as->bTerminalLink);
874
875 if (input_term) {
876 clock = input_term->bCSourceID;
877 break;
878 }
879
880 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
881 as->bTerminalLink);
882 if (output_term) {
883 clock = output_term->bCSourceID;
884 break;
885 }
886
887 dev_err(&dev->dev,
888 "%u:%d : bogus bTerminalLink %d\n",
889 iface_no, altno, as->bTerminalLink);
890 continue;
891 }
892 }
893
894 if (protocol == UAC_VERSION_1 || protocol == UAC_VERSION_2) {
895 /* get format type */
896 fmt = snd_usb_find_csint_desc(alts->extra,
897 alts->extralen,
898 NULL, UAC_FORMAT_TYPE);
899 if (!fmt) {
900 dev_err(&dev->dev,
901 "%u:%d : no UAC_FORMAT_TYPE desc\n",
902 iface_no, altno);
903 continue;
904 }
905 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8))
906 || ((protocol == UAC_VERSION_2) &&
907 (fmt->bLength < 6))) {
908 dev_err(&dev->dev,
909 "%u:%d : invalid UAC_FORMAT_TYPE desc\n",
910 iface_no, altno);
911 continue;
912 }
913
914 /*
915 * Blue Microphones workaround: The last altsetting is
916 * identical with the previous one, except for a larger
917 * packet size, but is actually a mislabeled two-channel
918 * setting; ignore it.
919 */
920 if (fmt->bNrChannels == 1 &&
921 fmt->bSubframeSize == 2 &&
922 altno == 2 && num == 3 &&
923 fp && fp->altsetting == 1 && fp->channels == 1 &&
924 fp->formats == SNDRV_PCM_FMTBIT_S16_LE &&
925 protocol == UAC_VERSION_1 &&
926 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
927 fp->maxpacksize * 2)
928 continue;
929 }
930
931 fp = kzalloc(sizeof(*fp), GFP_KERNEL);
932 if (!fp)
933 return -ENOMEM;
934
935 fp->iface = iface_no;
936 fp->altsetting = altno;
937 fp->altset_idx = i;
938 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
939 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
940 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
941 fp->protocol = protocol;
942 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
943 fp->channels = num_channels;
944 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
945 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
946 * (fp->maxpacksize & 0x7ff);
947 fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no);
948 fp->clock = clock;
949 INIT_LIST_HEAD(&fp->list);
950
951 /* some quirks for attributes here */
952 snd_usb_audioformat_attributes_quirk(chip, fp, stream);
953
954 /* ok, let's parse further... */
955 if (protocol == UAC_VERSION_1 || protocol == UAC_VERSION_2) {
> 956 if (snd_usb_parse_audio_format(chip, fp, format,
957 fmt, stream) < 0) {
958 kfree(fp->rate_table);
959 kfree(fp);
960 fp = NULL;
961 continue;
962 }
963 } else {
964 struct uac3_as_header_descriptor *as;
965
966 as = snd_usb_find_csint_desc(alts->extra,
967 alts->extralen,
968 NULL, UAC_AS_GENERAL);
969
970 if (snd_usb_parse_audio_format_v3(chip, fp, as,
971 stream) < 0) {
972 kfree(fp->rate_table);
973 kfree(fp);
974 fp = NULL;
975 continue;
976 }
977 }
978
979 /* Create chmap */
980 if (fp->channels != num_channels)
981 chconfig = 0;
982
983 if (protocol == UAC_VERSION_3)
984 fp->chmap = chmap_v3;
985 else
986 fp->chmap = convert_chmap(fp->channels, chconfig,
987 protocol);
988
989 dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint);
990 err = snd_usb_add_audio_stream(chip, stream, fp);
991 if (err < 0) {
992 list_del(&fp->list); /* unlink for avoiding double-free */
993 kfree(fp->rate_table);
994 kfree(fp->chmap);
995 kfree(fp);
996 return err;
997 }
998 /* try to set the interface... */
999 usb_set_interface(chip->dev, iface_no, altno);
1000 snd_usb_init_pitch(chip, iface_no, alts, fp);
1001 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max);
1002 }
1003 return 0;
1004 }
1005

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation

Attachment: .config.gz
Description: application/gzip