Linux Audio

Check our new training course

Loading...
v3.1
 
  1#ifndef __SOUND_CORE_H
  2#define __SOUND_CORE_H
  3
  4/*
  5 *  Main header file for the ALSA driver
  6 *  Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
  7 *
  8 *
  9 *   This program is free software; you can redistribute it and/or modify
 10 *   it under the terms of the GNU General Public License as published by
 11 *   the Free Software Foundation; either version 2 of the License, or
 12 *   (at your option) any later version.
 13 *
 14 *   This program is distributed in the hope that it will be useful,
 15 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 16 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17 *   GNU General Public License for more details.
 18 *
 19 *   You should have received a copy of the GNU General Public License
 20 *   along with this program; if not, write to the Free Software
 21 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 22 *
 23 */
 24
 25#include <linux/module.h>
 26#include <linux/sched.h>		/* wake_up() */
 27#include <linux/mutex.h>		/* struct mutex */
 28#include <linux/rwsem.h>		/* struct rw_semaphore */
 29#include <linux/pm.h>			/* pm_message_t */
 30#include <linux/device.h>
 31#include <linux/stringify.h>
 
 32
 33/* number of supported soundcards */
 34#ifdef CONFIG_SND_DYNAMIC_MINORS
 35#define SNDRV_CARDS 32
 36#else
 37#define SNDRV_CARDS 8		/* don't change - minor numbers */
 38#endif
 39
 40#define CONFIG_SND_MAJOR	116	/* standard configuration */
 41
 42/* forward declarations */
 43#ifdef CONFIG_PCI
 44struct pci_dev;
 45#endif
 
 46
 47/* device allocation stuff */
 48
 49#define SNDRV_DEV_TYPE_RANGE_SIZE		0x1000
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 50
 51typedef int __bitwise snd_device_type_t;
 52#define	SNDRV_DEV_TOPLEVEL	((__force snd_device_type_t) 0)
 53#define	SNDRV_DEV_CONTROL	((__force snd_device_type_t) 1)
 54#define	SNDRV_DEV_LOWLEVEL_PRE	((__force snd_device_type_t) 2)
 55#define	SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000)
 56#define	SNDRV_DEV_PCM		((__force snd_device_type_t) 0x1001)
 57#define	SNDRV_DEV_RAWMIDI	((__force snd_device_type_t) 0x1002)
 58#define	SNDRV_DEV_TIMER		((__force snd_device_type_t) 0x1003)
 59#define	SNDRV_DEV_SEQUENCER	((__force snd_device_type_t) 0x1004)
 60#define	SNDRV_DEV_HWDEP		((__force snd_device_type_t) 0x1005)
 61#define	SNDRV_DEV_INFO		((__force snd_device_type_t) 0x1006)
 62#define	SNDRV_DEV_BUS		((__force snd_device_type_t) 0x1007)
 63#define	SNDRV_DEV_CODEC		((__force snd_device_type_t) 0x1008)
 64#define	SNDRV_DEV_JACK          ((__force snd_device_type_t) 0x1009)
 65#define	SNDRV_DEV_LOWLEVEL	((__force snd_device_type_t) 0x2000)
 66
 67typedef int __bitwise snd_device_state_t;
 68#define	SNDRV_DEV_BUILD		((__force snd_device_state_t) 0)
 69#define	SNDRV_DEV_REGISTERED	((__force snd_device_state_t) 1)
 70#define	SNDRV_DEV_DISCONNECTED	((__force snd_device_state_t) 2)
 71
 72typedef int __bitwise snd_device_cmd_t;
 73#define	SNDRV_DEV_CMD_PRE	((__force snd_device_cmd_t) 0)
 74#define	SNDRV_DEV_CMD_NORMAL	((__force snd_device_cmd_t) 1)	
 75#define	SNDRV_DEV_CMD_POST	((__force snd_device_cmd_t) 2)
 76
 77struct snd_device;
 78
 79struct snd_device_ops {
 80	int (*dev_free)(struct snd_device *dev);
 81	int (*dev_register)(struct snd_device *dev);
 82	int (*dev_disconnect)(struct snd_device *dev);
 83};
 84
 85struct snd_device {
 86	struct list_head list;		/* list of registered devices */
 87	struct snd_card *card;		/* card which holds this device */
 88	snd_device_state_t state;	/* state of the device */
 89	snd_device_type_t type;		/* device type */
 90	void *device_data;		/* device structure */
 91	struct snd_device_ops *ops;	/* operations */
 92};
 93
 94#define snd_device(n) list_entry(n, struct snd_device, list)
 95
 96/* main structure for soundcard */
 97
 98struct snd_card {
 99	int number;			/* number of soundcard (index to
100								snd_cards) */
101
102	char id[16];			/* id string of this card */
103	char driver[16];		/* driver name */
104	char shortname[32];		/* short name of this soundcard */
105	char longname[80];		/* name of this soundcard */
 
106	char mixername[80];		/* mixer name */
107	char components[128];		/* card components delimited with
108								space */
109	struct module *module;		/* top-level module */
110
111	void *private_data;		/* private data for soundcard */
112	void (*private_free) (struct snd_card *card); /* callback for freeing of
113								private data */
114	struct list_head devices;	/* devices */
115
 
116	unsigned int last_numid;	/* last used numeric ID */
117	struct rw_semaphore controls_rwsem;	/* controls list lock */
118	rwlock_t ctl_files_rwlock;	/* ctl_files list lock */
119	int controls_count;		/* count of all controls */
120	int user_ctl_count;		/* count of all user controls */
121	struct list_head controls;	/* all controls for this card */
122	struct list_head ctl_files;	/* active control files */
123
124	struct snd_info_entry *proc_root;	/* root for soundcard specific files */
125	struct snd_info_entry *proc_id;	/* the card id */
126	struct proc_dir_entry *proc_root_link;	/* number link to real id */
127
128	struct list_head files_list;	/* all files associated to this card */
129	struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
130								state */
131	spinlock_t files_lock;		/* lock the files for this card */
132	int shutdown;			/* this card is going down */
133	int free_on_last_close;		/* free in context of file_release */
134	wait_queue_head_t shutdown_sleep;
135	struct device *dev;		/* device assigned to this card */
136	struct device *card_dev;	/* cardX object for sysfs */
 
 
 
 
 
 
 
 
 
 
137
138#ifdef CONFIG_PM
139	unsigned int power_state;	/* power state */
140	struct mutex power_lock;	/* power lock */
141	wait_queue_head_t power_sleep;
 
142#endif
143
144#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
145	struct snd_mixer_oss *mixer_oss;
146	int mixer_oss_change_count;
147#endif
148};
149
 
 
150#ifdef CONFIG_PM
151static inline void snd_power_lock(struct snd_card *card)
152{
153	mutex_lock(&card->power_lock);
154}
155
156static inline void snd_power_unlock(struct snd_card *card)
157{
158	mutex_unlock(&card->power_lock);
 
159}
160
161static inline unsigned int snd_power_get_state(struct snd_card *card)
 
 
 
 
 
 
 
 
162{
163	return card->power_state;
164}
165
166static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
 
 
 
 
167{
168	card->power_state = state;
169	wake_up(&card->power_sleep);
 
 
 
 
 
 
 
 
 
 
 
 
170}
171
172/* init.c */
173int snd_power_wait(struct snd_card *card, unsigned int power_state);
 
174
175#else /* ! CONFIG_PM */
176
177#define snd_power_lock(card)		do { (void)(card); } while (0)
178#define snd_power_unlock(card)		do { (void)(card); } while (0)
179static inline int snd_power_wait(struct snd_card *card, unsigned int state) { return 0; }
 
 
180#define snd_power_get_state(card)	({ (void)(card); SNDRV_CTL_POWER_D0; })
181#define snd_power_change_state(card, state)	do { (void)(card); } while (0)
182
183#endif /* CONFIG_PM */
184
185struct snd_minor {
186	int type;			/* SNDRV_DEVICE_TYPE_XXX */
187	int card;			/* card number */
188	int device;			/* device number */
189	const struct file_operations *f_ops;	/* file operations */
190	void *private_data;		/* private data for f_ops->open */
191	struct device *dev;		/* device for sysfs */
 
192};
193
194/* return a device pointer linked to each sound device as a parent */
195static inline struct device *snd_card_get_device_link(struct snd_card *card)
196{
197	return card ? card->card_dev : NULL;
198}
199
200/* sound.c */
201
202extern int snd_major;
203extern int snd_ecards_limit;
204extern struct class *sound_class;
 
 
 
205
206void snd_request_card(int card);
207
208int snd_register_device_for_dev(int type, struct snd_card *card,
209				int dev,
210				const struct file_operations *f_ops,
211				void *private_data,
212				const char *name,
213				struct device *device);
214
215/**
216 * snd_register_device - Register the ALSA device file for the card
217 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
218 * @card: the card instance
219 * @dev: the device index
220 * @f_ops: the file operations
221 * @private_data: user pointer for f_ops->open()
222 * @name: the device file name
223 *
224 * Registers an ALSA device file for the given card.
225 * The operators have to be set in reg parameter.
226 *
227 * This function uses the card's device pointer to link to the
228 * correct &struct device.
229 *
230 * Returns zero if successful, or a negative error code on failure.
231 */
232static inline int snd_register_device(int type, struct snd_card *card, int dev,
233				      const struct file_operations *f_ops,
234				      void *private_data,
235				      const char *name)
236{
237	return snd_register_device_for_dev(type, card, dev, f_ops,
238					   private_data, name,
239					   snd_card_get_device_link(card));
240}
241
242int snd_unregister_device(int type, struct snd_card *card, int dev);
243void *snd_lookup_minor_data(unsigned int minor, int type);
244int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
245			      struct device_attribute *attr);
246
247#ifdef CONFIG_SND_OSSEMUL
248int snd_register_oss_device(int type, struct snd_card *card, int dev,
249			    const struct file_operations *f_ops, void *private_data,
250			    const char *name);
251int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
252void *snd_lookup_oss_minor_data(unsigned int minor, int type);
253#endif
254
255int snd_minor_info_init(void);
256int snd_minor_info_done(void);
257
258/* sound_oss.c */
259
260#ifdef CONFIG_SND_OSSEMUL
261int snd_minor_info_oss_init(void);
262int snd_minor_info_oss_done(void);
263#else
264static inline int snd_minor_info_oss_init(void) { return 0; }
265static inline int snd_minor_info_oss_done(void) { return 0; }
266#endif
267
268/* memory.c */
269
270int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
271int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);
272
273/* init.c */
274
275extern struct snd_card *snd_cards[SNDRV_CARDS];
276int snd_card_locked(int card);
277#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
278#define SND_MIXER_OSS_NOTIFY_REGISTER	0
279#define SND_MIXER_OSS_NOTIFY_DISCONNECT	1
280#define SND_MIXER_OSS_NOTIFY_FREE	2
281extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
282#endif
283
284int snd_card_create(int idx, const char *id,
285		    struct module *module, int extra_size,
286		    struct snd_card **card_ret);
287
288int snd_card_disconnect(struct snd_card *card);
 
289int snd_card_free(struct snd_card *card);
290int snd_card_free_when_closed(struct snd_card *card);
291void snd_card_set_id(struct snd_card *card, const char *id);
292int snd_card_register(struct snd_card *card);
293int snd_card_info_init(void);
294int snd_card_info_done(void);
 
295int snd_component_add(struct snd_card *card, const char *component);
296int snd_card_file_add(struct snd_card *card, struct file *file);
297int snd_card_file_remove(struct snd_card *card, struct file *file);
298
 
 
 
 
 
 
 
 
 
 
 
 
 
 
299#define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
300
301/* device.c */
302
303int snd_device_new(struct snd_card *card, snd_device_type_t type,
304		   void *device_data, struct snd_device_ops *ops);
305int snd_device_register(struct snd_card *card, void *device_data);
306int snd_device_register_all(struct snd_card *card);
307int snd_device_disconnect(struct snd_card *card, void *device_data);
308int snd_device_disconnect_all(struct snd_card *card);
309int snd_device_free(struct snd_card *card, void *device_data);
310int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd);
 
311
312/* isadma.c */
313
314#ifdef CONFIG_ISA_DMA_API
315#define DMA_MODE_NO_ENABLE	0x0100
316
317void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode);
318void snd_dma_disable(unsigned long dma);
319unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
320#endif
321
322/* misc.c */
323struct resource;
324void release_and_free_resource(struct resource *res);
325
326/* --- */
327
 
 
 
 
 
 
 
328#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
 
329void __snd_printk(unsigned int level, const char *file, int line,
330		  const char *format, ...)
331     __attribute__ ((format (printf, 4, 5)));
332#else
333#define __snd_printk(level, file, line, format, args...) \
334	printk(format, ##args)
335#endif
336
337/**
338 * snd_printk - printk wrapper
339 * @fmt: format string
340 *
341 * Works like printk() but prints the file and the line of the caller
342 * when configured with CONFIG_SND_VERBOSE_PRINTK.
343 */
344#define snd_printk(fmt, args...) \
345	__snd_printk(0, __FILE__, __LINE__, fmt, ##args)
346
347#ifdef CONFIG_SND_DEBUG
348/**
349 * snd_printd - debug printk
350 * @fmt: format string
351 *
352 * Works like snd_printk() for debugging purposes.
353 * Ignored when CONFIG_SND_DEBUG is not set.
354 */
355#define snd_printd(fmt, args...) \
356	__snd_printk(1, __FILE__, __LINE__, fmt, ##args)
 
 
357
358/**
359 * snd_BUG - give a BUG warning message and stack trace
360 *
361 * Calls WARN() if CONFIG_SND_DEBUG is set.
362 * Ignored when CONFIG_SND_DEBUG is not set.
363 */
364#define snd_BUG()		WARN(1, "BUG?\n")
365
366/**
 
 
 
 
 
 
367 * snd_BUG_ON - debugging check macro
368 * @cond: condition to evaluate
369 *
370 * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition,
371 * and call WARN() and returns the value if it's non-zero.
372 * 
373 * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given
374 * condition is ignored.
375 *
376 * NOTE: the argument won't be evaluated at all when CONFIG_SND_DEBUG=n.
377 * Thus, don't put any statement that influences on the code behavior,
378 * such as pre/post increment, to the argument of this macro.
379 * If you want to evaluate and give a warning, use standard WARN_ON().
380 */
381#define snd_BUG_ON(cond)	WARN((cond), "BUG? (%s)\n", __stringify(cond))
382
383#else /* !CONFIG_SND_DEBUG */
384
385#define snd_printd(fmt, args...)	do { } while (0)
 
 
 
 
386#define snd_BUG()			do { } while (0)
387static inline int __snd_bug_on(int cond)
388{
389	return 0;
390}
391#define snd_BUG_ON(cond)	__snd_bug_on(0 && (cond))  /* always false */
 
 
392
393#endif /* CONFIG_SND_DEBUG */
394
395#ifdef CONFIG_SND_DEBUG_VERBOSE
396/**
397 * snd_printdd - debug printk
398 * @format: format string
399 *
400 * Works like snd_printk() for debugging purposes.
401 * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
402 */
403#define snd_printdd(format, args...) \
404	__snd_printk(2, __FILE__, __LINE__, format, ##args)
405#else
406#define snd_printdd(format, args...)	do { } while (0)
 
407#endif
408
409
410#define SNDRV_OSS_VERSION         ((3<<16)|(8<<8)|(1<<4)|(0))	/* 3.8.1a */
411
412/* for easier backward-porting */
413#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
414#define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
415#define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
416#define gameport_get_port_data(gp) (gp)->port_data
417#endif
418
419/* PCI quirk list helper */
420struct snd_pci_quirk {
421	unsigned short subvendor;	/* PCI subvendor ID */
422	unsigned short subdevice;	/* PCI subdevice ID */
423	unsigned short subdevice_mask;	/* bitmask to match */
424	int value;			/* value */
425#ifdef CONFIG_SND_DEBUG_VERBOSE
426	const char *name;		/* name of the device (optional) */
427#endif
428};
429
430#define _SND_PCI_QUIRK_ID_MASK(vend, mask, dev)	\
431	.subvendor = (vend), .subdevice = (dev), .subdevice_mask = (mask)
432#define _SND_PCI_QUIRK_ID(vend, dev) \
433	_SND_PCI_QUIRK_ID_MASK(vend, 0xffff, dev)
434#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
435#ifdef CONFIG_SND_DEBUG_VERBOSE
436#define SND_PCI_QUIRK(vend,dev,xname,val) \
437	{_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
438#define SND_PCI_QUIRK_VENDOR(vend, xname, val)			\
439	{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val), .name = (xname)}
440#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val)			\
441	{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev),			\
442			.value = (val), .name = (xname)}
 
443#else
444#define SND_PCI_QUIRK(vend,dev,xname,val) \
445	{_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
446#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val)			\
447	{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)}
448#define SND_PCI_QUIRK_VENDOR(vend, xname, val)			\
449	{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
 
450#endif
451
 
452const struct snd_pci_quirk *
453snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
454
455const struct snd_pci_quirk *
456snd_pci_quirk_lookup_id(u16 vendor, u16 device,
457			const struct snd_pci_quirk *list);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
458
459#endif /* __SOUND_CORE_H */
v5.14.15
  1/* SPDX-License-Identifier: GPL-2.0-or-later */
  2#ifndef __SOUND_CORE_H
  3#define __SOUND_CORE_H
  4
  5/*
  6 *  Main header file for the ALSA driver
  7 *  Copyright (c) 1994-2001 by Jaroslav Kysela <perex@perex.cz>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  8 */
  9
 10#include <linux/device.h>
 11#include <linux/sched.h>		/* wake_up() */
 12#include <linux/mutex.h>		/* struct mutex */
 13#include <linux/rwsem.h>		/* struct rw_semaphore */
 14#include <linux/pm.h>			/* pm_message_t */
 
 15#include <linux/stringify.h>
 16#include <linux/printk.h>
 17
 18/* number of supported soundcards */
 19#ifdef CONFIG_SND_DYNAMIC_MINORS
 20#define SNDRV_CARDS CONFIG_SND_MAX_CARDS
 21#else
 22#define SNDRV_CARDS 8		/* don't change - minor numbers */
 23#endif
 24
 25#define CONFIG_SND_MAJOR	116	/* standard configuration */
 26
 27/* forward declarations */
 
 28struct pci_dev;
 29struct module;
 30struct completion;
 31
 32/* device allocation stuff */
 33
 34/* type of the object used in snd_device_*()
 35 * this also defines the calling order
 36 */
 37enum snd_device_type {
 38	SNDRV_DEV_LOWLEVEL,
 39	SNDRV_DEV_INFO,
 40	SNDRV_DEV_BUS,
 41	SNDRV_DEV_CODEC,
 42	SNDRV_DEV_PCM,
 43	SNDRV_DEV_COMPRESS,
 44	SNDRV_DEV_RAWMIDI,
 45	SNDRV_DEV_TIMER,
 46	SNDRV_DEV_SEQUENCER,
 47	SNDRV_DEV_HWDEP,
 48	SNDRV_DEV_JACK,
 49	SNDRV_DEV_CONTROL,	/* NOTE: this must be the last one */
 50};
 51
 52enum snd_device_state {
 53	SNDRV_DEV_BUILD,
 54	SNDRV_DEV_REGISTERED,
 55	SNDRV_DEV_DISCONNECTED,
 56};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 57
 58struct snd_device;
 59
 60struct snd_device_ops {
 61	int (*dev_free)(struct snd_device *dev);
 62	int (*dev_register)(struct snd_device *dev);
 63	int (*dev_disconnect)(struct snd_device *dev);
 64};
 65
 66struct snd_device {
 67	struct list_head list;		/* list of registered devices */
 68	struct snd_card *card;		/* card which holds this device */
 69	enum snd_device_state state;	/* state of the device */
 70	enum snd_device_type type;	/* device type */
 71	void *device_data;		/* device structure */
 72	const struct snd_device_ops *ops;	/* operations */
 73};
 74
 75#define snd_device(n) list_entry(n, struct snd_device, list)
 76
 77/* main structure for soundcard */
 78
 79struct snd_card {
 80	int number;			/* number of soundcard (index to
 81								snd_cards) */
 82
 83	char id[16];			/* id string of this card */
 84	char driver[16];		/* driver name */
 85	char shortname[32];		/* short name of this soundcard */
 86	char longname[80];		/* name of this soundcard */
 87	char irq_descr[32];		/* Interrupt description */
 88	char mixername[80];		/* mixer name */
 89	char components[128];		/* card components delimited with
 90								space */
 91	struct module *module;		/* top-level module */
 92
 93	void *private_data;		/* private data for soundcard */
 94	void (*private_free) (struct snd_card *card); /* callback for freeing of
 95								private data */
 96	struct list_head devices;	/* devices */
 97
 98	struct device ctl_dev;		/* control device */
 99	unsigned int last_numid;	/* last used numeric ID */
100	struct rw_semaphore controls_rwsem;	/* controls list lock */
101	rwlock_t ctl_files_rwlock;	/* ctl_files list lock */
102	int controls_count;		/* count of all controls */
103	size_t user_ctl_alloc_size;	// current memory allocation by user controls.
104	struct list_head controls;	/* all controls for this card */
105	struct list_head ctl_files;	/* active control files */
106
107	struct snd_info_entry *proc_root;	/* root for soundcard specific files */
 
108	struct proc_dir_entry *proc_root_link;	/* number link to real id */
109
110	struct list_head files_list;	/* all files associated to this card */
111	struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
112								state */
113	spinlock_t files_lock;		/* lock the files for this card */
114	int shutdown;			/* this card is going down */
115	struct completion *release_completion;
 
116	struct device *dev;		/* device assigned to this card */
117	struct device card_dev;		/* cardX object for sysfs */
118	const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
119	bool registered;		/* card_dev is registered? */
120	int sync_irq;			/* assigned irq, used for PCM sync */
121	wait_queue_head_t remove_sleep;
122
123	size_t total_pcm_alloc_bytes;	/* total amount of allocated buffers */
124	struct mutex memory_mutex;	/* protection for the above */
125#ifdef CONFIG_SND_DEBUG
126	struct dentry *debugfs_root;    /* debugfs root for card */
127#endif
128
129#ifdef CONFIG_PM
130	unsigned int power_state;	/* power state */
131	atomic_t power_ref;
132	wait_queue_head_t power_sleep;
133	wait_queue_head_t power_ref_sleep;
134#endif
135
136#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
137	struct snd_mixer_oss *mixer_oss;
138	int mixer_oss_change_count;
139#endif
140};
141
142#define dev_to_snd_card(p)	container_of(p, struct snd_card, card_dev)
143
144#ifdef CONFIG_PM
145static inline unsigned int snd_power_get_state(struct snd_card *card)
146{
147	return READ_ONCE(card->power_state);
148}
149
150static inline void snd_power_change_state(struct snd_card *card, unsigned int state)
151{
152	WRITE_ONCE(card->power_state, state);
153	wake_up(&card->power_sleep);
154}
155
156/**
157 * snd_power_ref - Take the reference count for power control
158 * @card: sound card object
159 *
160 * The power_ref reference of the card is used for managing to block
161 * the snd_power_sync_ref() operation.  This function increments the reference.
162 * The counterpart snd_power_unref() has to be called appropriately later.
163 */
164static inline void snd_power_ref(struct snd_card *card)
165{
166	atomic_inc(&card->power_ref);
167}
168
169/**
170 * snd_power_unref - Release the reference count for power control
171 * @card: sound card object
172 */
173static inline void snd_power_unref(struct snd_card *card)
174{
175	if (atomic_dec_and_test(&card->power_ref))
176		wake_up(&card->power_ref_sleep);
177}
178
179/**
180 * snd_power_sync_ref - wait until the card power_ref is freed
181 * @card: sound card object
182 *
183 * This function is used to synchronize with the pending power_ref being
184 * released.
185 */
186static inline void snd_power_sync_ref(struct snd_card *card)
187{
188	wait_event(card->power_ref_sleep, !atomic_read(&card->power_ref));
189}
190
191/* init.c */
192int snd_power_wait(struct snd_card *card);
193int snd_power_ref_and_wait(struct snd_card *card);
194
195#else /* ! CONFIG_PM */
196
197static inline int snd_power_wait(struct snd_card *card) { return 0; }
198static inline void snd_power_ref(struct snd_card *card) {}
199static inline void snd_power_unref(struct snd_card *card) {}
200static inline int snd_power_ref_and_wait(struct snd_card *card) { return 0; }
201static inline void snd_power_sync_ref(struct snd_card *card) {}
202#define snd_power_get_state(card)	({ (void)(card); SNDRV_CTL_POWER_D0; })
203#define snd_power_change_state(card, state)	do { (void)(card); } while (0)
204
205#endif /* CONFIG_PM */
206
207struct snd_minor {
208	int type;			/* SNDRV_DEVICE_TYPE_XXX */
209	int card;			/* card number */
210	int device;			/* device number */
211	const struct file_operations *f_ops;	/* file operations */
212	void *private_data;		/* private data for f_ops->open */
213	struct device *dev;		/* device for sysfs */
214	struct snd_card *card_ptr;	/* assigned card instance */
215};
216
217/* return a device pointer linked to each sound device as a parent */
218static inline struct device *snd_card_get_device_link(struct snd_card *card)
219{
220	return card ? &card->card_dev : NULL;
221}
222
223/* sound.c */
224
225extern int snd_major;
226extern int snd_ecards_limit;
227extern struct class *sound_class;
228#ifdef CONFIG_SND_DEBUG
229extern struct dentry *sound_debugfs_root;
230#endif
231
232void snd_request_card(int card);
233
234void snd_device_initialize(struct device *dev, struct snd_card *card);
 
 
 
 
 
235
236int snd_register_device(int type, struct snd_card *card, int dev,
237			const struct file_operations *f_ops,
238			void *private_data, struct device *device);
239int snd_unregister_device(struct device *dev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
240void *snd_lookup_minor_data(unsigned int minor, int type);
 
 
241
242#ifdef CONFIG_SND_OSSEMUL
243int snd_register_oss_device(int type, struct snd_card *card, int dev,
244			    const struct file_operations *f_ops, void *private_data);
 
245int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
246void *snd_lookup_oss_minor_data(unsigned int minor, int type);
247#endif
248
249int snd_minor_info_init(void);
 
250
251/* sound_oss.c */
252
253#ifdef CONFIG_SND_OSSEMUL
254int snd_minor_info_oss_init(void);
 
255#else
256static inline int snd_minor_info_oss_init(void) { return 0; }
 
257#endif
258
259/* memory.c */
260
261int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);
262int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);
263
264/* init.c */
265
 
266int snd_card_locked(int card);
267#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
268#define SND_MIXER_OSS_NOTIFY_REGISTER	0
269#define SND_MIXER_OSS_NOTIFY_DISCONNECT	1
270#define SND_MIXER_OSS_NOTIFY_FREE	2
271extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd);
272#endif
273
274int snd_card_new(struct device *parent, int idx, const char *xid,
275		 struct module *module, int extra_size,
276		 struct snd_card **card_ret);
277
278int snd_card_disconnect(struct snd_card *card);
279void snd_card_disconnect_sync(struct snd_card *card);
280int snd_card_free(struct snd_card *card);
281int snd_card_free_when_closed(struct snd_card *card);
282void snd_card_set_id(struct snd_card *card, const char *id);
283int snd_card_register(struct snd_card *card);
284int snd_card_info_init(void);
285int snd_card_add_dev_attr(struct snd_card *card,
286			  const struct attribute_group *group);
287int snd_component_add(struct snd_card *card, const char *component);
288int snd_card_file_add(struct snd_card *card, struct file *file);
289int snd_card_file_remove(struct snd_card *card, struct file *file);
290
291struct snd_card *snd_card_ref(int card);
292
293/**
294 * snd_card_unref - Unreference the card object
295 * @card: the card object to unreference
296 *
297 * Call this function for the card object that was obtained via snd_card_ref()
298 * or snd_lookup_minor_data().
299 */
300static inline void snd_card_unref(struct snd_card *card)
301{
302	put_device(&card->card_dev);
303}
304
305#define snd_card_set_dev(card, devptr) ((card)->dev = (devptr))
306
307/* device.c */
308
309int snd_device_new(struct snd_card *card, enum snd_device_type type,
310		   void *device_data, const struct snd_device_ops *ops);
311int snd_device_register(struct snd_card *card, void *device_data);
312int snd_device_register_all(struct snd_card *card);
313void snd_device_disconnect(struct snd_card *card, void *device_data);
314void snd_device_disconnect_all(struct snd_card *card);
315void snd_device_free(struct snd_card *card, void *device_data);
316void snd_device_free_all(struct snd_card *card);
317int snd_device_get_state(struct snd_card *card, void *device_data);
318
319/* isadma.c */
320
321#ifdef CONFIG_ISA_DMA_API
322#define DMA_MODE_NO_ENABLE	0x0100
323
324void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode);
325void snd_dma_disable(unsigned long dma);
326unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
327#endif
328
329/* misc.c */
330struct resource;
331void release_and_free_resource(struct resource *res);
332
333/* --- */
334
335/* sound printk debug levels */
336enum {
337	SND_PR_ALWAYS,
338	SND_PR_DEBUG,
339	SND_PR_VERBOSE,
340};
341
342#if defined(CONFIG_SND_DEBUG) || defined(CONFIG_SND_VERBOSE_PRINTK)
343__printf(4, 5)
344void __snd_printk(unsigned int level, const char *file, int line,
345		  const char *format, ...);
 
346#else
347#define __snd_printk(level, file, line, format, ...) \
348	printk(format, ##__VA_ARGS__)
349#endif
350
351/**
352 * snd_printk - printk wrapper
353 * @fmt: format string
354 *
355 * Works like printk() but prints the file and the line of the caller
356 * when configured with CONFIG_SND_VERBOSE_PRINTK.
357 */
358#define snd_printk(fmt, ...) \
359	__snd_printk(0, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
360
361#ifdef CONFIG_SND_DEBUG
362/**
363 * snd_printd - debug printk
364 * @fmt: format string
365 *
366 * Works like snd_printk() for debugging purposes.
367 * Ignored when CONFIG_SND_DEBUG is not set.
368 */
369#define snd_printd(fmt, ...) \
370	__snd_printk(1, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
371#define _snd_printd(level, fmt, ...) \
372	__snd_printk(level, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
373
374/**
375 * snd_BUG - give a BUG warning message and stack trace
376 *
377 * Calls WARN() if CONFIG_SND_DEBUG is set.
378 * Ignored when CONFIG_SND_DEBUG is not set.
379 */
380#define snd_BUG()		WARN(1, "BUG?\n")
381
382/**
383 * snd_printd_ratelimit - Suppress high rates of output when
384 * 			  CONFIG_SND_DEBUG is enabled.
385 */
386#define snd_printd_ratelimit() printk_ratelimit()
387
388/**
389 * snd_BUG_ON - debugging check macro
390 * @cond: condition to evaluate
391 *
392 * Has the same behavior as WARN_ON when CONFIG_SND_DEBUG is set,
393 * otherwise just evaluates the conditional and returns the value.
 
 
 
 
 
 
 
 
394 */
395#define snd_BUG_ON(cond)	WARN_ON((cond))
396
397#else /* !CONFIG_SND_DEBUG */
398
399__printf(1, 2)
400static inline void snd_printd(const char *format, ...) {}
401__printf(2, 3)
402static inline void _snd_printd(int level, const char *format, ...) {}
403
404#define snd_BUG()			do { } while (0)
405
406#define snd_BUG_ON(condition) ({ \
407	int __ret_warn_on = !!(condition); \
408	unlikely(__ret_warn_on); \
409})
410
411static inline bool snd_printd_ratelimit(void) { return false; }
412
413#endif /* CONFIG_SND_DEBUG */
414
415#ifdef CONFIG_SND_DEBUG_VERBOSE
416/**
417 * snd_printdd - debug printk
418 * @format: format string
419 *
420 * Works like snd_printk() for debugging purposes.
421 * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
422 */
423#define snd_printdd(format, ...) \
424	__snd_printk(2, __FILE__, __LINE__, format, ##__VA_ARGS__)
425#else
426__printf(1, 2)
427static inline void snd_printdd(const char *format, ...) {}
428#endif
429
430
431#define SNDRV_OSS_VERSION         ((3<<16)|(8<<8)|(1<<4)|(0))	/* 3.8.1a */
432
433/* for easier backward-porting */
434#if IS_ENABLED(CONFIG_GAMEPORT)
435#define gameport_set_dev_parent(gp,xdev) ((gp)->dev.parent = (xdev))
436#define gameport_set_port_data(gp,r) ((gp)->port_data = (r))
437#define gameport_get_port_data(gp) (gp)->port_data
438#endif
439
440/* PCI quirk list helper */
441struct snd_pci_quirk {
442	unsigned short subvendor;	/* PCI subvendor ID */
443	unsigned short subdevice;	/* PCI subdevice ID */
444	unsigned short subdevice_mask;	/* bitmask to match */
445	int value;			/* value */
446#ifdef CONFIG_SND_DEBUG_VERBOSE
447	const char *name;		/* name of the device (optional) */
448#endif
449};
450
451#define _SND_PCI_QUIRK_ID_MASK(vend, mask, dev)	\
452	.subvendor = (vend), .subdevice = (dev), .subdevice_mask = (mask)
453#define _SND_PCI_QUIRK_ID(vend, dev) \
454	_SND_PCI_QUIRK_ID_MASK(vend, 0xffff, dev)
455#define SND_PCI_QUIRK_ID(vend,dev) {_SND_PCI_QUIRK_ID(vend, dev)}
456#ifdef CONFIG_SND_DEBUG_VERBOSE
457#define SND_PCI_QUIRK(vend,dev,xname,val) \
458	{_SND_PCI_QUIRK_ID(vend, dev), .value = (val), .name = (xname)}
459#define SND_PCI_QUIRK_VENDOR(vend, xname, val)			\
460	{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val), .name = (xname)}
461#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val)			\
462	{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev),			\
463			.value = (val), .name = (xname)}
464#define snd_pci_quirk_name(q)	((q)->name)
465#else
466#define SND_PCI_QUIRK(vend,dev,xname,val) \
467	{_SND_PCI_QUIRK_ID(vend, dev), .value = (val)}
468#define SND_PCI_QUIRK_MASK(vend, mask, dev, xname, val)			\
469	{_SND_PCI_QUIRK_ID_MASK(vend, mask, dev), .value = (val)}
470#define SND_PCI_QUIRK_VENDOR(vend, xname, val)			\
471	{_SND_PCI_QUIRK_ID_MASK(vend, 0, 0), .value = (val)}
472#define snd_pci_quirk_name(q)	""
473#endif
474
475#ifdef CONFIG_PCI
476const struct snd_pci_quirk *
477snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
478
479const struct snd_pci_quirk *
480snd_pci_quirk_lookup_id(u16 vendor, u16 device,
481			const struct snd_pci_quirk *list);
482#else
483static inline const struct snd_pci_quirk *
484snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list)
485{
486	return NULL;
487}
488
489static inline const struct snd_pci_quirk *
490snd_pci_quirk_lookup_id(u16 vendor, u16 device,
491			const struct snd_pci_quirk *list)
492{
493	return NULL;
494}
495#endif
496
497#endif /* __SOUND_CORE_H */