[linux-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 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);
}

/* Most of drivers need only this one */
static inline int snd_mask_test_format(const struct snd_mask *mask,
				       snd_pcm_format_t format)
{
	return snd_mask_test(mask, (__force unsigned int)format);
}

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