[mirror_ubuntu-eoan-kernel.git] / sound / usb / clock.c

/*
 *   Clock domain and sample rate management functions
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/bitops.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/usb.h>
#include <linux/usb/audio.h>
#include <linux/usb/audio-v2.h>
#include <linux/usb/audio-v3.h>

#include <sound/core.h>
#include <sound/info.h>
#include <sound/pcm.h>

#include "usbaudio.h"
#include "card.h"
#include "helper.h"
#include "clock.h"
#include "quirks.h"

static void *find_uac_clock_desc(struct usb_host_interface *iface, int id,
				 bool (*validator)(void *, int), u8 type)
{
	void *cs = NULL;

	while ((cs = snd_usb_find_csint_desc(iface->extra, iface->extralen,
					     cs, type))) {
		if (validator(cs, id))
			return cs;
	}

	return NULL;
}

static bool validate_clock_source_v2(void *p, int id)
{
	struct uac_clock_source_descriptor *cs = p;
	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
}

static bool validate_clock_source_v3(void *p, int id)
{
	struct uac3_clock_source_descriptor *cs = p;
	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
}

static bool validate_clock_selector_v2(void *p, int id)
{
	struct uac_clock_selector_descriptor *cs = p;
	return cs->bLength >= sizeof(*cs) && cs->bClockID == id &&
		cs->bLength == 7 + cs->bNrInPins;
}

static bool validate_clock_selector_v3(void *p, int id)
{
	struct uac3_clock_selector_descriptor *cs = p;
	return cs->bLength >= sizeof(*cs) && cs->bClockID == id &&
		cs->bLength == 11 + cs->bNrInPins;
}

static bool validate_clock_multiplier_v2(void *p, int id)
{
	struct uac_clock_multiplier_descriptor *cs = p;
	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
}

static bool validate_clock_multiplier_v3(void *p, int id)
{
	struct uac3_clock_multiplier_descriptor *cs = p;
	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
}

#define DEFINE_FIND_HELPER(name, obj, validator, type)		\
static obj *name(struct usb_host_interface *iface, int id)	\
{								\
	return find_uac_clock_desc(iface, id, validator, type);	\
}

DEFINE_FIND_HELPER(snd_usb_find_clock_source,
		   struct uac_clock_source_descriptor,
		   validate_clock_source_v2, UAC2_CLOCK_SOURCE);
DEFINE_FIND_HELPER(snd_usb_find_clock_source_v3,
		   struct uac3_clock_source_descriptor,
		   validate_clock_source_v3, UAC3_CLOCK_SOURCE);

DEFINE_FIND_HELPER(snd_usb_find_clock_selector,
		   struct uac_clock_selector_descriptor,
		   validate_clock_selector_v2, UAC2_CLOCK_SELECTOR);
DEFINE_FIND_HELPER(snd_usb_find_clock_selector_v3,
		   struct uac3_clock_selector_descriptor,
		   validate_clock_selector_v3, UAC3_CLOCK_SELECTOR);

DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier,
		   struct uac_clock_multiplier_descriptor,
		   validate_clock_multiplier_v2, UAC2_CLOCK_MULTIPLIER);
DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier_v3,
		   struct uac3_clock_multiplier_descriptor,
		   validate_clock_multiplier_v3, UAC3_CLOCK_MULTIPLIER);

static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id)
{
	unsigned char buf;
	int ret;

	ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
			      UAC2_CS_CUR,
			      USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
			      UAC2_CX_CLOCK_SELECTOR << 8,
			      snd_usb_ctrl_intf(chip) | (selector_id << 8),
			      &buf, sizeof(buf));

	if (ret < 0)
		return ret;

	return buf;
}

static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_id,
					unsigned char pin)
{
	int ret;

	ret = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
			      UAC2_CS_CUR,
			      USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
			      UAC2_CX_CLOCK_SELECTOR << 8,
			      snd_usb_ctrl_intf(chip) | (selector_id << 8),
			      &pin, sizeof(pin));
	if (ret < 0)
		return ret;

	if (ret != sizeof(pin)) {
		usb_audio_err(chip,
			"setting selector (id %d) unexpected length %d\n",
			selector_id, ret);
		return -EINVAL;
	}

	ret = uac_clock_selector_get_val(chip, selector_id);
	if (ret < 0)
		return ret;

	if (ret != pin) {
		usb_audio_err(chip,
			"setting selector (id %d) to %x failed (current: %d)\n",
			selector_id, pin, ret);
		return -EINVAL;
	}

	return ret;
}

static bool uac_clock_source_is_valid(struct snd_usb_audio *chip,
				      int protocol,
				      int source_id)
{
	int err;
	unsigned char data;
	struct usb_device *dev = chip->dev;
	u32 bmControls;

	if (protocol == UAC_VERSION_3) {
		struct uac3_clock_source_descriptor *cs_desc =
			snd_usb_find_clock_source_v3(chip->ctrl_intf, source_id);

		if (!cs_desc)
			return 0;
		bmControls = le32_to_cpu(cs_desc->bmControls);
	} else { /* UAC_VERSION_1/2 */
		struct uac_clock_source_descriptor *cs_desc =
			snd_usb_find_clock_source(chip->ctrl_intf, source_id);

		if (!cs_desc)
			return 0;
		bmControls = cs_desc->bmControls;
	}

	/* If a clock source can't tell us whether it's valid, we assume it is */
	if (!uac_v2v3_control_is_readable(bmControls,
				      UAC2_CS_CONTROL_CLOCK_VALID))
		return 1;

	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
			      USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
			      UAC2_CS_CONTROL_CLOCK_VALID << 8,
			      snd_usb_ctrl_intf(chip) | (source_id << 8),
			      &data, sizeof(data));

	if (err < 0) {
		dev_warn(&dev->dev,
			 "%s(): cannot get clock validity for id %d\n",
			   __func__, source_id);
		return 0;
	}

	return !!data;
}

static int __uac_clock_find_source(struct snd_usb_audio *chip, int entity_id,
				   unsigned long *visited, bool validate)
{
	struct uac_clock_source_descriptor *source;
	struct uac_clock_selector_descriptor *selector;
	struct uac_clock_multiplier_descriptor *multiplier;

	entity_id &= 0xff;

	if (test_and_set_bit(entity_id, visited)) {
		usb_audio_warn(chip,
			 "%s(): recursive clock topology detected, id %d.\n",
			 __func__, entity_id);
		return -EINVAL;
	}

	/* first, see if the ID we're looking for is a clock source already */
	source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id);
	if (source) {
		entity_id = source->bClockID;
		if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_2,
								entity_id)) {
			usb_audio_err(chip,
				"clock source %d is not valid, cannot use\n",
				entity_id);
			return -ENXIO;
		}
		return entity_id;
	}

	selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id);
	if (selector) {
		int ret, i, cur;

		/* the entity ID we are looking for is a selector.
		 * find out what it currently selects */
		ret = uac_clock_selector_get_val(chip, selector->bClockID);
		if (ret < 0)
			return ret;

		/* Selector values are one-based */

		if (ret > selector->bNrInPins || ret < 1) {
			usb_audio_err(chip,
				"%s(): selector reported illegal value, id %d, ret %d\n",
				__func__, selector->bClockID, ret);

			return -EINVAL;
		}

		cur = ret;
		ret = __uac_clock_find_source(chip, selector->baCSourceID[ret - 1],
					       visited, validate);
		if (!validate || ret > 0 || !chip->autoclock)
			return ret;

		/* The current clock source is invalid, try others. */
		for (i = 1; i <= selector->bNrInPins; i++) {
			int err;

			if (i == cur)
				continue;

			ret = __uac_clock_find_source(chip, selector->baCSourceID[i - 1],
				visited, true);
			if (ret < 0)
				continue;

			err = uac_clock_selector_set_val(chip, entity_id, i);
			if (err < 0)
				continue;

			usb_audio_info(chip,
				 "found and selected valid clock source %d\n",
				 ret);
			return ret;
		}

		return -ENXIO;
	}

	/* FIXME: multipliers only act as pass-thru element for now */
	multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id);
	if (multiplier)
		return __uac_clock_find_source(chip, multiplier->bCSourceID,
						visited, validate);

	return -EINVAL;
}

static int __uac3_clock_find_source(struct snd_usb_audio *chip, int entity_id,
				   unsigned long *visited, bool validate)
{
	struct uac3_clock_source_descriptor *source;
	struct uac3_clock_selector_descriptor *selector;
	struct uac3_clock_multiplier_descriptor *multiplier;

	entity_id &= 0xff;

	if (test_and_set_bit(entity_id, visited)) {
		usb_audio_warn(chip,
			 "%s(): recursive clock topology detected, id %d.\n",
			 __func__, entity_id);
		return -EINVAL;
	}

	/* first, see if the ID we're looking for is a clock source already */
	source = snd_usb_find_clock_source_v3(chip->ctrl_intf, entity_id);
	if (source) {
		entity_id = source->bClockID;
		if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_3,
								entity_id)) {
			usb_audio_err(chip,
				"clock source %d is not valid, cannot use\n",
				entity_id);
			return -ENXIO;
		}
		return entity_id;
	}

	selector = snd_usb_find_clock_selector_v3(chip->ctrl_intf, entity_id);
	if (selector) {
		int ret, i, cur;

		/* the entity ID we are looking for is a selector.
		 * find out what it currently selects */
		ret = uac_clock_selector_get_val(chip, selector->bClockID);
		if (ret < 0)
			return ret;

		/* Selector values are one-based */

		if (ret > selector->bNrInPins || ret < 1) {
			usb_audio_err(chip,
				"%s(): selector reported illegal value, id %d, ret %d\n",
				__func__, selector->bClockID, ret);

			return -EINVAL;
		}

		cur = ret;
		ret = __uac3_clock_find_source(chip, selector->baCSourceID[ret - 1],
					       visited, validate);
		if (!validate || ret > 0 || !chip->autoclock)
			return ret;

		/* The current clock source is invalid, try others. */
		for (i = 1; i <= selector->bNrInPins; i++) {
			int err;

			if (i == cur)
				continue;

			ret = __uac3_clock_find_source(chip, selector->baCSourceID[i - 1],
				visited, true);
			if (ret < 0)
				continue;

			err = uac_clock_selector_set_val(chip, entity_id, i);
			if (err < 0)
				continue;

			usb_audio_info(chip,
				 "found and selected valid clock source %d\n",
				 ret);
			return ret;
		}

		return -ENXIO;
	}

	/* FIXME: multipliers only act as pass-thru element for now */
	multiplier = snd_usb_find_clock_multiplier_v3(chip->ctrl_intf,
						      entity_id);
	if (multiplier)
		return __uac3_clock_find_source(chip, multiplier->bCSourceID,
						visited, validate);

	return -EINVAL;
}

/*
 * For all kinds of sample rate settings and other device queries,
 * the clock source (end-leaf) must be used. However, clock selectors,
 * clock multipliers and sample rate converters may be specified as
 * clock source input to terminal. This functions walks the clock path
 * to its end and tries to find the source.
 *
 * The 'visited' bitfield is used internally to detect recursive loops.
 *
 * Returns the clock source UnitID (>=0) on success, or an error.
 */
int snd_usb_clock_find_source(struct snd_usb_audio *chip, int protocol,
			      int entity_id, bool validate)
{
	DECLARE_BITMAP(visited, 256);
	memset(visited, 0, sizeof(visited));

	switch (protocol) {
	case UAC_VERSION_2:
		return __uac_clock_find_source(chip, entity_id, visited,
					       validate);
	case UAC_VERSION_3:
		return __uac3_clock_find_source(chip, entity_id, visited,
					       validate);
	default:
		return -EINVAL;
	}
}

static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
			      struct usb_host_interface *alts,
			      struct audioformat *fmt, int rate)
{
	struct usb_device *dev = chip->dev;
	unsigned int ep;
	unsigned char data[3];
	int err, crate;

	if (get_iface_desc(alts)->bNumEndpoints < 1)
		return -EINVAL;
	ep = get_endpoint(alts, 0)->bEndpointAddress;

	/* if endpoint doesn't have sampling rate control, bail out */
	if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE))
		return 0;

	data[0] = rate;
	data[1] = rate >> 8;
	data[2] = rate >> 16;
	err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
			      USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
			      UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
			      data, sizeof(data));
	if (err < 0) {
		dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n",
			iface, fmt->altsetting, rate, ep);
		return err;
	}

	/* Don't check the sample rate for devices which we know don't
	 * support reading */
	if (snd_usb_get_sample_rate_quirk(chip))
		return 0;
	/* the firmware is likely buggy, don't repeat to fail too many times */
	if (chip->sample_rate_read_error > 2)
		return 0;

	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
			      USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
			      UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
			      data, sizeof(data));
	if (err < 0) {
		dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n",
			iface, fmt->altsetting, ep);
		chip->sample_rate_read_error++;
		return 0; /* some devices don't support reading */
	}

	crate = data[0] | (data[1] << 8) | (data[2] << 16);
	if (crate != rate) {
		dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate);
		// runtime->rate = crate;
	}

	return 0;
}

static int get_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
			      int altsetting, int clock)
{
	struct usb_device *dev = chip->dev;
	__le32 data;
	int err;

	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
			      USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
			      UAC2_CS_CONTROL_SAM_FREQ << 8,
			      snd_usb_ctrl_intf(chip) | (clock << 8),
			      &data, sizeof(data));
	if (err < 0) {
		dev_warn(&dev->dev, "%d:%d: cannot get freq (v2/v3): err %d\n",
			 iface, altsetting, err);
		return 0;
	}

	return le32_to_cpu(data);
}

static int set_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
			      struct usb_host_interface *alts,
			      struct audioformat *fmt, int rate)
{
	struct usb_device *dev = chip->dev;
	__le32 data;
	int err, cur_rate, prev_rate;
	int clock;
	bool writeable;
	u32 bmControls;

	clock = snd_usb_clock_find_source(chip, fmt->protocol,
					  fmt->clock, true);
	if (clock < 0)
		return clock;

	prev_rate = get_sample_rate_v2v3(chip, iface, fmt->altsetting, clock);
	if (prev_rate == rate)
		return 0;

	if (fmt->protocol == UAC_VERSION_3) {
		struct uac3_clock_source_descriptor *cs_desc;

		cs_desc = snd_usb_find_clock_source_v3(chip->ctrl_intf, clock);
		bmControls = le32_to_cpu(cs_desc->bmControls);
	} else {
		struct uac_clock_source_descriptor *cs_desc;

		cs_desc = snd_usb_find_clock_source(chip->ctrl_intf, clock);
		bmControls = cs_desc->bmControls;
	}

	writeable = uac_v2v3_control_is_writeable(bmControls,
						  UAC2_CS_CONTROL_SAM_FREQ);
	if (writeable) {
		data = cpu_to_le32(rate);
		err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
				      USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
				      UAC2_CS_CONTROL_SAM_FREQ << 8,
				      snd_usb_ctrl_intf(chip) | (clock << 8),
				      &data, sizeof(data));
		if (err < 0) {
			usb_audio_err(chip,
				"%d:%d: cannot set freq %d (v2/v3): err %d\n",
				iface, fmt->altsetting, rate, err);
			return err;
		}

		cur_rate = get_sample_rate_v2v3(chip, iface,
						fmt->altsetting, clock);
	} else {
		cur_rate = prev_rate;
	}

	if (cur_rate != rate) {
		if (!writeable) {
			usb_audio_warn(chip,
				 "%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",
				 iface, fmt->altsetting, rate, cur_rate);
			return -ENXIO;
		}
		usb_audio_dbg(chip,
			"current rate %d is different from the runtime rate %d\n",
			cur_rate, rate);
	}

	/* Some devices doesn't respond to sample rate changes while the
	 * interface is active. */
	if (rate != prev_rate) {
		usb_set_interface(dev, iface, 0);
		snd_usb_set_interface_quirk(dev);
		usb_set_interface(dev, iface, fmt->altsetting);
		snd_usb_set_interface_quirk(dev);
	}

	return 0;
}

int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
			     struct usb_host_interface *alts,
			     struct audioformat *fmt, int rate)
{
	switch (fmt->protocol) {
	case UAC_VERSION_1:
	default:
		return set_sample_rate_v1(chip, iface, alts, fmt, rate);

	case UAC_VERSION_3:
		if (chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
			if (rate != UAC3_BADD_SAMPLING_RATE)
				return -ENXIO;
			else
				return 0;
		}
	/* fall through */
	case UAC_VERSION_2:
		return set_sample_rate_v2v3(chip, iface, alts, fmt, rate);
	}
}
Commit	Line	Data
79f920fb DM	1	/*
	2	* Clock domain and sample rate management functions
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	17	*
	18	*/
	19
	20	#include <linux/bitops.h>
	21	#include <linux/init.h>
79f920fb DM	22	#include <linux/string.h>
79f920fb DM	23	#include <linux/usb.h>
79f920fb DM	24	#include <linux/usb/audio.h>
79f920fb DM	25	#include <linux/usb/audio-v2.h>
9a2fe9b8	26	#include <linux/usb/audio-v3.h>
79f920fb DM	27
	28	#include <sound/core.h>
	29	#include <sound/info.h>
	30	#include <sound/pcm.h>
79f920fb DM	31
	32	#include "usbaudio.h"
	33	#include "card.h"
79f920fb	34	#include "helper.h"
f22aa949	35	#include "clock.h"
21bb5aaf	36	#include "quirks.h"
79f920fb	37
f7645bd6 TI	38	static void find_uac_clock_desc(struct usb_host_interface iface, int id,
f7645bd6 TI	39	bool (validator)(void , int), u8 type)
79f920fb	40	{
f7645bd6	41	void *cs = NULL;
79f920fb	42
f7645bd6 TI	43	while ((cs = snd_usb_find_csint_desc(iface->extra, iface->extralen,
	44	cs, type))) {
	45	if (validator(cs, id))
79f920fb DM	46	return cs;
	47	}
	48
	49	return NULL;
	50	}
	51
f7645bd6	52	static bool validate_clock_source_v2(void *p, int id)
9a2fe9b8	53	{
f7645bd6	54	struct uac_clock_source_descriptor *cs = p;
f5d76e9c	55	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
9a2fe9b8 RB	56	}
9a2fe9b8 RB	57
f7645bd6	58	static bool validate_clock_source_v3(void *p, int id)
79f920fb	59	{
f7645bd6	60	struct uac3_clock_source_descriptor *cs = p;
b580fbff	61	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
79f920fb DM	62	}
79f920fb DM	63
f7645bd6	64	static bool validate_clock_selector_v2(void *p, int id)
9a2fe9b8	65	{
f7645bd6 TI	66	struct uac_clock_selector_descriptor *cs = p;
f7645bd6 TI	67	return cs->bLength >= sizeof(*cs) && cs->bClockID == id &&
f5d76e9c	68	cs->bLength == 7 + cs->bNrInPins;
9a2fe9b8 RB	69	}
9a2fe9b8 RB	70
f7645bd6	71	static bool validate_clock_selector_v3(void *p, int id)
79f920fb	72	{
f7645bd6	73	struct uac3_clock_selector_descriptor *cs = p;
b580fbff TI	74	return cs->bLength >= sizeof(*cs) && cs->bClockID == id &&
b580fbff TI	75	cs->bLength == 11 + cs->bNrInPins;
79f920fb DM	76	}
79f920fb DM	77
f7645bd6	78	static bool validate_clock_multiplier_v2(void *p, int id)
9a2fe9b8	79	{
f7645bd6	80	struct uac_clock_multiplier_descriptor *cs = p;
f5d76e9c	81	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
f7645bd6	82	}
9a2fe9b8	83
f7645bd6 TI	84	static bool validate_clock_multiplier_v3(void *p, int id)
	85	{
	86	struct uac3_clock_multiplier_descriptor *cs = p;
b580fbff	87	return cs->bLength == sizeof(*cs) && cs->bClockID == id;
f7645bd6	88	}
9a2fe9b8	89
f7645bd6 TI	90	#define DEFINE_FIND_HELPER(name, obj, validator, type) \
	91	static obj name(struct usb_host_interface iface, int id) \
	92	{ \
	93	return find_uac_clock_desc(iface, id, validator, type); \
9a2fe9b8 RB	94	}
9a2fe9b8 RB	95
f7645bd6 TI	96	DEFINE_FIND_HELPER(snd_usb_find_clock_source,
	97	struct uac_clock_source_descriptor,
	98	validate_clock_source_v2, UAC2_CLOCK_SOURCE);
	99	DEFINE_FIND_HELPER(snd_usb_find_clock_source_v3,
	100	struct uac3_clock_source_descriptor,
	101	validate_clock_source_v3, UAC3_CLOCK_SOURCE);
	102
	103	DEFINE_FIND_HELPER(snd_usb_find_clock_selector,
	104	struct uac_clock_selector_descriptor,
	105	validate_clock_selector_v2, UAC2_CLOCK_SELECTOR);
	106	DEFINE_FIND_HELPER(snd_usb_find_clock_selector_v3,
	107	struct uac3_clock_selector_descriptor,
	108	validate_clock_selector_v3, UAC3_CLOCK_SELECTOR);
	109
	110	DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier,
	111	struct uac_clock_multiplier_descriptor,
	112	validate_clock_multiplier_v2, UAC2_CLOCK_MULTIPLIER);
	113	DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier_v3,
	114	struct uac3_clock_multiplier_descriptor,
	115	validate_clock_multiplier_v3, UAC3_CLOCK_MULTIPLIER);
	116
79f920fb DM	117	static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id)
	118	{
	119	unsigned char buf;
	120	int ret;
	121
	122	ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
	123	UAC2_CS_CUR,
	124	USB_RECIP_INTERFACE \| USB_TYPE_CLASS \| USB_DIR_IN,
11bcbc44 DM	125	UAC2_CX_CLOCK_SELECTOR << 8,
11bcbc44 DM	126	snd_usb_ctrl_intf(chip) \| (selector_id << 8),
17d900c4	127	&buf, sizeof(buf));
79f920fb DM	128
	129	if (ret < 0)
	130	return ret;
	131
	132	return buf;
	133	}
	134
8c55af3f EZ	135	static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_id,
	136	unsigned char pin)
	137	{
	138	int ret;
	139
	140	ret = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
	141	UAC2_CS_CUR,
	142	USB_RECIP_INTERFACE \| USB_TYPE_CLASS \| USB_DIR_OUT,
	143	UAC2_CX_CLOCK_SELECTOR << 8,
	144	snd_usb_ctrl_intf(chip) \| (selector_id << 8),
	145	&pin, sizeof(pin));
	146	if (ret < 0)
	147	return ret;
	148
	149	if (ret != sizeof(pin)) {
0ba41d91 TI	150	usb_audio_err(chip,
	151	"setting selector (id %d) unexpected length %d\n",
	152	selector_id, ret);
8c55af3f EZ	153	return -EINVAL;
	154	}
	155
	156	ret = uac_clock_selector_get_val(chip, selector_id);
	157	if (ret < 0)
	158	return ret;
	159
	160	if (ret != pin) {
0ba41d91 TI	161	usb_audio_err(chip,
	162	"setting selector (id %d) to %x failed (current: %d)\n",
	163	selector_id, pin, ret);
8c55af3f EZ	164	return -EINVAL;
	165	}
	166
	167	return ret;
	168	}
	169
9a2fe9b8 RB	170	static bool uac_clock_source_is_valid(struct snd_usb_audio *chip,
	171	int protocol,
	172	int source_id)
79f920fb DM	173	{
	174	int err;
	175	unsigned char data;
	176	struct usb_device *dev = chip->dev;
9a2fe9b8 RB	177	u32 bmControls;
	178
	179	if (protocol == UAC_VERSION_3) {
	180	struct uac3_clock_source_descriptor *cs_desc =
	181	snd_usb_find_clock_source_v3(chip->ctrl_intf, source_id);
	182
	183	if (!cs_desc)
	184	return 0;
	185	bmControls = le32_to_cpu(cs_desc->bmControls);
	186	} else { /* UAC_VERSION_1/2 */
	187	struct uac_clock_source_descriptor *cs_desc =
	188	snd_usb_find_clock_source(chip->ctrl_intf, source_id);
	189
	190	if (!cs_desc)
	191	return 0;
	192	bmControls = cs_desc->bmControls;
	193	}
3bc6fbc7 DM	194
3bc6fbc7 DM	195	/* If a clock source can't tell us whether it's valid, we assume it is */
9a2fe9b8	196	if (!uac_v2v3_control_is_readable(bmControls,
21e9b3e9	197	UAC2_CS_CONTROL_CLOCK_VALID))
3bc6fbc7	198	return 1;
79f920fb DM	199
	200	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
	201	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
11bcbc44 DM	202	UAC2_CS_CONTROL_CLOCK_VALID << 8,
11bcbc44 DM	203	snd_usb_ctrl_intf(chip) \| (source_id << 8),
17d900c4	204	&data, sizeof(data));
79f920fb DM	205
79f920fb DM	206	if (err < 0) {
0ba41d91 TI	207	dev_warn(&dev->dev,
0ba41d91 TI	208	"%s(): cannot get clock validity for id %d\n",
79f920fb	209	__func__, source_id);
3bc6fbc7	210	return 0;
79f920fb DM	211	}
	212
	213	return !!data;
	214	}
	215
9a2fe9b8 RB	216	static int __uac_clock_find_source(struct snd_usb_audio *chip, int entity_id,
9a2fe9b8 RB	217	unsigned long *visited, bool validate)
79f920fb DM	218	{
	219	struct uac_clock_source_descriptor *source;
	220	struct uac_clock_selector_descriptor *selector;
	221	struct uac_clock_multiplier_descriptor *multiplier;
	222
	223	entity_id &= 0xff;
	224
	225	if (test_and_set_bit(entity_id, visited)) {
0ba41d91 TI	226	usb_audio_warn(chip,
	227	"%s(): recursive clock topology detected, id %d.\n",
	228	__func__, entity_id);
79f920fb DM	229	return -EINVAL;
	230	}
	231
	232	/* first, see if the ID we're looking for is a clock source already */
3d8d4dcf	233	source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id);
06ffc1eb EZ	234	if (source) {
06ffc1eb EZ	235	entity_id = source->bClockID;
9a2fe9b8 RB	236	if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_2,
9a2fe9b8 RB	237	entity_id)) {
0ba41d91 TI	238	usb_audio_err(chip,
	239	"clock source %d is not valid, cannot use\n",
	240	entity_id);
06ffc1eb EZ	241	return -ENXIO;
	242	}
	243	return entity_id;
	244	}
79f920fb	245
3d8d4dcf	246	selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id);
79f920fb	247	if (selector) {
8c55af3f	248	int ret, i, cur;
79f920fb DM	249
	250	/* the entity ID we are looking for is a selector.
	251	* find out what it currently selects */
	252	ret = uac_clock_selector_get_val(chip, selector->bClockID);
	253	if (ret < 0)
	254	return ret;
	255
157a57b6 DM	256	/* Selector values are one-based */
157a57b6 DM	257
79f920fb	258	if (ret > selector->bNrInPins \|\| ret < 1) {
0ba41d91	259	usb_audio_err(chip,
79f920fb DM	260	"%s(): selector reported illegal value, id %d, ret %d\n",
	261	__func__, selector->bClockID, ret);
	262
	263	return -EINVAL;
	264	}
	265
8c55af3f EZ	266	cur = ret;
8c55af3f EZ	267	ret = __uac_clock_find_source(chip, selector->baCSourceID[ret - 1],
06ffc1eb	268	visited, validate);
ef02e29b	269	if (!validate \|\| ret > 0 \|\| !chip->autoclock)
8c55af3f EZ	270	return ret;
	271
	272	/* The current clock source is invalid, try others. */
	273	for (i = 1; i <= selector->bNrInPins; i++) {
	274	int err;
	275
	276	if (i == cur)
	277	continue;
	278
	279	ret = __uac_clock_find_source(chip, selector->baCSourceID[i - 1],
	280	visited, true);
	281	if (ret < 0)
	282	continue;
	283
	284	err = uac_clock_selector_set_val(chip, entity_id, i);
	285	if (err < 0)
	286	continue;
	287
0ba41d91 TI	288	usb_audio_info(chip,
	289	"found and selected valid clock source %d\n",
	290	ret);
8c55af3f EZ	291	return ret;
	292	}
	293
	294	return -ENXIO;
79f920fb DM	295	}
	296
	297	/* FIXME: multipliers only act as pass-thru element for now */
3d8d4dcf	298	multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id);
79f920fb	299	if (multiplier)
3d8d4dcf	300	return __uac_clock_find_source(chip, multiplier->bCSourceID,
06ffc1eb	301	visited, validate);
79f920fb DM	302
	303	return -EINVAL;
	304	}
	305
9a2fe9b8 RB	306	static int __uac3_clock_find_source(struct snd_usb_audio *chip, int entity_id,
	307	unsigned long *visited, bool validate)
	308	{
	309	struct uac3_clock_source_descriptor *source;
	310	struct uac3_clock_selector_descriptor *selector;
	311	struct uac3_clock_multiplier_descriptor *multiplier;
	312
	313	entity_id &= 0xff;
	314
	315	if (test_and_set_bit(entity_id, visited)) {
	316	usb_audio_warn(chip,
	317	"%s(): recursive clock topology detected, id %d.\n",
	318	__func__, entity_id);
	319	return -EINVAL;
	320	}
	321
	322	/* first, see if the ID we're looking for is a clock source already */
	323	source = snd_usb_find_clock_source_v3(chip->ctrl_intf, entity_id);
	324	if (source) {
	325	entity_id = source->bClockID;
	326	if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_3,
	327	entity_id)) {
	328	usb_audio_err(chip,
	329	"clock source %d is not valid, cannot use\n",
	330	entity_id);
	331	return -ENXIO;
	332	}
	333	return entity_id;
	334	}
	335
	336	selector = snd_usb_find_clock_selector_v3(chip->ctrl_intf, entity_id);
	337	if (selector) {
	338	int ret, i, cur;
	339
	340	/* the entity ID we are looking for is a selector.
	341	* find out what it currently selects */
	342	ret = uac_clock_selector_get_val(chip, selector->bClockID);
	343	if (ret < 0)
	344	return ret;
	345
	346	/* Selector values are one-based */
	347
	348	if (ret > selector->bNrInPins \|\| ret < 1) {
	349	usb_audio_err(chip,
	350	"%s(): selector reported illegal value, id %d, ret %d\n",
	351	__func__, selector->bClockID, ret);
	352
	353	return -EINVAL;
	354	}
	355
	356	cur = ret;
	357	ret = __uac3_clock_find_source(chip, selector->baCSourceID[ret - 1],
	358	visited, validate);
	359	if (!validate \|\| ret > 0 \|\| !chip->autoclock)
	360	return ret;
	361
	362	/* The current clock source is invalid, try others. */
	363	for (i = 1; i <= selector->bNrInPins; i++) {
	364	int err;
	365
	366	if (i == cur)
	367	continue;
	368
	369	ret = __uac3_clock_find_source(chip, selector->baCSourceID[i - 1],
370	visited, true);
371	if (ret < 0)
372	continue;
373
374	err = uac_clock_selector_set_val(chip, entity_id, i);
375	if (err < 0)
376	continue;
377
378	usb_audio_info(chip,
379	"found and selected valid clock source %d\n",
380	ret);
381	return ret;
382	}
383
384	return -ENXIO;
385	}
386
387	/* FIXME: multipliers only act as pass-thru element for now */
388	multiplier = snd_usb_find_clock_multiplier_v3(chip->ctrl_intf,
389	entity_id);
390	if (multiplier)
391	return __uac3_clock_find_source(chip, multiplier->bCSourceID,
392	visited, validate);
393
394	return -EINVAL;
395	}
396
157a57b6 DM	397	/*
	398	* For all kinds of sample rate settings and other device queries,
	399	* the clock source (end-leaf) must be used. However, clock selectors,
	400	* clock multipliers and sample rate converters may be specified as
	401	* clock source input to terminal. This functions walks the clock path
	402	* to its end and tries to find the source.
	403	*
	404	* The 'visited' bitfield is used internally to detect recursive loops.
	405	*
	406	* Returns the clock source UnitID (>=0) on success, or an error.
	407	*/
9a2fe9b8 RB	408	int snd_usb_clock_find_source(struct snd_usb_audio *chip, int protocol,
9a2fe9b8 RB	409	int entity_id, bool validate)
79f920fb DM	410	{
	411	DECLARE_BITMAP(visited, 256);
	412	memset(visited, 0, sizeof(visited));
9a2fe9b8 RB	413
	414	switch (protocol) {
	415	case UAC_VERSION_2:
	416	return __uac_clock_find_source(chip, entity_id, visited,
	417	validate);
	418	case UAC_VERSION_3:
	419	return __uac3_clock_find_source(chip, entity_id, visited,
	420	validate);
	421	default:
	422	return -EINVAL;
	423	}
79f920fb DM	424	}
	425
	426	static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
	427	struct usb_host_interface *alts,
	428	struct audioformat *fmt, int rate)
	429	{
	430	struct usb_device *dev = chip->dev;
	431	unsigned int ep;
	432	unsigned char data[3];
	433	int err, crate;
	434
447d6275 TI	435	if (get_iface_desc(alts)->bNumEndpoints < 1)
447d6275 TI	436	return -EINVAL;
79f920fb DM	437	ep = get_endpoint(alts, 0)->bEndpointAddress;
	438
	439	/* if endpoint doesn't have sampling rate control, bail out */
d32d552e	440	if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE))
79f920fb	441	return 0;
79f920fb DM	442
	443	data[0] = rate;
	444	data[1] = rate >> 8;
	445	data[2] = rate >> 16;
f25ecf8f TI	446	err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
	447	USB_TYPE_CLASS \| USB_RECIP_ENDPOINT \| USB_DIR_OUT,
	448	UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
	449	data, sizeof(data));
	450	if (err < 0) {
0ba41d91 TI	451	dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n",
0ba41d91 TI	452	iface, fmt->altsetting, rate, ep);
79f920fb DM	453	return err;
	454	}
	455
b62b9980 JT	456	/* Don't check the sample rate for devices which we know don't
	457	* support reading */
	458	if (snd_usb_get_sample_rate_quirk(chip))
	459	return 0;
57dd5414 TI	460	/* the firmware is likely buggy, don't repeat to fail too many times */
	461	if (chip->sample_rate_read_error > 2)
	462	return 0;
b62b9980	463
f25ecf8f TI	464	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
	465	USB_TYPE_CLASS \| USB_RECIP_ENDPOINT \| USB_DIR_IN,
	466	UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
	467	data, sizeof(data));
	468	if (err < 0) {
0ba41d91 TI	469	dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n",
0ba41d91 TI	470	iface, fmt->altsetting, ep);
57dd5414	471	chip->sample_rate_read_error++;
79f920fb DM	472	return 0; /* some devices don't support reading */
	473	}
	474
	475	crate = data[0] \| (data[1] << 8) \| (data[2] << 16);
	476	if (crate != rate) {
0ba41d91	477	dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate);
79f920fb DM	478	// runtime->rate = crate;
	479	}
	480
	481	return 0;
	482	}
	483
9a2fe9b8	484	static int get_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
7c517465 TI	485	int altsetting, int clock)
	486	{
	487	struct usb_device *dev = chip->dev;
f6a8bc70	488	__le32 data;
7c517465 TI	489	int err;
	490
	491	err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
	492	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_IN,
	493	UAC2_CS_CONTROL_SAM_FREQ << 8,
	494	snd_usb_ctrl_intf(chip) \| (clock << 8),
f6a8bc70	495	&data, sizeof(data));
7c517465	496	if (err < 0) {
9a2fe9b8	497	dev_warn(&dev->dev, "%d:%d: cannot get freq (v2/v3): err %d\n",
0ba41d91	498	iface, altsetting, err);
7c517465 TI	499	return 0;
	500	}
	501
f6a8bc70	502	return le32_to_cpu(data);
7c517465 TI	503	}
7c517465 TI	504
9a2fe9b8	505	static int set_sample_rate_v2v3(struct snd_usb_audio *chip, int iface,
79f920fb DM	506	struct usb_host_interface *alts,
	507	struct audioformat *fmt, int rate)
	508	{
	509	struct usb_device *dev = chip->dev;
f6a8bc70	510	__le32 data;
690a863f	511	int err, cur_rate, prev_rate;
8c55af3f	512	int clock;
1dc669fe	513	bool writeable;
9a2fe9b8	514	u32 bmControls;
79f920fb	515
9a2fe9b8 RB	516	clock = snd_usb_clock_find_source(chip, fmt->protocol,
9a2fe9b8 RB	517	fmt->clock, true);
79f920fb DM	518	if (clock < 0)
	519	return clock;
	520
9a2fe9b8	521	prev_rate = get_sample_rate_v2v3(chip, iface, fmt->altsetting, clock);
fa92dd77 DH	522	if (prev_rate == rate)
fa92dd77 DH	523	return 0;
690a863f	524
9a2fe9b8 RB	525	if (fmt->protocol == UAC_VERSION_3) {
	526	struct uac3_clock_source_descriptor *cs_desc;
	527
	528	cs_desc = snd_usb_find_clock_source_v3(chip->ctrl_intf, clock);
	529	bmControls = le32_to_cpu(cs_desc->bmControls);
	530	} else {
	531	struct uac_clock_source_descriptor *cs_desc;
	532
	533	cs_desc = snd_usb_find_clock_source(chip->ctrl_intf, clock);
	534	bmControls = cs_desc->bmControls;
	535	}
	536
21e9b3e9 AC	537	writeable = uac_v2v3_control_is_writeable(bmControls,
21e9b3e9 AC	538	UAC2_CS_CONTROL_SAM_FREQ);
1dc669fe EZ	539	if (writeable) {
	540	data = cpu_to_le32(rate);
	541	err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
	542	USB_TYPE_CLASS \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	543	UAC2_CS_CONTROL_SAM_FREQ << 8,
	544	snd_usb_ctrl_intf(chip) \| (clock << 8),
	545	&data, sizeof(data));
	546	if (err < 0) {
0ba41d91	547	usb_audio_err(chip,
9a2fe9b8	548	"%d:%d: cannot set freq %d (v2/v3): err %d\n",
0ba41d91	549	iface, fmt->altsetting, rate, err);
1dc669fe EZ	550	return err;
1dc669fe EZ	551	}
79f920fb	552
9a2fe9b8 RB	553	cur_rate = get_sample_rate_v2v3(chip, iface,
9a2fe9b8 RB	554	fmt->altsetting, clock);
1dc669fe EZ	555	} else {
	556	cur_rate = prev_rate;
	557	}
79f920fb	558
690a863f	559	if (cur_rate != rate) {
1dc669fe	560	if (!writeable) {
0ba41d91 TI	561	usb_audio_warn(chip,
	562	"%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n",
	563	iface, fmt->altsetting, rate, cur_rate);
1dc669fe EZ	564	return -ENXIO;
1dc669fe EZ	565	}
0ba41d91 TI	566	usb_audio_dbg(chip,
	567	"current rate %d is different from the runtime rate %d\n",
	568	cur_rate, rate);
690a863f TH	569	}
	570
	571	/* Some devices doesn't respond to sample rate changes while the
	572	* interface is active. */
	573	if (rate != prev_rate) {
	574	usb_set_interface(dev, iface, 0);
21bb5aaf	575	snd_usb_set_interface_quirk(dev);
690a863f	576	usb_set_interface(dev, iface, fmt->altsetting);
21bb5aaf	577	snd_usb_set_interface_quirk(dev);
690a863f	578	}
79f920fb DM	579
	580	return 0;
	581	}
	582
	583	int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
	584	struct usb_host_interface *alts,
	585	struct audioformat *fmt, int rate)
	586	{
8f898e92	587	switch (fmt->protocol) {
79f920fb	588	case UAC_VERSION_1:
a2acad82	589	default:
79f920fb DM	590	return set_sample_rate_v1(chip, iface, alts, fmt, rate);
79f920fb DM	591
9a2fe9b8	592	case UAC_VERSION_3:
17156f23 RB	593	if (chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
	594	if (rate != UAC3_BADD_SAMPLING_RATE)
	595	return -ENXIO;
	596	else
	597	return 0;
	598	}
	599	/* fall through */
	600	case UAC_VERSION_2:
9a2fe9b8	601	return set_sample_rate_v2v3(chip, iface, alts, fmt, rate);
79f920fb	602	}
79f920fb DM	603	}
79f920fb DM	604