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

[kbuild test robot <lkp@intel.com>]

[-- Attachment #1: Type: text/plain, Size: 14482 bytes --]

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 #2: .config.gz --]
[-- Type: application/gzip, Size: 28503 bytes --]