Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0ba41d91 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: usb-audio: Use standard printk helpers 



Convert with dev_err() and co from snd_printk(), etc.
As there are too deep indirections (e.g. ep->chip->dev->dev),
a few new local macros, usb_audio_err() & co, are introduced.

Also, the device numbers in some messages are dropped, as they are
shown in the prefix automatically.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 6436bcf6

sound/usb/card.c

+22 −19
Original line number Diff line number Diff line
@@ -139,8 +139,8 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int 
	struct usb_interface *iface = usb_ifnum_to_if(dev, interface);



	if (!iface) {

		snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",

			   dev->devnum, ctrlif, interface);

		dev_err(&dev->dev, "%u:%d : does not exist\n",

			ctrlif, interface);

		return -EINVAL;

	}
@@ -165,8 +165,8 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int 
	}



	if (usb_interface_claimed(iface)) {

		snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",

						dev->devnum, ctrlif, interface);

		dev_dbg(&dev->dev, "%d:%d: skipping, already claimed\n",

			ctrlif, interface);

		return -EINVAL;

	}
@@ -176,8 +176,9 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int 
		int err = snd_usbmidi_create(chip->card, iface,

					     &chip->midi_list, NULL);

		if (err < 0) {

			snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",

						dev->devnum, ctrlif, interface);

			dev_err(&dev->dev,

				"%u:%d: cannot create sequencer device\n",

				ctrlif, interface);

			return -EINVAL;

		}

		usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
@@ -188,14 +189,15 @@ static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int int 
	if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&

	     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||

	    altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {

		snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",

					dev->devnum, ctrlif, interface, altsd->bInterfaceClass);

		dev_dbg(&dev->dev,

			"%u:%d: skipping non-supported interface %d\n",

			ctrlif, interface, altsd->bInterfaceClass);

		/* skip non-supported classes */

		return -EINVAL;

	}



	if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {

		snd_printk(KERN_ERR "low speed audio streaming not supported\n");

		dev_err(&dev->dev, "low speed audio streaming not supported\n");

		return -EINVAL;

	}
@@ -228,13 +230,14 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) 
	protocol = altsd->bInterfaceProtocol;



	if (!control_header) {

		snd_printk(KERN_ERR "cannot find UAC_HEADER\n");

		dev_err(&dev->dev, "cannot find UAC_HEADER\n");

		return -EINVAL;

	}



	switch (protocol) {

	default:

		snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n",

		dev_warn(&dev->dev,

			 "unknown interface protocol %#02x, assuming v1\n",

			 protocol);

		/* fall through */
@@ -242,12 +245,12 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) 
		struct uac1_ac_header_descriptor *h1 = control_header;



		if (!h1->bInCollection) {

			snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");

			dev_info(&dev->dev, "skipping empty audio interface (v1)\n");

			return -EINVAL;

		}



		if (h1->bLength < sizeof(*h1) + h1->bInCollection) {

			snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");

			dev_err(&dev->dev, "invalid UAC_HEADER (v1)\n");

			return -EINVAL;

		}
@@ -277,7 +280,7 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) 
		}



		if (!assoc) {

			snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");

			dev_err(&dev->dev, "Audio class v2 interfaces need an interface association\n");

			return -EINVAL;

		}
@@ -351,14 +354,14 @@ static int snd_usb_audio_create(struct usb_interface *intf, 
	case USB_SPEED_SUPER:

		break;

	default:

		snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));

		dev_err(&dev->dev, "unknown device speed %d\n", snd_usb_get_speed(dev));

		return -ENXIO;

	}



	err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,

			   0, &card);

	if (err < 0) {

		snd_printk(KERN_ERR "cannot create card instance %d\n", idx);

		dev_err(&dev->dev, "cannot create card instance %d\n", idx);

		return err;

	}
@@ -499,7 +502,7 @@ snd_usb_audio_probe(struct usb_device *dev, 
	for (i = 0; i < SNDRV_CARDS; i++) {

		if (usb_chip[i] && usb_chip[i]->dev == dev) {

			if (usb_chip[i]->shutdown) {

				snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");

				dev_err(&dev->dev, "USB device is in the shutdown state, cannot create a card instance\n");

				goto __error;

			}

			chip = usb_chip[i];
@@ -523,7 +526,7 @@ snd_usb_audio_probe(struct usb_device *dev, 
				break;

			}

		if (!chip) {

			printk(KERN_ERR "no available usb audio device\n");

			dev_err(&dev->dev, "no available usb audio device\n");

			goto __error;

		}

	}

sound/usb/clock.c

+34 −31
Original line number Diff line number Diff line
@@ -115,9 +115,9 @@ static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_i 
		return ret;



	if (ret != sizeof(pin)) {

		snd_printk(KERN_ERR

			"usb-audio:%d: setting selector (id %d) unexpected length %d\n",

			chip->dev->devnum, selector_id, ret);

		usb_audio_err(chip,

			"setting selector (id %d) unexpected length %d\n",

			selector_id, ret);

		return -EINVAL;

	}
@@ -126,9 +126,9 @@ static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_i 
		return ret;



	if (ret != pin) {

		snd_printk(KERN_ERR

			"usb-audio:%d: setting selector (id %d) to %x failed (current: %d)\n",

			chip->dev->devnum, selector_id, pin, ret);

		usb_audio_err(chip,

			"setting selector (id %d) to %x failed (current: %d)\n",

			selector_id, pin, ret);

		return -EINVAL;

	}
@@ -158,7 +158,8 @@ static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, int source_id) 
			      &data, sizeof(data));



	if (err < 0) {

		snd_printk(KERN_WARNING "%s(): cannot get clock validity for id %d\n",

		dev_warn(&dev->dev,

			 "%s(): cannot get clock validity for id %d\n",

			   __func__, source_id);

		return 0;

	}
@@ -177,7 +178,7 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, 
	entity_id &= 0xff;



	if (test_and_set_bit(entity_id, visited)) {

		snd_printk(KERN_WARNING

		usb_audio_warn(chip,

			 "%s(): recursive clock topology detected, id %d.\n",

			 __func__, entity_id);

		return -EINVAL;
@@ -188,8 +189,9 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, 
	if (source) {

		entity_id = source->bClockID;

		if (validate && !uac_clock_source_is_valid(chip, entity_id)) {

			snd_printk(KERN_ERR "usb-audio:%d: clock source %d is not valid, cannot use\n",

				   chip->dev->devnum, entity_id);

			usb_audio_err(chip,

				"clock source %d is not valid, cannot use\n",

				entity_id);

			return -ENXIO;

		}

		return entity_id;
@@ -208,7 +210,7 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, 
		/* Selector values are one-based */



		if (ret > selector->bNrInPins || ret < 1) {

			snd_printk(KERN_ERR

			usb_audio_err(chip,

				"%s(): selector reported illegal value, id %d, ret %d\n",

				__func__, selector->bClockID, ret);
@@ -237,9 +239,9 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip, 
			if (err < 0)

				continue;



			snd_printk(KERN_INFO

				"usb-audio:%d: found and selected valid clock source %d\n",

				chip->dev->devnum, ret);

			usb_audio_info(chip,

				 "found and selected valid clock source %d\n",

				 ret);

			return ret;

		}
@@ -296,8 +298,8 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface, 
				   USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,

				   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,

				   data, sizeof(data))) < 0) {

		snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",

			   dev->devnum, iface, fmt->altsetting, rate, ep);

		dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n",

			iface, fmt->altsetting, rate, ep);

		return err;

	}
@@ -305,14 +307,14 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface, 
				   USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,

				   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,

				   data, sizeof(data))) < 0) {

		snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",

			   dev->devnum, iface, fmt->altsetting, ep);

		dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n",

			iface, fmt->altsetting, ep);

		return 0; /* some devices don't support reading */

	}



	crate = data[0] | (data[1] << 8) | (data[2] << 16);

	if (crate != rate) {

		snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);

		dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate);

		// runtime->rate = crate;

	}
@@ -332,8 +334,8 @@ static int get_sample_rate_v2(struct snd_usb_audio *chip, int iface, 
			      snd_usb_ctrl_intf(chip) | (clock << 8),

			      &data, sizeof(data));

	if (err < 0) {

		snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq (v2): err %d\n",

			   dev->devnum, iface, altsetting, err);

		dev_warn(&dev->dev, "%d:%d: cannot get freq (v2): err %d\n",

			 iface, altsetting, err);

		return 0;

	}
@@ -369,8 +371,9 @@ static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface, 
				      snd_usb_ctrl_intf(chip) | (clock << 8),

				      &data, sizeof(data));

		if (err < 0) {

			snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d (v2): err %d\n",

				   dev->devnum, iface, fmt->altsetting, rate, err);

			usb_audio_err(chip,

				"%d:%d: cannot set freq %d (v2): err %d\n",

				iface, fmt->altsetting, rate, err);

			return err;

		}
@@ -381,12 +384,12 @@ static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface, 


	if (cur_rate != rate) {

		if (!writeable) {

			snd_printk(KERN_WARNING

				   "%d:%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",

				   dev->devnum, iface, fmt->altsetting, rate, cur_rate);

			usb_audio_warn(chip,

				 "%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",

				 iface, fmt->altsetting, rate, cur_rate);

			return -ENXIO;

		}

		snd_printd(KERN_WARNING

		usb_audio_dbg(chip,

			"current rate %d is different from the runtime rate %d\n",

			cur_rate, rate);

	}

sound/usb/endpoint.c

+19 −13
Original line number Diff line number Diff line
@@ -333,7 +333,8 @@ static void queue_pending_output_urbs(struct snd_usb_endpoint *ep) 


		err = usb_submit_urb(ctx->urb, GFP_ATOMIC);

		if (err < 0)

			snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",

			usb_audio_err(ep->chip,

				"Unable to submit urb #%d: %d (urb %p)\n",

				ctx->index, err, ctx->urb);

		else

			set_bit(ctx->index, &ep->active_mask);
@@ -387,7 +388,7 @@ static void snd_complete_urb(struct urb *urb) 
	if (err == 0)

		return;



	snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);

	usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);

	//snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);



exit_clear:
@@ -426,13 +427,14 @@ struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip, 
		if (ep->ep_num == ep_num &&

		    ep->iface == alts->desc.bInterfaceNumber &&

		    ep->altsetting == alts->desc.bAlternateSetting) {

			snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",

			usb_audio_dbg(ep->chip,

				      "Re-using EP %x in iface %d,%d @%p\n",

					ep_num, ep->iface, ep->altsetting, ep);

			goto __exit_unlock;

		}

	}



	snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",

	usb_audio_dbg(chip, "Creating new %s %s endpoint #%x\n",

		    is_playback ? "playback" : "capture",

		    type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",

		    ep_num);
@@ -496,7 +498,8 @@ static int wait_clear_urbs(struct snd_usb_endpoint *ep) 
	} while (time_before(jiffies, end_time));



	if (alive)

		snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",

		usb_audio_err(ep->chip,

			"timeout: still %d active urbs on EP #%x\n",

			alive, ep->ep_num);

	clear_bit(EP_FLAG_STOPPING, &ep->flags);
@@ -794,7 +797,8 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep, 
	int err;



	if (ep->use_count != 0) {

		snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",

		usb_audio_warn(ep->chip,

			 "Unable to change format on ep #%x: already in use\n",

			 ep->ep_num);

		return -EBUSY;

	}
@@ -830,7 +834,8 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep, 
		err = -EINVAL;

	}



	snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",

	usb_audio_dbg(ep->chip,

		"Setting params for ep #%x (type %d, %d urbs), ret=%d\n",

		ep->ep_num, ep->type, ep->nurbs, err);



	return err;
@@ -906,7 +911,8 @@ int snd_usb_endpoint_start(struct snd_usb_endpoint *ep, bool can_sleep) 


		err = usb_submit_urb(urb, GFP_ATOMIC);

		if (err < 0) {

			snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",

			usb_audio_err(ep->chip,

				"cannot submit urb %d, error %d: %s\n",

				i, err, usb_error_string(err));

			goto __error;

		}

sound/usb/format.c

+39 −29
Original line number Diff line number Diff line
@@ -74,8 +74,8 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, 
	if ((pcm_formats == 0) &&

	    (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED))) {

		/* some devices don't define this correctly... */

		snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",

			    chip->dev->devnum, fp->iface, fp->altsetting);

		usb_audio_info(chip, "%u:%d : format type 0 is detected, processed as PCM\n",

			fp->iface, fp->altsetting);

		format = 1 << UAC_FORMAT_TYPE_I_PCM;

	}

	if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) {
@@ -83,8 +83,8 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, 
		    sample_width == 24 && sample_bytes == 2)

			sample_bytes = 3;

		else if (sample_width > sample_bytes * 8) {

			snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",

				   chip->dev->devnum, fp->iface, fp->altsetting,

			usb_audio_info(chip, "%u:%d : sample bitwidth %d in over sample bytes %d\n",

				 fp->iface, fp->altsetting,

				 sample_width, sample_bytes);

		}

		/* check the format byte size */
@@ -108,8 +108,9 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, 
			pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE;

			break;

		default:

			snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",

				   chip->dev->devnum, fp->iface, fp->altsetting,

			usb_audio_info(chip,

				 "%u:%d : unsupported sample bitwidth %d in %d bytes\n",

				 fp->iface, fp->altsetting,

				 sample_width, sample_bytes);

			break;

		}
@@ -132,8 +133,9 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, 
		pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW;

	}

	if (format & ~0x3f) {

		snd_printk(KERN_INFO "%d:%u:%d : unsupported format bits %#x\n",

			   chip->dev->devnum, fp->iface, fp->altsetting, format);

		usb_audio_info(chip,

			 "%u:%d : unsupported format bits %#x\n",

			 fp->iface, fp->altsetting, format);

	}



	pcm_formats |= snd_usb_interface_dsd_format_quirks(chip, fp, sample_bytes);
@@ -158,8 +160,9 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof 
	int nr_rates = fmt[offset];



	if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {

		snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",

				   chip->dev->devnum, fp->iface, fp->altsetting);

		usb_audio_err(chip,

			"%u:%d : invalid UAC_FORMAT_TYPE desc\n",

			fp->iface, fp->altsetting);

		return -EINVAL;

	}
@@ -171,7 +174,7 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof 


		fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);

		if (fp->rate_table == NULL) {

			snd_printk(KERN_ERR "cannot malloc\n");

			usb_audio_err(chip, "cannot malloc\n");

			return -ENOMEM;

		}
@@ -222,7 +225,8 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof 
 * get to know how many sample rates we have to expect.

 * Then fp->rate_table can be allocated and filled.

 */

static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,

static int parse_uac2_sample_rate_range(struct snd_usb_audio *chip,

					struct audioformat *fp, int nr_triplets,

					const unsigned char *data)

{

	int i, nr_rates = 0;
@@ -261,7 +265,7 @@ static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets, 


			nr_rates++;

			if (nr_rates >= MAX_NR_RATES) {

				snd_printk(KERN_ERR "invalid uac2 rates\n");

				usb_audio_err(chip, "invalid uac2 rates\n");

				break;

			}
@@ -287,7 +291,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 
	int clock = snd_usb_clock_find_source(chip, fp->clock, false);



	if (clock < 0) {

		snd_printk(KERN_ERR "%s(): unable to find clock source (clock %d)\n",

		dev_err(&dev->dev,

			"%s(): unable to find clock source (clock %d)\n",

				__func__, clock);

		goto err;

	}
@@ -300,7 +305,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 
			      tmp, sizeof(tmp));



	if (ret < 0) {

		snd_printk(KERN_ERR "%s(): unable to retrieve number of sample rates (clock %d)\n",

		dev_err(&dev->dev,

			"%s(): unable to retrieve number of sample rates (clock %d)\n",

				__func__, clock);

		goto err;

	}
@@ -321,7 +327,8 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 
			      data, data_size);



	if (ret < 0) {

		snd_printk(KERN_ERR "%s(): unable to retrieve sample rate range (clock %d)\n",

		dev_err(&dev->dev,

			"%s(): unable to retrieve sample rate range (clock %d)\n",

				__func__, clock);

		ret = -EINVAL;

		goto err_free;
@@ -332,7 +339,7 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 
	 * will have to deal with. */

	kfree(fp->rate_table);

	fp->rate_table = NULL;

	fp->nr_rates = parse_uac2_sample_rate_range(fp, nr_triplets, data);

	fp->nr_rates = parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);



	if (fp->nr_rates == 0) {

		/* SNDRV_PCM_RATE_CONTINUOUS */
@@ -348,7 +355,7 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip, 


	/* Call the triplet parser again, but this time, fp->rate_table is

	 * allocated, so the rates will be stored */

	parse_uac2_sample_rate_range(fp, nr_triplets, data);

	parse_uac2_sample_rate_range(chip, fp, nr_triplets, data);



err_free:

	kfree(data);
@@ -408,8 +415,9 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, 
	}



	if (fp->channels < 1) {

		snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",

			   chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);

		usb_audio_err(chip,

			"%u:%d : invalid channels %d\n",

			fp->iface, fp->altsetting, fp->channels);

		return -EINVAL;

	}
@@ -435,8 +443,9 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, 
		fp->formats = SNDRV_PCM_FMTBIT_MPEG;

		break;

	default:

		snd_printd(KERN_INFO "%d:%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",

			   chip->dev->devnum, fp->iface, fp->altsetting, format);

		usb_audio_info(chip,

			 "%u:%d : unknown format tag %#x is detected.  processed as MPEG.\n",

			 fp->iface, fp->altsetting, format);

		fp->formats = SNDRV_PCM_FMTBIT_MPEG;

		break;

	}
@@ -449,7 +458,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, 
		struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;

		brate = le16_to_cpu(fmt->wMaxBitRate);

		framesize = le16_to_cpu(fmt->wSamplesPerFrame);

		snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);

		usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);

		fp->frame_size = framesize;

		ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */

		break;
@@ -458,7 +467,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, 
		struct uac_format_type_ii_ext_descriptor *fmt = _fmt;

		brate = le16_to_cpu(fmt->wMaxBitRate);

		framesize = le16_to_cpu(fmt->wSamplesPerFrame);

		snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);

		usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);

		fp->frame_size = framesize;

		ret = parse_audio_format_rates_v2(chip, fp);

		break;
@@ -484,8 +493,9 @@ int snd_usb_parse_audio_format(struct snd_usb_audio *chip, 
		err = parse_audio_format_ii(chip, fp, format, fmt);

		break;

	default:

		snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",

			   chip->dev->devnum, fp->iface, fp->altsetting,

		usb_audio_info(chip,

			 "%u:%d : format type %d is not supported yet\n",

			 fp->iface, fp->altsetting,

			 fmt->bFormatType);

		return -ENOTSUPP;

	}

sound/usb/midi.c

+24 −21
Original line number Diff line number Diff line
@@ -191,16 +191,16 @@ static int snd_usbmidi_submit_urb(struct urb* urb, gfp_t flags) 
{

	int err = usb_submit_urb(urb, flags);

	if (err < 0 && err != -ENODEV)

		snd_printk(KERN_ERR "usb_submit_urb: %d\n", err);

		dev_err(&urb->dev->dev, "usb_submit_urb: %d\n", err);

	return err;

}



/*

 * Error handling for URB completion functions.

 */

static int snd_usbmidi_urb_error(int status)

static int snd_usbmidi_urb_error(const struct urb *urb)

{

	switch (status) {

	switch (urb->status) {

	/* manually unlinked, or device gone */

	case -ENOENT:

	case -ECONNRESET:
@@ -213,7 +213,7 @@ static int snd_usbmidi_urb_error(int status) 
	case -EILSEQ:

		return -EIO;

	default:

		snd_printk(KERN_ERR "urb status %d\n", status);

		dev_err(&urb->dev->dev, "urb status %d\n", urb->status);

		return 0; /* continue */

	}

}
@@ -227,7 +227,7 @@ static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint* ep, int port 
	struct usbmidi_in_port* port = &ep->ports[portidx];



	if (!port->substream) {

		snd_printd("unexpected port %d!\n", portidx);

		dev_dbg(&ep->umidi->dev->dev, "unexpected port %d!\n", portidx);

		return;

	}

	if (!test_bit(port->substream->number, &ep->umidi->input_triggered))
@@ -259,7 +259,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb) 
		ep->umidi->usb_protocol_ops->input(ep, urb->transfer_buffer,

						   urb->actual_length);

	} else {

		int err = snd_usbmidi_urb_error(urb->status);

		int err = snd_usbmidi_urb_error(urb);

		if (err < 0) {

			if (err != -ENODEV) {

				ep->error_resubmit = 1;
@@ -289,7 +289,7 @@ static void snd_usbmidi_out_urb_complete(struct urb* urb) 
	}

	spin_unlock(&ep->buffer_lock);

	if (urb->status < 0) {

		int err = snd_usbmidi_urb_error(urb->status);

		int err = snd_usbmidi_urb_error(urb);

		if (err < 0) {

			if (err != -ENODEV)

				mod_timer(&ep->umidi->error_timer,
@@ -1668,7 +1668,7 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi, 


	struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number);

	if (!substream) {

		snd_printd(KERN_ERR "substream %d:%d not found\n", stream, number);

		dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream, number);

		return;

	}
@@ -1717,7 +1717,7 @@ static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi, 
			}

		}

	}

	snd_printdd(KERN_INFO "created %d output and %d input ports\n",

	dev_dbg(&umidi->dev->dev, "created %d output and %d input ports\n",

		    out_ports, in_ports);

	return 0;

}
@@ -1747,10 +1747,11 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, 
	    ms_header->bLength >= 7 &&

	    ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&

	    ms_header->bDescriptorSubtype == UAC_HEADER)

		snd_printdd(KERN_INFO "MIDIStreaming version %02x.%02x\n",

		dev_dbg(&umidi->dev->dev, "MIDIStreaming version %02x.%02x\n",

			    ms_header->bcdMSC[1], ms_header->bcdMSC[0]);

	else

		snd_printk(KERN_WARNING "MIDIStreaming interface descriptor not found\n");

		dev_warn(&umidi->dev->dev,

			 "MIDIStreaming interface descriptor not found\n");



	epidx = 0;

	for (i = 0; i < intfd->bNumEndpoints; ++i) {
@@ -1767,7 +1768,8 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, 
		if (usb_endpoint_dir_out(ep)) {

			if (endpoints[epidx].out_ep) {

				if (++epidx >= MIDI_MAX_ENDPOINTS) {

					snd_printk(KERN_WARNING "too many endpoints\n");

					dev_warn(&umidi->dev->dev,

						 "too many endpoints\n");

					break;

				}

			}
@@ -1782,12 +1784,13 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, 
				 */

				endpoints[epidx].out_interval = 1;

			endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;

			snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",

			dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",

				    ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);

		} else {

			if (endpoints[epidx].in_ep) {

				if (++epidx >= MIDI_MAX_ENDPOINTS) {

					snd_printk(KERN_WARNING "too many endpoints\n");

					dev_warn(&umidi->dev->dev,

						 "too many endpoints\n");

					break;

				}

			}
@@ -1797,7 +1800,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, 
			else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)

				endpoints[epidx].in_interval = 1;

			endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;

			snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",

			dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n",

				    ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack);

		}

	}
@@ -1865,7 +1868,7 @@ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi) 
	    (get_endpoint(hostif, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_INT)

		return;



	snd_printdd(KERN_INFO "switching to altsetting %d with int ep\n",

	dev_dbg(&umidi->dev->dev, "switching to altsetting %d with int ep\n",

		    intfd->bAlternateSetting);

	usb_set_interface(umidi->dev, intfd->bInterfaceNumber,

			  intfd->bAlternateSetting);
@@ -2047,25 +2050,25 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi, 
	 * input bulk endpoints (at indices 1 and 3) which aren't used.

	 */

	if (intfd->bNumEndpoints < (endpoint->out_cables > 0x0001 ? 5 : 3)) {

		snd_printdd(KERN_ERR "not enough endpoints\n");

		dev_dbg(&umidi->dev->dev, "not enough endpoints\n");

		return -ENOENT;

	}



	epd = get_endpoint(hostif, 0);

	if (!usb_endpoint_dir_in(epd) || !usb_endpoint_xfer_int(epd)) {

		snd_printdd(KERN_ERR "endpoint[0] isn't interrupt\n");

		dev_dbg(&umidi->dev->dev, "endpoint[0] isn't interrupt\n");

		return -ENXIO;

	}

	epd = get_endpoint(hostif, 2);

	if (!usb_endpoint_dir_out(epd) || !usb_endpoint_xfer_bulk(epd)) {

		snd_printdd(KERN_ERR "endpoint[2] isn't bulk output\n");

		dev_dbg(&umidi->dev->dev, "endpoint[2] isn't bulk output\n");

		return -ENXIO;

	}

	if (endpoint->out_cables > 0x0001) {

		epd = get_endpoint(hostif, 4);

		if (!usb_endpoint_dir_out(epd) ||

		    !usb_endpoint_xfer_bulk(epd)) {

			snd_printdd(KERN_ERR "endpoint[4] isn't bulk output\n");

			dev_dbg(&umidi->dev->dev, "endpoint[4] isn't bulk output\n");

			return -ENXIO;

		}

	}
@@ -2289,7 +2292,7 @@ int snd_usbmidi_create(struct snd_card *card, 
		err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);

		break;

	default:

		snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);

		dev_err(&umidi->dev->dev, "invalid quirk type %d\n", quirk->type);

		err = -ENXIO;

		break;

	}