[linux-2.6-block.git] / include / sound / pcm_params.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
#ifndef __SOUND_PCM_PARAMS_H
#define __SOUND_PCM_PARAMS_H

/*
 *  PCM params helpers
 *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
 */

#include <sound/pcm.h>

int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
			   struct snd_pcm_hw_params *params,
			   snd_pcm_hw_param_t var, int *dir);
int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
			  struct snd_pcm_hw_params *params,
			  snd_pcm_hw_param_t var, int *dir);
int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
			   snd_pcm_hw_param_t var, int *dir);

#define SNDRV_MASK_BITS	64	/* we use so far 64bits only */
#define SNDRV_MASK_SIZE	(SNDRV_MASK_BITS / 32)
#define MASK_OFS(i)	((i) >> 5)
#define MASK_BIT(i)	(1U << ((i) & 31))

static inline size_t snd_mask_sizeof(void)
{
	return sizeof(struct snd_mask);
}

static inline void snd_mask_none(struct snd_mask *mask)
{
	memset(mask, 0, sizeof(*mask));
}

static inline void snd_mask_any(struct snd_mask *mask)
{
	memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
}

static inline int snd_mask_empty(const struct snd_mask *mask)
{
	int i;
	for (i = 0; i < SNDRV_MASK_SIZE; i++)
		if (mask->bits[i])
			return 0;
	return 1;
}

static inline unsigned int snd_mask_min(const struct snd_mask *mask)
{
	int i;
	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
		if (mask->bits[i])
			return __ffs(mask->bits[i]) + (i << 5);
	}
	return 0;
}

static inline unsigned int snd_mask_max(const struct snd_mask *mask)
{
	int i;
	for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
		if (mask->bits[i])
			return __fls(mask->bits[i]) + (i << 5);
	}
	return 0;
}

static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
{
	mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
}

/* Most of drivers need only this one */
static inline void snd_mask_set_format(struct snd_mask *mask,
				       snd_pcm_format_t format)
{
	snd_mask_set(mask, (__force unsigned int)format);
}

static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
{
	mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
}

static inline void snd_mask_set_range(struct snd_mask *mask,
				      unsigned int from, unsigned int to)
{
	unsigned int i;
	for (i = from; i <= to; i++)
		mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
}

static inline void snd_mask_reset_range(struct snd_mask *mask,
					unsigned int from, unsigned int to)
{
	unsigned int i;
	for (i = from; i <= to; i++)
		mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
}

static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
{
	unsigned int v;
	v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
	snd_mask_none(mask);
	mask->bits[MASK_OFS(val)] = v;
}

static inline void snd_mask_intersect(struct snd_mask *mask,
				      const struct snd_mask *v)
{
	int i;
	for (i = 0; i < SNDRV_MASK_SIZE; i++)
		mask->bits[i] &= v->bits[i];
}

static inline int snd_mask_eq(const struct snd_mask *mask,
			      const struct snd_mask *v)
{
	return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
}

static inline void snd_mask_copy(struct snd_mask *mask,
				 const struct snd_mask *v)
{
	*mask = *v;
}

static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
{
	return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
}

static inline int snd_mask_single(const struct snd_mask *mask)
{
	int i, c = 0;
	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
		if (! mask->bits[i])
			continue;
		if (mask->bits[i] & (mask->bits[i] - 1))
			return 0;
		if (c)
			return 0;
		c++;
	}
	return 1;
}

static inline int snd_mask_refine(struct snd_mask *mask,
				  const struct snd_mask *v)
{
	struct snd_mask old;
	snd_mask_copy(&old, mask);
	snd_mask_intersect(mask, v);
	if (snd_mask_empty(mask))
		return -EINVAL;
	return !snd_mask_eq(mask, &old);
}

static inline int snd_mask_refine_first(struct snd_mask *mask)
{
	if (snd_mask_single(mask))
		return 0;
	snd_mask_leave(mask, snd_mask_min(mask));
	return 1;
}

static inline int snd_mask_refine_last(struct snd_mask *mask)
{
	if (snd_mask_single(mask))
		return 0;
	snd_mask_leave(mask, snd_mask_max(mask));
	return 1;
}

static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
{
	if (snd_mask_min(mask) >= val)
		return 0;
	snd_mask_reset_range(mask, 0, val - 1);
	if (snd_mask_empty(mask))
		return -EINVAL;
	return 1;
}

static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
{
	if (snd_mask_max(mask) <= val)
		return 0;
	snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
	if (snd_mask_empty(mask))
		return -EINVAL;
	return 1;
}

static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
{
	int changed;
	changed = !snd_mask_single(mask);
	snd_mask_leave(mask, val);
	if (snd_mask_empty(mask))
		return -EINVAL;
	return changed;
}

static inline int snd_mask_value(const struct snd_mask *mask)
{
	return snd_mask_min(mask);
}

static inline void snd_interval_any(struct snd_interval *i)
{
	i->min = 0;
	i->openmin = 0;
	i->max = UINT_MAX;
	i->openmax = 0;
	i->integer = 0;
	i->empty = 0;
}

static inline void snd_interval_none(struct snd_interval *i)
{
	i->empty = 1;
}

static inline int snd_interval_checkempty(const struct snd_interval *i)
{
	return (i->min > i->max ||
		(i->min == i->max && (i->openmin || i->openmax)));
}

static inline int snd_interval_empty(const struct snd_interval *i)
{
	return i->empty;
}

static inline int snd_interval_single(const struct snd_interval *i)
{
	return (i->min == i->max || 
		(i->min + 1 == i->max && (i->openmin || i->openmax)));
}

static inline int snd_interval_value(const struct snd_interval *i)
{
	if (i->openmin && !i->openmax)
		return i->max;
	return i->min;
}

static inline int snd_interval_min(const struct snd_interval *i)
{
	return i->min;
}

static inline int snd_interval_max(const struct snd_interval *i)
{
	unsigned int v;
	v = i->max;
	if (i->openmax)
		v--;
	return v;
}

static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
{
	return !((i->min > val || (i->min == val && i->openmin) ||
		  i->max < val || (i->max == val && i->openmax)));
}

static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
{
	*d = *s;
}

static inline int snd_interval_setinteger(struct snd_interval *i)
{
	if (i->integer)
		return 0;
	if (i->openmin && i->openmax && i->min == i->max)
		return -EINVAL;
	i->integer = 1;
	return 1;
}

static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
{
	if (i1->empty)
		return i2->empty;
	if (i2->empty)
		return i1->empty;
	return i1->min == i2->min && i1->openmin == i2->openmin &&
		i1->max == i2->max && i1->openmax == i2->openmax;
}

/**
 * params_access - get the access type from the hw params
 * @p: hw params
 */
static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
{
	return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
		SNDRV_PCM_HW_PARAM_ACCESS));
}

/**
 * params_format - get the sample format from the hw params
 * @p: hw params
 */
static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
{
	return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
		SNDRV_PCM_HW_PARAM_FORMAT));
}

/**
 * params_subformat - get the sample subformat from the hw params
 * @p: hw params
 */
static inline snd_pcm_subformat_t
params_subformat(const struct snd_pcm_hw_params *p)
{
	return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
		SNDRV_PCM_HW_PARAM_SUBFORMAT));
}

/**
 * params_period_bytes - get the period size (in bytes) from the hw params
 * @p: hw params
 */
static inline unsigned int
params_period_bytes(const struct snd_pcm_hw_params *p)
{
	return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
}

/**
 * params_width - get the number of bits of the sample format from the hw params
 * @p: hw params
 *
 * This function returns the number of bits per sample that the selected sample
 * format of the hw params has.
 */
static inline int params_width(const struct snd_pcm_hw_params *p)
{
	return snd_pcm_format_width(params_format(p));
}

/*
 * params_physical_width - get the storage size of the sample format from the hw params
 * @p: hw params
 *
 * This functions returns the number of bits per sample that the selected sample
 * format of the hw params takes up in memory. This will be equal or larger than
 * params_width().
 */
static inline int params_physical_width(const struct snd_pcm_hw_params *p)
{
	return snd_pcm_format_physical_width(params_format(p));
}

static inline void
params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
{
	snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
}

#endif /* __SOUND_PCM_PARAMS_H */
Commit	Line	Data
1a59d1b8	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
1da177e4 LT	2	#ifndef __SOUND_PCM_PARAMS_H
	3	#define __SOUND_PCM_PARAMS_H
	4
	5	/*
	6	* PCM params helpers
	7	* Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
1da177e4 LT	8	*/
1da177e4 LT	9
f3761c39 MB	10	#include <sound/pcm.h>
f3761c39 MB	11
e88e8ae6 TI	12	int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
	13	struct snd_pcm_hw_params *params,
	14	snd_pcm_hw_param_t var, int *dir);
	15	int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
	16	struct snd_pcm_hw_params *params,
	17	snd_pcm_hw_param_t var, int *dir);
	18	int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
	19	snd_pcm_hw_param_t var, int *dir);
1da177e4	20
1da177e4 LT	21	#define SNDRV_MASK_BITS 64 /* we use so far 64bits only */
	22	#define SNDRV_MASK_SIZE (SNDRV_MASK_BITS / 32)
	23	#define MASK_OFS(i) ((i) >> 5)
	24	#define MASK_BIT(i) (1U << ((i) & 31))
	25
9bb22e21	26	static inline size_t snd_mask_sizeof(void)
1da177e4	27	{
877211f5	28	return sizeof(struct snd_mask);
1da177e4 LT	29	}
1da177e4 LT	30
9bb22e21	31	static inline void snd_mask_none(struct snd_mask *mask)
1da177e4 LT	32	{
	33	memset(mask, 0, sizeof(*mask));
	34	}
	35
9bb22e21	36	static inline void snd_mask_any(struct snd_mask *mask)
1da177e4 LT	37	{
	38	memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
	39	}
	40
9bb22e21	41	static inline int snd_mask_empty(const struct snd_mask *mask)
1da177e4 LT	42	{
	43	int i;
	44	for (i = 0; i < SNDRV_MASK_SIZE; i++)
	45	if (mask->bits[i])
	46	return 0;
	47	return 1;
	48	}
	49
9bb22e21	50	static inline unsigned int snd_mask_min(const struct snd_mask *mask)
1da177e4 LT	51	{
1da177e4 LT	52	int i;
1da177e4 LT	53	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
1da177e4 LT	54	if (mask->bits[i])
599ee329	55	return __ffs(mask->bits[i]) + (i << 5);
1da177e4 LT	56	}
	57	return 0;
	58	}
	59
9bb22e21	60	static inline unsigned int snd_mask_max(const struct snd_mask *mask)
1da177e4 LT	61	{
1da177e4 LT	62	int i;
1da177e4 LT	63	for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
1da177e4 LT	64	if (mask->bits[i])
757b0376	65	return __fls(mask->bits[i]) + (i << 5);
1da177e4 LT	66	}
	67	return 0;
	68	}
	69
9bb22e21	70	static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
1da177e4	71	{
1da177e4 LT	72	mask->bits[MASK_OFS(val)] \|= MASK_BIT(val);
	73	}
	74
0b62834e TI	75	/* Most of drivers need only this one */
	76	static inline void snd_mask_set_format(struct snd_mask *mask,
	77	snd_pcm_format_t format)
	78	{
	79	snd_mask_set(mask, (__force unsigned int)format);
	80	}
	81
9bb22e21	82	static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
1da177e4	83	{
1da177e4 LT	84	mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
	85	}
	86
9bb22e21 TI	87	static inline void snd_mask_set_range(struct snd_mask *mask,
9bb22e21 TI	88	unsigned int from, unsigned int to)
1da177e4 LT	89	{
1da177e4 LT	90	unsigned int i;
1da177e4 LT	91	for (i = from; i <= to; i++)
	92	mask->bits[MASK_OFS(i)] \|= MASK_BIT(i);
	93	}
	94
9bb22e21 TI	95	static inline void snd_mask_reset_range(struct snd_mask *mask,
9bb22e21 TI	96	unsigned int from, unsigned int to)
1da177e4 LT	97	{
1da177e4 LT	98	unsigned int i;
1da177e4 LT	99	for (i = from; i <= to; i++)
	100	mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
	101	}
	102
9bb22e21	103	static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
1da177e4 LT	104	{
1da177e4 LT	105	unsigned int v;
1da177e4 LT	106	v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
	107	snd_mask_none(mask);
	108	mask->bits[MASK_OFS(val)] = v;
	109	}
	110
9bb22e21 TI	111	static inline void snd_mask_intersect(struct snd_mask *mask,
9bb22e21 TI	112	const struct snd_mask *v)
1da177e4 LT	113	{
	114	int i;
	115	for (i = 0; i < SNDRV_MASK_SIZE; i++)
	116	mask->bits[i] &= v->bits[i];
	117	}
	118
9bb22e21 TI	119	static inline int snd_mask_eq(const struct snd_mask *mask,
9bb22e21 TI	120	const struct snd_mask *v)
1da177e4 LT	121	{
	122	return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
	123	}
	124
9bb22e21 TI	125	static inline void snd_mask_copy(struct snd_mask *mask,
9bb22e21 TI	126	const struct snd_mask *v)
1da177e4 LT	127	{
	128	mask = v;
	129	}
	130
9bb22e21	131	static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
1da177e4	132	{
1da177e4 LT	133	return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
	134	}
	135
9bb22e21	136	static inline int snd_mask_single(const struct snd_mask *mask)
1da177e4 LT	137	{
1da177e4 LT	138	int i, c = 0;
1da177e4 LT	139	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
	140	if (! mask->bits[i])
	141	continue;
	142	if (mask->bits[i] & (mask->bits[i] - 1))
	143	return 0;
	144	if (c)
	145	return 0;
	146	c++;
	147	}
	148	return 1;
	149	}
	150
9bb22e21 TI	151	static inline int snd_mask_refine(struct snd_mask *mask,
9bb22e21 TI	152	const struct snd_mask *v)
1da177e4	153	{
877211f5	154	struct snd_mask old;
1da177e4 LT	155	snd_mask_copy(&old, mask);
	156	snd_mask_intersect(mask, v);
	157	if (snd_mask_empty(mask))
	158	return -EINVAL;
	159	return !snd_mask_eq(mask, &old);
	160	}
	161
9bb22e21	162	static inline int snd_mask_refine_first(struct snd_mask *mask)
1da177e4	163	{
1da177e4 LT	164	if (snd_mask_single(mask))
	165	return 0;
	166	snd_mask_leave(mask, snd_mask_min(mask));
	167	return 1;
	168	}
	169
9bb22e21	170	static inline int snd_mask_refine_last(struct snd_mask *mask)
1da177e4	171	{
1da177e4 LT	172	if (snd_mask_single(mask))
	173	return 0;
	174	snd_mask_leave(mask, snd_mask_max(mask));
	175	return 1;
	176	}
	177
9bb22e21	178	static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
1da177e4	179	{
1da177e4 LT	180	if (snd_mask_min(mask) >= val)
	181	return 0;
	182	snd_mask_reset_range(mask, 0, val - 1);
	183	if (snd_mask_empty(mask))
	184	return -EINVAL;
	185	return 1;
	186	}
	187
9bb22e21	188	static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
1da177e4	189	{
1da177e4 LT	190	if (snd_mask_max(mask) <= val)
	191	return 0;
	192	snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
	193	if (snd_mask_empty(mask))
	194	return -EINVAL;
	195	return 1;
	196	}
	197
9bb22e21	198	static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
1da177e4 LT	199	{
1da177e4 LT	200	int changed;
1da177e4 LT	201	changed = !snd_mask_single(mask);
	202	snd_mask_leave(mask, val);
	203	if (snd_mask_empty(mask))
	204	return -EINVAL;
	205	return changed;
	206	}
	207
9bb22e21	208	static inline int snd_mask_value(const struct snd_mask *mask)
1da177e4	209	{
1da177e4 LT	210	return snd_mask_min(mask);
	211	}
	212
9bb22e21	213	static inline void snd_interval_any(struct snd_interval *i)
1da177e4 LT	214	{
	215	i->min = 0;
	216	i->openmin = 0;
	217	i->max = UINT_MAX;
	218	i->openmax = 0;
	219	i->integer = 0;
	220	i->empty = 0;
	221	}
	222
9bb22e21	223	static inline void snd_interval_none(struct snd_interval *i)
1da177e4 LT	224	{
	225	i->empty = 1;
	226	}
	227
9bb22e21	228	static inline int snd_interval_checkempty(const struct snd_interval *i)
1da177e4 LT	229	{
	230	return (i->min > i->max \|\|
	231	(i->min == i->max && (i->openmin \|\| i->openmax)));
	232	}
	233
9bb22e21	234	static inline int snd_interval_empty(const struct snd_interval *i)
1da177e4 LT	235	{
	236	return i->empty;
	237	}
	238
9bb22e21	239	static inline int snd_interval_single(const struct snd_interval *i)
1da177e4	240	{
1da177e4	241	return (i->min == i->max \|\|
5363857b	242	(i->min + 1 == i->max && (i->openmin \|\| i->openmax)));
1da177e4 LT	243	}
1da177e4 LT	244
9bb22e21	245	static inline int snd_interval_value(const struct snd_interval *i)
1da177e4	246	{
5363857b TI	247	if (i->openmin && !i->openmax)
5363857b TI	248	return i->max;
1da177e4 LT	249	return i->min;
	250	}
	251
9bb22e21	252	static inline int snd_interval_min(const struct snd_interval *i)
1da177e4	253	{
1da177e4 LT	254	return i->min;
	255	}
	256
9bb22e21	257	static inline int snd_interval_max(const struct snd_interval *i)
1da177e4 LT	258	{
1da177e4 LT	259	unsigned int v;
1da177e4 LT	260	v = i->max;
	261	if (i->openmax)
	262	v--;
	263	return v;
	264	}
	265
9bb22e21	266	static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
1da177e4 LT	267	{
	268	return !((i->min > val \|\| (i->min == val && i->openmin) \|\|
	269	i->max < val \|\| (i->max == val && i->openmax)));
	270	}
	271
9bb22e21	272	static inline void snd_interval_copy(struct snd_interval d, const struct snd_interval s)
1da177e4 LT	273	{
	274	d = s;
	275	}
	276
9bb22e21	277	static inline int snd_interval_setinteger(struct snd_interval *i)
1da177e4 LT	278	{
	279	if (i->integer)
	280	return 0;
	281	if (i->openmin && i->openmax && i->min == i->max)
	282	return -EINVAL;
	283	i->integer = 1;
	284	return 1;
	285	}
	286
9bb22e21	287	static inline int snd_interval_eq(const struct snd_interval i1, const struct snd_interval i2)
1da177e4 LT	288	{
	289	if (i1->empty)
	290	return i2->empty;
	291	if (i2->empty)
	292	return i1->empty;
	293	return i1->min == i2->min && i1->openmin == i2->openmin &&
	294	i1->max == i2->max && i1->openmax == i2->openmax;
	295	}
	296
89827ca9 LPC	297	/**
	298	* params_access - get the access type from the hw params
	299	* @p: hw params
	300	*/
744c2ad2 LPC	301	static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
	302	{
	303	return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
	304	SNDRV_PCM_HW_PARAM_ACCESS));
	305	}
	306
89827ca9 LPC	307	/**
	308	* params_format - get the sample format from the hw params
	309	* @p: hw params
	310	*/
744c2ad2 LPC	311	static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
	312	{
	313	return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
	314	SNDRV_PCM_HW_PARAM_FORMAT));
	315	}
	316
89827ca9 LPC	317	/**
	318	* params_subformat - get the sample subformat from the hw params
	319	* @p: hw params
	320	*/
744c2ad2 LPC	321	static inline snd_pcm_subformat_t
	322	params_subformat(const struct snd_pcm_hw_params *p)
	323	{
	324	return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
	325	SNDRV_PCM_HW_PARAM_SUBFORMAT));
	326	}
1da177e4	327
89827ca9 LPC	328	/**
	329	* params_period_bytes - get the period size (in bytes) from the hw params
	330	* @p: hw params
	331	*/
b51beb75 TI	332	static inline unsigned int
	333	params_period_bytes(const struct snd_pcm_hw_params *p)
	334	{
cd9978f1	335	return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
b51beb75 TI	336	}
b51beb75 TI	337
89827ca9 LPC	338	/**
	339	* params_width - get the number of bits of the sample format from the hw params
	340	* @p: hw params
	341	*
	342	* This function returns the number of bits per sample that the selected sample
	343	* format of the hw params has.
	344	*/
	345	static inline int params_width(const struct snd_pcm_hw_params *p)
8c5178fc MB	346	{
	347	return snd_pcm_format_width(params_format(p));
	348	}
	349
89827ca9 LPC	350	/*
	351	* params_physical_width - get the storage size of the sample format from the hw params
	352	* @p: hw params
	353	*
	354	* This functions returns the number of bits per sample that the selected sample
	355	* format of the hw params takes up in memory. This will be equal or larger than
	356	* params_width().
	357	*/
	358	static inline int params_physical_width(const struct snd_pcm_hw_params *p)
8c5178fc MB	359	{
	360	return snd_pcm_format_physical_width(params_format(p));
	361	}
	362
052a9f69 FY	363	static inline void
	364	params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
	365	{
0b62834e	366	snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
052a9f69 FY	367	}
052a9f69 FY	368
b51beb75	369	#endif /* __SOUND_PCM_PARAMS_H */