Linux ALSA声卡驱动之二：声卡的创建

心已赠人 2022-10-01 12:59 179阅读 0赞

声明：本博内容均由[http://blog.csdn.net/droidphone][http_blog.csdn.net_droidphone]原创，转载请注明出处，谢谢！

1. struct snd\_card

1.1. snd\_card是什么  
snd\_card可以说是整个ALSA音频驱动最顶层的一个结构，整个声卡的软件逻辑结构开始于该结构，几乎所有与声音相关的逻辑设备都是在snd\_card的管理之下，声卡驱动的第一个动作通常就是创建一个snd\_card结构体。正因为如此，本节中，我们也从 struct cnd\_card开始吧。

1.2. snd\_card的定义  
snd\_card的定义位于改头文件中：include/sound/core.h

/* main structure for soundcard */
    
    struct snd_card {
    	int number;			/* number of soundcard (index to
    								snd_cards) */
    
    	char id[16];			/* id string of this card */
    	char driver[16];		/* driver name */
    	char shortname[32];		/* short name of this soundcard */
    	char longname[80];		/* name of this soundcard */
    	char mixername[80];		/* mixer name */
    	char components[80];		/* card components delimited with
    								space */
    	struct module *module;		/* top-level module */
    
    	void *private_data;		/* private data for soundcard */
    	void (*private_free) (struct snd_card *card); /* callback for freeing of
    								private data */
    	struct list_head devices;	/* devices */
    
    	unsigned int last_numid;	/* last used numeric ID */
    	struct rw_semaphore controls_rwsem;	/* controls list lock */
    	rwlock_t ctl_files_rwlock;	/* ctl_files list lock */
    	int controls_count;		/* count of all controls */
    	int user_ctl_count;		/* count of all user controls */
    	struct list_head controls;	/* all controls for this card */
    	struct list_head ctl_files;	/* active control files */
    
    	struct snd_info_entry *proc_root;	/* root for soundcard specific files */
    	struct snd_info_entry *proc_id;	/* the card id */
    	struct proc_dir_entry *proc_root_link;	/* number link to real id */
    
    	struct snd_monitor_file *files; /* all files associated to this card */
    	struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
    								state */
    	spinlock_t files_lock;		/* lock the files for this card */
    	int shutdown;			/* this card is going down */
    	int free_on_last_close;		/* free in context of file_release */
    	wait_queue_head_t shutdown_sleep;
    	struct device *dev;		/* device assigned to this card */
    #ifndef CONFIG_SYSFS_DEPRECATED
    	struct device *card_dev;	/* cardX object for sysfs */
    #endif
    
    #ifdef CONFIG_PM
    	unsigned int power_state;	/* power state */
    	struct mutex power_lock;	/* power lock */
    	wait_queue_head_t power_sleep;
    #endif
    
    #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
    	struct snd_mixer_oss *mixer_oss;
    	int mixer_oss_change_count;
    #endif
    };

struct list\_head devices     记录该声卡下所有逻辑设备的链表  
struct list\_head controls    记录该声卡下所有的控制单元的链表  
void \*private\_data            声卡的私有数据，可以在创建声卡时通过参数指定数据的大小  
2. 声卡的建立流程

2.1.1. 第一步，创建snd\_card的一个实例

struct snd_card *card;
    int err;
    ....
    err = snd_card_create(index, id, THIS_MODULE, 0, &card);

index           一个整数值，该声卡的编号  
id                字符串，声卡的标识符  
第四个参数    该参数决定在创建snd\_card实例时，需要同时额外分配的私有数据的大小，该数据的指针最终会赋值给snd\_card的private\_data数据成员  
card             返回所创建的snd\_card实例的指针

2.1.2. 第二步，创建声卡的芯片专用数据  
声卡的专用数据主要用于存放该声卡的一些资源信息，例如中断资源、io资源、dma资源等。可以有两种创建方法：

通过上一步中snd\_card\_create()中的第四个参数，让snd\_card\_create自己创建

// struct mychip 用于保存专用数据
    err = snd_card_create(index, id, THIS_MODULE,
                    sizeof(struct mychip), &card);
    // 从private_data中取出
    struct mychip *chip = card->private_data;

自己创建：

struct mychip {
        struct snd_card *card;
        ....
    };
    struct snd_card *card;
    struct mychip *chip;
    
    chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    ......
    err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
    // 专用数据记录snd_card实例
    chip->card = card;
    .....

然后，把芯片的专有数据注册为声卡的一个低阶设备：

static int snd_mychip_dev_free(struct snd_device *device)
    {
        return snd_mychip_free(device->device_data);
    }
    
    static struct snd_device_ops ops = {
        .dev_free = snd_mychip_dev_free,
    };
    ....
    snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);

注册为低阶设备主要是为了当声卡被注销时，芯片专用数据所占用的内存可以被自动地释放。

2.1.3. 第三步，设置Driver的ID和名字

strcpy(card->driver, "My Chip");
    strcpy(card->shortname, "My Own Chip 123");
    sprintf(card->longname, "%s at 0x%lx irq %i",
                card->shortname, chip->ioport, chip->irq);

snd\_card的driver字段保存着芯片的ID字符串，user空间的alsa-lib会使用到该字符串，所以必须要保证该ID的唯一性。shortname字段更多地用于打印信息，longname字段则会出现在/proc/asound/cards中。

2.1.4. 第四步，创建声卡的功能部件（逻辑设备），例如PCM，Mixer，MIDI等  
这时候可以创建声卡的各种功能部件了，还记得开头的snd\_card结构体的devices字段吗？每一种部件的创建最终会调用snd\_device\_new()来生成一个snd\_device实例，并把该实例链接到snd\_card的devices链表中。

通常，alsa-driver的已经提供了一些常用的部件的创建函数，而不必直接调用snd\_device\_new()，比如：

PCM  ----        snd\_pcm\_new()

RAWMIDI --    snd\_rawmidi\_new()

CONTROL --   snd\_ctl\_create()

TIMER   --       snd\_timer\_new()

INFO    --        snd\_card\_proc\_new()

JACK    --        snd\_jack\_new()

2.1.5. 第五步，注册声卡

err = snd_card_register(card);
    if (err < 0) {
        snd_card_free(card);
        return err;
    }

2.2. 一个实际的例子  
我把/sound/arm/pxa2xx-ac97.c的部分代码贴上来：

static int __devinit pxa2xx_ac97_probe(struct platform_device *dev)
    {
    	struct snd_card *card;
    	struct snd_ac97_bus *ac97_bus;
    	struct snd_ac97_template ac97_template;
    	int ret;
    	pxa2xx_audio_ops_t *pdata = dev->dev.platform_data;
    
    	if (dev->id >= 0) {
    		dev_err(&dev->dev, "PXA2xx has only one AC97 port./n");
    		ret = -ENXIO;
    		goto err_dev;
    	}
    (1)
    	ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
    			      THIS_MODULE, 0, &card);
    	if (ret < 0)
    		goto err;
    
    	card->dev = &dev->dev;
    (3)
    	strncpy(card->driver, dev->dev.driver->name, sizeof(card->driver));
    
    (4)
    	ret = pxa2xx_pcm_new(card, &pxa2xx_ac97_pcm_client, &pxa2xx_ac97_pcm);
    	if (ret)
    		goto err;
    (2)
    	ret = pxa2xx_ac97_hw_probe(dev);
    	if (ret)
    		goto err;
    
    (4)
    	ret = snd_ac97_bus(card, 0, &pxa2xx_ac97_ops, NULL, &ac97_bus);
    	if (ret)
    		goto err_remove;
    	memset(&ac97_template, 0, sizeof(ac97_template));
    	ret = snd_ac97_mixer(ac97_bus, &ac97_template, &pxa2xx_ac97_ac97);
    	if (ret)
    		goto err_remove;
    (3)
    	snprintf(card->shortname, sizeof(card->shortname),
    		 "%s", snd_ac97_get_short_name(pxa2xx_ac97_ac97));
    	snprintf(card->longname, sizeof(card->longname),
    		 "%s (%s)", dev->dev.driver->name, card->mixername);
    
    	if (pdata && pdata->codec_pdata[0])
    		snd_ac97_dev_add_pdata(ac97_bus->codec[0], pdata->codec_pdata[0]);
    	snd_card_set_dev(card, &dev->dev);
    (5)
    	ret = snd_card_register(card);
    	if (ret == 0) {
    		platform_set_drvdata(dev, card);
    		return 0;
    	}
    
    err_remove:
    	pxa2xx_ac97_hw_remove(dev);
    err:
    	if (card)
    		snd_card_free(card);
    err_dev:
    	return ret;
    }
    
    static int __devexit pxa2xx_ac97_remove(struct platform_device *dev)
    {
    	struct snd_card *card = platform_get_drvdata(dev);
    
    	if (card) {
    		snd_card_free(card);
    		platform_set_drvdata(dev, NULL);
    		pxa2xx_ac97_hw_remove(dev);
    	}
    
    	return 0;
    }
    
    static struct platform_driver pxa2xx_ac97_driver = {
    	.probe		= pxa2xx_ac97_probe,
    	.remove		= __devexit_p(pxa2xx_ac97_remove),
    	.driver		= {
    		.name	= "pxa2xx-ac97",
    		.owner	= THIS_MODULE,
    #ifdef CONFIG_PM
    		.pm	= &pxa2xx_ac97_pm_ops,
    #endif
    	},
    };
    
    static int __init pxa2xx_ac97_init(void)
    {
    	return platform_driver_register(&pxa2xx_ac97_driver);
    }
    
    static void __exit pxa2xx_ac97_exit(void)
    {
    	platform_driver_unregister(&pxa2xx_ac97_driver);
    }
    
    module_init(pxa2xx_ac97_init);
    module_exit(pxa2xx_ac97_exit);
    
    MODULE_AUTHOR("Nicolas Pitre");
    MODULE_DESCRIPTION("AC97 driver for the Intel PXA2xx chip");

驱动程序通常由probe回调函数开始，对一下2.1中的步骤，是否有相似之处？

经过以上的创建步骤之后，声卡的逻辑结构如下图所示：

![0_13014670816zCV.gif][]

图 2.2.1  声卡的软件逻辑结构

下面的章节里我们分别讨论一下snd\_card\_create()和snd\_card\_register()这两个函数。

3. snd\_card\_create()  
 snd\_card\_create()在/sound/core/init.c中定义。

/**
     *  snd_card_new - create and initialize a soundcard structure
     *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
     *  @xid: card identification (ASCII string)
     *  @module: top level module for locking
     *  @extra_size: allocate this extra size after the main soundcard structure
     *
     *  Creates and initializes a soundcard structure.
     *
     *  Returns kmallocated snd_card structure. Creates the ALSA control interface
     *  (which is blocked until snd_card_register function is called).
     */
    struct snd_card *snd_card_new(int idx, const char *xid,
    			 struct module *module, int extra_size)
    {
    	struct snd_card *card;
    	int err;
    
    	if (extra_size < 0)
    		extra_size = 0;
    	card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
    	if (card == NULL)
    		return NULL;
    	if (xid) {
    		if (!snd_info_check_reserved_words(xid))
    			goto __error;
    		strlcpy(card->id, xid, sizeof(card->id));
    	}
    	err = 0;
    	mutex_lock(&snd_card_mutex);
    	if (idx < 0) {
    		int idx2;
    		for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
    			/* idx == -1 == 0xffff means: take any free slot */
    			if (~snd_cards_lock & idx & 1<<idx2) {
    				idx = idx2;
    				if (idx >= snd_ecards_limit)
    					snd_ecards_limit = idx + 1;
    				break;
    			}
    	} else {
    		 if (idx < snd_ecards_limit) {
    			if (snd_cards_lock & (1 << idx))
    				err = -EBUSY;	/* invalid */
    		} else {
    			if (idx < SNDRV_CARDS)
    				snd_ecards_limit = idx + 1; /* increase the limit */
    			else
    				err = -ENODEV;
    		}
    	}
    	if (idx < 0 || err < 0) {
    		mutex_unlock(&snd_card_mutex);
    		snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
    			 idx, snd_ecards_limit - 1, err);
    		goto __error;
    	}
    	snd_cards_lock |= 1 << idx;		/* lock it */
    	mutex_unlock(&snd_card_mutex);
    	card->number = idx;
    	card->module = module;
    	INIT_LIST_HEAD(&card->devices);
    	init_rwsem(&card->controls_rwsem);
    	rwlock_init(&card->ctl_files_rwlock);
    	INIT_LIST_HEAD(&card->controls);
    	INIT_LIST_HEAD(&card->ctl_files);
    	spin_lock_init(&card->files_lock);
    	init_waitqueue_head(&card->shutdown_sleep);
    #ifdef CONFIG_PM
    	mutex_init(&card->power_lock);
    	init_waitqueue_head(&card->power_sleep);
    #endif
    	/* the control interface cannot be accessed from the user space until */
    	/* snd_cards_bitmask and snd_cards are set with snd_card_register */
    	if ((err = snd_ctl_create(card)) < 0) {
    		snd_printd("unable to register control minors\n");
    		goto __error;
    	}
    	if ((err = snd_info_card_create(card)) < 0) {
    		snd_printd("unable to create card info\n");
    		goto __error_ctl;
    	}
    	if (extra_size > 0)
    		card->private_data = (char *)card + sizeof(struct snd_card);
    	return card;
    
          __error_ctl:
    	snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
          __error:
    	kfree(card);
          	return NULL;
    }

首先，根据extra\_size参数的大小分配内存，该内存区可以作为芯片的专有数据使用（见前面的介绍）：

card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
    	if (!card)
    		return -ENOMEM;

拷贝声卡的ID字符串：

if (xid)
    		strlcpy(card->id, xid, sizeof(card->id));

如果传入的声卡编号为-1，自动分配一个索引编号：

if (idx < 0) {
    		for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
    			/* idx == -1 == 0xffff means: take any free slot */
    			if (~snd_cards_lock & idx & 1<<idx2) {
    				if (module_slot_match(module, idx2)) {
    					idx = idx2;
    					break;
    				}
    			}
    	}
    	if (idx < 0) {
    		for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
    			/* idx == -1 == 0xffff means: take any free slot */
    			if (~snd_cards_lock & idx & 1<<idx2) {
    				if (!slots[idx2] || !*slots[idx2]) {
    					idx = idx2;
    					break;
    				}
    			}
    	}

初始化snd\_card结构中必要的字段：

card->number = idx;
    	card->module = module;
    	INIT_LIST_HEAD(&card->devices);
    	init_rwsem(&card->controls_rwsem);
    	rwlock_init(&card->ctl_files_rwlock);
    	INIT_LIST_HEAD(&card->controls);
    	INIT_LIST_HEAD(&card->ctl_files);
    	spin_lock_init(&card->files_lock);
    	INIT_LIST_HEAD(&card->files_list);
    	init_waitqueue_head(&card->shutdown_sleep);
    #ifdef CONFIG_PM
    	mutex_init(&card->power_lock);
    	init_waitqueue_head(&card->power_sleep);
    #endif

建立逻辑设备：Control

/* the control interface cannot be accessed from the user space until */
    	/* snd_cards_bitmask and snd_cards are set with snd_card_register */
    	err = snd_ctl_create(card);

建立proc文件中的info节点：通常就是/proc/asound/card0

err = snd_info_card_create(card);

把第一步分配的内存指针放入private\_data字段中：

if (extra_size > 0)
    		card->private_data = (char *)card + sizeof(struct snd_card);

4. snd\_card\_register()  
  snd\_card\_create()在/sound/core/init.c中定义。

/**
     *  snd_card_register - register the soundcard
     *  @card: soundcard structure
     *
     *  This function registers all the devices assigned to the soundcard.
     *  Until calling this, the ALSA control interface is blocked from the
     *  external accesses.  Thus, you should call this function at the end
     *  of the initialization of the card.
     *
     *  Returns zero otherwise a negative error code if the registrain failed.
     */
    int snd_card_register(struct snd_card *card)

首先，创建sysfs下的设备：

if (!card->card_dev) {
    		card->card_dev = device_create(sound_class, card->dev,
    					       MKDEV(0, 0), card,
    					       "card%i", card->number);
    		if (IS_ERR(card->card_dev))
    			card->card_dev = NULL;
    	}

其中，sound\_class是在/sound/sound\_core.c中创建的：

static char *sound_devnode(struct device *dev, mode_t *mode)
    {
    	if (MAJOR(dev->devt) == SOUND_MAJOR)
    		return NULL;
    	return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev));
    }
    static int __init init_soundcore(void)
    {
    	int rc;
    
    	rc = init_oss_soundcore();
    	if (rc)
    		return rc;
    
    	sound_class = class_create(THIS_MODULE, "sound");
    	if (IS_ERR(sound_class)) {
    		cleanup_oss_soundcore();
    		return PTR_ERR(sound_class);
    	}
    
    	sound_class->devnode = sound_devnode;
    
    	return 0;
    }

由此可见，声卡的class将会出现在文件系统的/sys/class/sound/下面，并且，sound\_devnode()也决定了相应的设备节点也将会出现在/dev/snd/下面。

接下来的步骤，通过snd\_device\_register\_all()注册所有挂在该声卡下的逻辑设备，snd\_device\_register\_all()实际上是通过snd\_card的devices链表，遍历所有的snd\_device，并且调用snd\_device的ops->dev\_register()来实现各自设备的注册的。

if ((err = snd_device_register_all(card)) < 0)
    		return err;

最后就是建立一些相应的proc和sysfs下的文件或属性节点，代码就不贴了。

至此，整个声卡完成了建立过程。

[http_blog.csdn.net_droidphone]: http://blog.csdn.net/droidphone
[0_13014670816zCV.gif]: /images/20220118/0645a89316814eeabd32a7e049a2a58b.png