Linux ALSA驅動之三:PCM創建流程源碼分析(基於Linux 5.18)

語言: CN / TW / HK

開啟掘金成長之旅!這是我參與「掘金日新計劃 · 2 月更文挑戰」的第 3 天,點擊查看活動詳情

1、基本概念及邏輯關係

  如上圖,通過上一節聲卡的學習我們已經知道PCM是聲卡的一個子設備,或者表示一個PCM實例。

  每個聲卡最多可以包含4個pcm的實例,每個pcm實例對應一個pcm設備文件。pcm實例數量的這種限制源於linux設備號所佔用的位大小,如果以後使用64位的設備號,我們將可以創建更多的pcm實例。不過大多數情況下,在嵌入式設備中,一個pcm實例已經足夠了。

  一個pcm實例由一個playback stream和一個capture stream組成,這兩個stream又分別有一個或多個substreams組成。可以用如下圖來表示他們直接的邏輯關係:

  當一個子流已經存在,並且已經被打開,當再次被打開的時候,會被阻塞。        

  在實際的應用中,通常不會如上圖這麼複雜,大多數情況下是一個聲卡有一個PCM實例,PCM下面有一個playback和capture,而playback和capture各自有一個substream。

  PCM層有幾個很重要的結構體,我們通過如下的UML圖來梳理他們直接的關係。

  1、snd_pcm: 掛在snd_card下面的一個snd_device。

  2、snd_pcm中的字段:streams[2] :該數組中的兩個元素指向兩個snd_pcm_str結構,分別代表playback stream和capture stream。

  3、snd_pcm_str中的substream字段:指向snd_pcm_substream結構。

  4、snd_pcm_substream是pcm中間層的核心,絕大部分任務都是在substream中處理,尤其是他的ops(snd_pcm_ops)字段,許多user空間的應用程序通過alsa-lib對驅動程序的請求都是由該結構中的函數處理。它的runtime字段則指向snd_pcm_runtime結構,snd_pcm_runtime記錄這substream的一些重要的軟件和硬件運行環境和參數。

2、PCM創建流程

  PCM的整個創建流程請參考如下時序圖進行理解:

  alsa-driver的中間層已經提供新建PCM的API:

2.1、創建PCM實例

C int snd_pcm_new(struct snd_card *card, const char *id, int device, int playback_count, int capture_count, struct snd_pcm **rpcm)

  card: 表示所屬的聲卡。

  ID: PCM實例的ID(名字)。

  device: 表示目前創建的是該聲卡下的第幾個PCM,第一個PCM設備從0開始計數。

  playback_count: 表示該PCM播放流中將會有幾個substream。

  capture_count :表示該PCM錄音流中將會有幾個substream。

  rpcm: 返回的PCM實例。

  該函數的主要作用是創建PCM邏輯設備,創建回放子流和錄製子流實例,並初始化回放子流和錄製子流的PCM操作函數(數據搬運時,需要調用這些函數來驅動 codec、codec_dai、cpu_dai、dma 設備工作)。

2.2、設置PCM設備的操作函數

C void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, const struct snd_pcm_ops *ops)   pcm: 上述snd_pcm_new 創建的PCM實例。

  direction: 是指SNDRV_PCM_STREAM_PLAYBACK或SNDRV_PCM_STREAM_CAPTURE,即設置為播放或者錄音功能。

  snd_pcm_ops: 結構中的函數通常就是我們驅動要實現的函數。

2.3、定義PCM的操作函數

  以AC97驅動(linux/sound/arm/pxa2xx-ac97.c)為例,在驅動中對於PCM進行了如下設置:

```C++ static const struct snd_pcm_ops pxa2xx_ac97_pcm_ops = { .open = pxa2xx_ac97_pcm_open, .close = pxa2xx_ac97_pcm_close, .hw_params = pxa2xx_pcm_hw_params, .prepare = pxa2xx_ac97_pcm_prepare, .trigger = pxa2xx_pcm_trigger, .pointer = pxa2xx_pcm_pointer, };

snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pxa2xx_ac97_pcm_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pxa2xx_ac97_pcm_ops); ```

2.4、定義硬件參數

```C++ static const struct snd_pcm_hardware pxa2xx_pcm_hardware = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE, .period_bytes_min = 32, .period_bytes_max = 8192 - 32, .periods_min = 1, .periods_max = 256, .buffer_bytes_max = 128 * 1024, .fifo_size = 32, };

int pxa2xx_pcm_open(struct snd_pcm_substream substream) { struct snd_soc_pcm_runtime rtd = substream->private_data; struct snd_pcm_runtime runtime = substream->runtime; struct snd_dmaengine_dai_dma_data dma_params; int ret;

runtime->hw = pxa2xx_pcm_hardware;

dma_params = snd_soc_dai_get_dma_data(asoc_rtd_to_cpu(rtd, 0), substream);
if (!dma_params)
        return 0;

/*
 * For mysterious reasons (and despite what the manual says)
 * playback samples are lost if the DMA count is not a multiple
 * of the DMA burst size.  Let's add a rule to enforce that.
 */
ret = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32);
if (ret)
        return ret;

ret = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 32);
if (ret)
        return ret;

ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
        return ret;

return snd_dmaengine_pcm_open(substream, dma_request_slave_channel(asoc_rtd_to_cpu(rtd, 0)->dev, dma_params->chan_name));

} ```

3、PCM相關源碼分析

3.1、snd_pcm_new

```C++ / * snd_pcm_new - create a new PCM instance * @card: the card instance * @id: the id string * @device: the device index (zero based) * @playback_count: the number of substreams for playback * @capture_count: the number of substreams for capture * @rpcm: the pointer to store the new pcm instance * * Creates a new PCM instance. * * The pcm operators have to be set afterwards to the new instance * via snd_pcm_set_ops(). * * Return: Zero if successful, or a negative error code on failure. / int snd_pcm_new(struct snd_card card, const char *id, int device, int playback_count, int capture_count, struct snd_pcm rpcm) { / 直接調用函數_snd_pcm_new,參數internal傳入false / return _snd_pcm_new(card, id, device, playback_count, capture_count, false, rpcm); }

static int _snd_pcm_new(struct snd_card card, const char id, int device, int playback_count, int capture_count, bool internal, struct snd_pcm rpcm) { struct snd_pcm pcm; int err; / 1. 邏輯設備的操作函數結構體, 主要用於註冊子設備 */ static const struct snd_device_ops ops = { .dev_free = snd_pcm_dev_free, .dev_register = snd_pcm_dev_register, .dev_disconnect = snd_pcm_dev_disconnect, }; static const struct snd_device_ops internal_ops = { .dev_free = snd_pcm_dev_free, };

if (snd_BUG_ON(!card))
    return -ENXIO;
if (rpcm)
    *rpcm = NULL;
/* 2. 為snd_pcm結構體分配空間,根據傳入參數賦值 */
pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
if (!pcm)
    return -ENOMEM;
pcm->card = card;
pcm->device = device;
pcm->internal = internal;
mutex_init(&pcm->open_mutex);
init_waitqueue_head(&pcm->open_wait);
INIT_LIST_HEAD(&pcm->list);
if (id)
    strscpy(pcm->id, id, sizeof(pcm->id));

/* 3. 根據傳入的playback和capture的個數創建PCM流 snd_pcm_str */
err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                         playback_count);
if (err < 0)
    goto free_pcm;

err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count);
if (err < 0)
    goto free_pcm;

/* 4. 創建一個PCM邏輯設備,創建邏輯設備,並添加到邏輯設備鏈表 */
err = snd_device_new(card, SNDRV_DEV_PCM, pcm, internal ? &internal_ops : &ops);
if (err < 0)
        goto free_pcm;

if (rpcm)
        *rpcm = pcm;
return 0;

free_pcm: snd_pcm_free(pcm); return err; } ```

3.2、snd_pcm

```C++ struct snd_pcm { struct snd_card card; struct list_head list; int device; / device number / unsigned int info_flags; unsigned short dev_class; unsigned short dev_subclass; char id[64]; char name[80]; struct snd_pcm_str streams[2]; struct mutex open_mutex; wait_queue_head_t open_wait; void private_data; void (private_free) (struct snd_pcm pcm); bool internal; / pcm is for internal use only / bool nonatomic; / whole PCM operations are in non-atomic context / bool no_device_suspend; / don't invoke device PM suspend /

if IS_ENABLED(CONFIG_SND_PCM_OSS)

struct snd_pcm_oss oss;

endif

}; ```   這裏重要的變量有兩個streams與private_data。streams有兩個,是因為一個指向播放設備,一個指向錄音設備。private_data在很多結構裏都可以看到,和麪象對象裏的繼承有點類似,如果將snd_pcm理解為基類的話,private_data指向的就是它的繼承類,也就是真正的實現者。

  list,在pcm.c中有一個全局變量snd_pcm_devices,將所有的snd_pcm對象鏈接起來,目的是外部提供一些可供枚舉所有設備的接口,看起來並不怎麼被用到。

  另外還有info_flags、dev_class等變量看起來是為一些特殊設備預留的,對待一些特殊操作。

```C++ struct snd_pcm_str { int stream; / stream (direction) / struct snd_pcm pcm; / -- substreams -- / unsigned int substream_count; unsigned int substream_opened; struct snd_pcm_substream substream;

if IS_ENABLED(CONFIG_SND_PCM_OSS)

/* -- OSS things -- */
struct snd_pcm_oss_stream oss;

endif

ifdef CONFIG_SND_VERBOSE_PROCFS

struct snd_info_entry *proc_root;

ifdef CONFIG_SND_PCM_XRUN_DEBUG

unsigned int xrun_debug;    /* 0 = disabled, 1 = verbose, 2 = stacktrace */

endif

endif

struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
struct device dev;

}; ```   snd_pcm_str的主要作用是指向snd_pcm_substream,而snd_pcm_substream可以有多個,這也是snd_pcm_str存在的原因,否則snd_pcm直接指向snd_pcm_substream就可以了。

  這裏的dev是將pcm加入到文件系統時要用到。包含的信息,在下面介紹的snd_pcm_new_stream中會看到。

3.3、snd_pcm_new_stream

```C++ / * snd_pcm_new_stream - create a new PCM stream * @pcm: the pcm instance * @stream: the stream direction, SNDRV_PCM_STREAM_XXX * @substream_count: the number of substreams * * Creates a new stream for the pcm. * The corresponding stream on the pcm must have been empty before * calling this, i.e. zero must be given to the argument of * snd_pcm_new(). * * Return: Zero if successful, or a negative error code on failure. / int snd_pcm_new_stream(struct snd_pcm pcm, int stream, int substream_count) { int idx, err; / 3.1 根據傳入的參數,為PCM流(snd_pcm_str)賦值:方向,所屬的PCM,PCM子流的個數 / struct snd_pcm_str pstr = &pcm->streams[stream]; struct snd_pcm_substream substream, *prev;

if IS_ENABLED(CONFIG_SND_PCM_OSS)

mutex_init(&pstr->oss.setup_mutex);

endif

pstr->stream = stream;
pstr->pcm = pcm;
pstr->substream_count = substream_count;
if (!substream_count)
    return 0;

snd_device_initialize(&pstr->dev, pcm->card);
pstr->dev.groups = pcm_dev_attr_groups;
pstr->dev.type = &pcm_dev_type;
dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device, stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');

/* proc */
if (!pcm->internal) {
    err = snd_pcm_stream_proc_init(pstr);
    if (err < 0) {
        pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
        return err;
    }
}
prev = NULL;
for (idx = 0, prev = NULL; idx < substream_count; idx++) {
    /* 為子流分配空間,賦值(pcm,pcm流,ID, 方向.....) */
    substream = kzalloc(sizeof(*substream), GFP_KERNEL);
    if (!substream)
        return -ENOMEM;
    substream->pcm = pcm;
    substream->pstr = pstr;
    substream->number = idx;
    substream->stream = stream;
    sprintf(substream->name, "subdevice #%i", idx);
    substream->buffer_bytes_max = UINT_MAX;
    /* 添加子流到子流的鏈表 */
    if (prev == NULL)    /* 第一個子流 */
        pstr->substream = substream;
    else
        prev->next = substream;    /* 非第一個子流,添加到前一個子流後部 */
    /* proc */
    if (!pcm->internal) {
        err = snd_pcm_substream_proc_init(substream);
        if (err < 0) {
            pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
            if (prev == NULL)
                pstr->substream = NULL;
            else
                prev->next = NULL;
            kfree(substream);
            return err;
        }
    }
    /* 結構體初始化 */
    substream->group = &substream->self_group;
    snd_pcm_group_init(&substream->self_group);
    list_add_tail(&substream->link_list, &substream->self_group.substreams);
    atomic_set(&substream->mmap_count, 0);
    prev = substream;
}
return 0;

} ```   函數參數中的int stream,是一個枚舉類型: 

C++ enum { SNDRV_PCM_STREAM_PLAYBACK = 0, SNDRV_PCM_STREAM_CAPTURE, SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, };   從snd_device_initialize(&pstr->dev, pcm->card); 開始。dev最終會被傳入device_add函數中,用來構建文件系統。

C void snd_device_initialize(struct device *dev, struct snd_card *card) { device_initialize(dev); if (card) dev->parent = &card->card_dev; dev->class = sound_class; dev->release = default_release; }   這段函數中可以看到dev->class被設置成sound_class,這個是我們之前提到的文件放到snd目錄的原因。

3.4、snd_pcm_substream

```C++ struct snd_pcm_substream { struct snd_pcm pcm; struct snd_pcm_str pstr; void private_data; / copied from pcm->private_data / int number; char name[32]; / substream name / int stream; / stream (direction) / struct pm_qos_request latency_pm_qos_req; / pm_qos request / size_t buffer_bytes_max; / limit ring buffer size / struct snd_dma_buffer dma_buffer; size_t dma_max; / -- hardware operations -- / const struct snd_pcm_ops ops; / -- runtime information -- / struct snd_pcm_runtime runtime; / -- timer section -- / struct snd_timer timer; / timer / unsigned timer_running: 1; / time is running / long wait_time; / time in ms for R/W to wait for avail / / -- next substream -- / struct snd_pcm_substream next; / -- linked substreams -- / struct list_head link_list; / linked list member / struct snd_pcm_group self_group; / fake group for non linked substream (with substream lock inside) / struct snd_pcm_group group; / pointer to current group / / -- assigned files -- / int ref_count; atomic_t mmap_count; unsigned int f_flags; void (pcm_release)(struct snd_pcm_substream ); struct pid *pid;

if IS_ENABLED(CONFIG_SND_PCM_OSS)

/* -- OSS things -- */
struct snd_pcm_oss_substream oss;

endif

ifdef CONFIG_SND_VERBOSE_PROCFS

struct snd_info_entry *proc_root;

endif / CONFIG_SND_VERBOSE_PROCFS /

/* misc flags */
unsigned int hw_opened: 1;
unsigned int managed_buffer_alloc:1;

}; ```   snd_pcm_substream的內容有些多,此處只需要重要的進行介紹。

  private_data: 從snd_pcm中的private_data拷貝過來的,指向實現者的結構。

  const struct snd_pcm_ops *ops: 這部分是框架的內容,具體的操作需要實現者的參與,留給實現者的函數指針集。這個和文件操作的設計策略是一致的。

  struct snd_pcm_runtime *runtime: 讀寫數據的時候由它來控制。到分析讀寫代碼的時候,會重點關注它。

  struct snd_pcm_substream *next: 將多個snd_pcm_substream對象鏈接起來,它就是snd_pcm_str指向的鏈接。

  group: 在用户空間可以通過SNDRV_PCM_IOCTL_LINK將多個substream鏈接起來。然後就可以對這些對象進行統一的操作。我沒遇到過具體的應用場景。

3.5、snd_pcm_set_ops

```C++ / * snd_pcm_set_ops - set the PCM operators * @pcm: the pcm instance * @direction: stream direction, SNDRV_PCM_STREAM_XXX * @ops: the operator table * * Sets the given PCM operators to the pcm instance. / void snd_pcm_set_ops(struct snd_pcm pcm, int direction, const struct snd_pcm_ops ops) { struct snd_pcm_str stream = &pcm->streams[direction]; struct snd_pcm_substream *substream;

for (substream = stream->substream; substream != NULL; substream = substream->next)
        substream->ops = ops;

} EXPORT_SYMBOL(snd_pcm_set_ops); ```   此函數是提供給調用側使用的。設置的內容可以參考pcm文件結構簡圖。 

3.6、snd_pcm_dev_register

  在繼續分析snd_pcm_dev_register函數之前需要先介紹一個結構體。struct snd_minor。

C++ struct snd_minor { int type; /* SNDRV_DEVICE_TYPE_XXX */ int card; /* card number */ int device; /* device number */ const struct file_operations *f_ops; /* file operations */ void *private_data; /* private data for f_ops->open */ struct device *dev; /* device for sysfs */ struct snd_card *card_ptr; /* assigned card instance */ };   type: 設備類型,比如是pcm, control, timer等設備。

  card_number: 所屬的card。

  device: 當前設備類型下的設備編號。

  f_ops: 具體設備的文件操作集合。

  private_data: open函數的私有數據。

  card_ptr: 所屬的card。

此結構體是用來保存當前設備的上下文信息,該card下所有邏輯設備都存在此結構。

```C++ static int snd_pcm_dev_register(struct snd_device device) { / 1、添加pcm結構體到全局鏈表snd_pcm_devices / int cidx, err; struct snd_pcm_substream substream; struct snd_pcm *pcm;

if (snd_BUG_ON(!device || !device->device_data))
    return -ENXIO;
/* snd_devcie保存的是snd_pcm對象 */
pcm = device->device_data;

mutex_lock(&register_mutex);
/* snd_pcm對象將被保存到全局變量snd_pcm_devices中,用於枚舉設備等操作 */
err = snd_pcm_add(pcm);
if (err)
    goto unlock;
for (cidx = 0; cidx < 2; cidx++) {
    /* 2、確定PCM設備節點名字 */
    int devtype = -1;
    if (pcm->streams[cidx].substream == NULL)
        continue;
    switch (cidx) {
    case SNDRV_PCM_STREAM_PLAYBACK:
        devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
        break;
    case SNDRV_PCM_STREAM_CAPTURE:
        devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
        break;
    }
    /* register pcm */
    /* 將設備添加到文件系統,將snd_pcm_f_ops傳入,將被設置給snd_minor對象 */
    err = snd_register_device(devtype, pcm->card, pcm->device,
                              &snd_pcm_f_ops[cidx], pcm,
                              &pcm->streams[cidx].dev);
    if (err < 0) {
        list_del_init(&pcm->list);
        goto unlock;
    }

    for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
        /* 設定CONFIG_SND_PCM_TIMER宏的時候,會去設置substream的時間 */
        snd_pcm_timer_init(substream);
}

pcm_call_notify(pcm, n_register);

unlock: mutex_unlock(&register_mutex); return err; }

/ * snd_register_device - Register the ALSA device file for the card * @type: the device type, SNDRV_DEVICE_TYPE_XXX * @card: the card instance * @dev: the device index * @f_ops: the file operations * @private_data: user pointer for f_ops->open() * @device: the device to register * * Registers an ALSA device file for the given card. * The operators have to be set in reg parameter. * * Return: Zero if successful, or a negative error code on failure. / int snd_register_device(int type, struct snd_card card, int dev, const struct file_operations f_ops, void private_data, struct device device) { int minor; int err = 0; struct snd_minor preg;

if (snd_BUG_ON(!device))
    return -EINVAL;

preg = kmalloc(sizeof *preg, GFP_KERNEL);
if (preg == NULL)
    return -ENOMEM;
/* 創建一個snd_minor,並添加到全局結構體 snd_minors */
preg->type = type;
preg->card = card ? card->number : -1;
preg->device = dev;
preg->f_ops = f_ops;
preg->private_data = private_data;
preg->card_ptr = card;
mutex_lock(&sound_mutex);
/* 4、註冊一個設備節點 */
minor = snd_find_free_minor(type, card, dev);
if (minor < 0) {
    err = minor;
    goto error;
}

preg->dev = device;
device->devt = MKDEV(major, minor);
err = device_add(device);
if (err < 0)
    goto error;

snd_minors[minor] = preg;

error: mutex_unlock(&sound_mutex); if (err < 0) kfree(preg); return err; } ```   當聲卡被註冊時,會註冊所有的邏輯設備。主要的工作是創建PCM設備節點具體的流程:

    1、添加pcm結構體到全局鏈表snd_pcm_devices。

    2、確定PCM設備節點名字。

    3、創建一個snd_minor,並添加到全局結構體 snd_minors。

    4、註冊一個設備節點

  可以看到添加到文件系統的是播放設備和錄音設備,根據snd_pcm_str指向的內容來設定的。代碼中看到snd_pcm也被定義為SNDRV_DEV_PCM設備,但是文件系統中並不會保存這個類型的設備。

  snd_pcm_timer_init是在CONFIG_SND_PCM_TIMER宏被定義的時候,會起作用。

  通過下圖可以幫助你更好的理解各結構直接的邏輯關係。