2. 程式人生 > >ALSA音訊驅動研究

ALSA音訊驅動研究

阿新 • • 發佈：2018-12-27

前面一節的內容我們提到，ASoC被分為Machine、Platform和Codec三大部分，其中的Machine驅動負責Platform和Codec之間的耦合以及部分和裝置或板子特定的程式碼，再次引用上一節的內容：Machine驅動負責處理機器特有的一些控制元件和音訊事件（例如，當播放音訊時，需要先行開啟一個放大器）；單獨的Platform和Codec驅動是不能工作的，它必須由Machine驅動把它們結合在一起才能完成整個裝置的音訊處理工作。

ASoC的一切都從Machine驅動開始，包括音效卡的註冊，繫結Platform和Codec驅動等等，下面就讓我們從Machine驅動開始討論吧。

/********************************************************************************************/
宣告：本博內容均由http://blog.csdn.net/droidphone原創，轉載請註明出處，謝謝！
/********************************************************************************************/

1. 註冊Platform Device

ASoC把音效卡註冊為Platform Device，我們以裝配有WM8994的一款Samsung的開發板SMDK為例子做說明，WM8994是一顆Wolfson生產的多功能Codec晶片。

程式碼的位於：/sound/soc/samsung/smdk_wm8994.c，我們關注模組的初始化函式：

[cpp] view plaincopy
  1. staticint __init smdk_audio_init(void)  
  2. {  
  3.     int ret;  
  4.     smdk_snd_device = platform_device_alloc("soc-audio"
    , -1);  
  5.     if (!smdk_snd_device)  
  6.         return -ENOMEM;  
  7.     platform_set_drvdata(smdk_snd_device, &smdk);  
  8.     ret = platform_device_add(smdk_snd_device);  
  9.     if (ret)  
  10.         platform_device_put(smdk_snd_device);  
  11.     return ret;  
  12. }  

由此可見，模組初始化時，註冊了一個名為soc-audio的Platform裝置，同時把smdk設到platform_device結構的dev.drvdata欄位中，這裡引出了第一個資料結構snd_soc_card的例項smdk，他的定義如下：

[cpp] view plaincopy
  1. staticstruct snd_soc_dai_link smdk_dai[] = {  
  2.     { /* Primary DAI i/f */
  3.         .name = "WM8994 AIF1",  
  4.         .stream_name = "Pri_Dai",  
  5.         .cpu_dai_name = "samsung-i2s.0",  
  6.         .codec_dai_name = "wm8994-aif1",  
  7.         .platform_name = "samsung-audio",  
  8.         .codec_name = "wm8994-codec",  
  9.         .init = smdk_wm8994_init_paiftx,  
  10.         .ops = &smdk_ops,  
  11.     }, { /* Sec_Fifo Playback i/f */
  12.         .name = "Sec_FIFO TX",  
  13.         .stream_name = "Sec_Dai",  
  14.         .cpu_dai_name = "samsung-i2s.4",  
  15.         .codec_dai_name = "wm8994-aif1",  
  16.         .platform_name = "samsung-audio",  
  17.         .codec_name = "wm8994-codec",  
  18.         .ops = &smdk_ops,  
  19.     },  
  20. };  
  21. staticstruct snd_soc_card smdk = {  
  22.     .name = "SMDK-I2S",  
  23.     .owner = THIS_MODULE,  
  24.     .dai_link = smdk_dai,  
  25.     .num_links = ARRAY_SIZE(smdk_dai),  
  26. };  

通過snd_soc_card結構，又引出了Machine驅動的另外兩個個數據結構：

  • snd_soc_dai_link（例項：smdk_dai[] ）
  • snd_soc_ops（例項：smdk_ops ）

其中，snd_soc_dai_link中，指定了Platform、Codec、codec_dai、cpu_dai的名字，稍後Machine驅動將會利用這些名字去匹配已經在系統中註冊的platform，codec，dai，這些註冊的部件都是在另外相應的Platform驅動和Codec驅動的程式碼檔案中定義的，這樣看來，Machine驅動的裝置初始化程式碼無非就是選擇合適Platform和Codec以及dai，用他們填充以上幾個資料結構，然後註冊Platform裝置即可。當然還要實現連線Platform和Codec的dai_link對應的ops實現，本例就是smdk_ops，它只實現了hw_params函式：smdk_hw_params。

2. 註冊Platform Driver

按照Linux的裝置模型，有platform_device，就一定會有platform_driver。ASoC的platform_driver在以下檔案中定義：sound/soc/soc-core.c。

還是先從模組的入口看起：

[cpp] view plaincopy
  1. staticint __init snd_soc_init(void)  
  2. {  
  3.     ......  
  4.     return platform_driver_register(&soc_driver);  
  5. } 

我們看到platform_driver的name欄位為soc-audio，正好與platform_device中的名字相同，按照Linux的裝置模型，platform匯流排會匹配這兩個名字相同的device和driver，同時會觸發soc_probe的呼叫，它正是整個ASoC驅動初始化的入口。

3. 初始化入口soc_probe()

soc_probe函式本身很簡單，它先從platform_device引數中取出snd_soc_card，然後呼叫snd_soc_register_card，通過snd_soc_register_card，為snd_soc_pcm_runtime陣列申請記憶體，每一個dai_link對應snd_soc_pcm_runtime陣列的一個單元，然後把snd_soc_card中的dai_link配置複製到相應的snd_soc_pcm_runtime中，最後，大部分的工作都在snd_soc_instantiate_card中實現，下面就看看snd_soc_instantiate_card做了些什麼：

該函式首先利用card->instantiated來判斷該卡是否已經例項化，如果已經例項化則直接返回，否則遍歷每一對dai_link，進行codec、platform、dai的繫結工作，下只是程式碼的部分選節，詳細的程式碼請直接參考完整的程式碼樹。

[cpp] view plaincopy
  1. /* bind DAIs */
  2. for (i = 0; i < card->num_links; i++)  
  3.     soc_bind_dai_link(card, i);  

ASoC定義了三個全域性的連結串列頭變數：codec_list、dai_list、platform_list，系統中所有的Codec、DAI、Platform都在註冊時連線到這三個全域性連結串列上。soc_bind_dai_link函式逐個掃描這三個連結串列，根據card->dai_link[]中的名稱進行匹配，匹配後把相應的codec，dai和platform例項賦值到card->rtd[]中（snd_soc_pcm_runtime）。經過這個過程後，snd_soc_pcm_runtime：（card->rtd）中儲存了本Machine中使用的Codec，DAI和Platform驅動的資訊。

snd_soc_instantiate_card接著初始化Codec的暫存器快取，然後呼叫標準的alsa函式建立音效卡例項： 

[cpp] view plaincopy
  1. /* card bind complete so register a sound card */
  2. ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,  
  3.         card->owner, 0, &card->snd_card);  
  4. card->snd_card->dev = card->dev;  
  5. card->dapm.bias_level = SND_SOC_BIAS_OFF;  
  6. card->dapm.dev = card->dev;  
  7. card->dapm.card = card;  
  8. list_add(&card->dapm.list, &card->dapm_list);  


然後，依次呼叫各個子結構的probe函式：

  1. /* initialise the sound card only once */
  2. if (card->probe) {  
  3.     ret = card->probe(card);  
  4.     if (ret < 0)  
  5.         goto card_probe_error;  
  6. }  
  7. /* early DAI link probe */
  8. for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;  
  9.         order++) {  
  10.     for (i = 0; i < card->num_links; i++) {  
  11.         ret = soc_probe_dai_link(card, i, order);  
  12.         if (ret < 0) {  
  13.             pr_err("asoc: failed to instantiate card %s: %d\n",  
  14.                card->name, ret);  
  15.             goto probe_dai_err;  
  16.         }  
  17.     }  
  18. }  
  19. for (i = 0; i < card->num_aux_devs; i++) {  
  20.     ret = soc_probe_aux_dev(card, i);  
  21.     if (ret < 0) {  
  22.         pr_err("asoc: failed to add auxiliary devices %s: %d\n",  
  23.                card->name, ret);  
  24.         goto probe_aux_dev_err;  
  25.     }  
  26. }  

在上面的soc_probe_dai_link()函式中做了比較多的事情，把他展開繼續討論：

  1. staticint soc_probe_dai_link(struct snd_soc_card *card, int num, int order)  
  2. {  
  3.         ......  
  4.     /* set default power off timeout */
  5.     rtd->pmdown_time = pmdown_time;  
  6.     /* probe the cpu_dai */
  7.     if (!cpu_dai->probed &&  
  8.             cpu_dai->driver->probe_order == order) {  
  9.         if (cpu_dai->driver->probe) {  
  10.             ret = cpu_dai->driver->probe(cpu_dai);  
  11.         }  
  12.         cpu_dai->probed = 1;  
  13.         /* mark cpu_dai as probed and add to card dai list */
  14.         list_add(&cpu_dai->card_list, &card->dai_dev_list);  
  15.     }  
  16.     /* probe the CODEC */
  17.     if (!codec->probed &&  
  18.             codec->driver->probe_order == order) {  
  19.         ret = soc_probe_codec(card, codec);  
  20.     }  
  21.     /* probe the platform */
  22.     if (!platform->probed &&  
  23.             platform->driver->probe_order == order) {  
  24.         ret = soc_probe_platform(card, platform);  
  25.     }  
  26.     /* probe the CODEC DAI */
  27.     if (!codec_dai->probed && codec_dai->driver->probe_order == order) {  
  28.         if (codec_dai->driver->probe) {  
  29.             ret = codec_dai->driver->probe(codec_dai);  
  30.         }  
  31.         /* mark codec_dai as probed and add to card dai list */
  32.         codec_dai->probed = 1;  
  33.         list_add(&codec_dai->card_list, &card->dai_dev_list);  
  34.     }  
  35.     /* complete DAI probe during last probe */
  36.     if (order != SND_SOC_COMP_ORDER_LAST)  
  37.         return 0;  
  38.     ret = soc_post_component_init(card, codec, num, 0);  
  39.     if (ret)  
  40.         return ret;  
  41.         ......  
  42.     /* create the pcm */
  43.     ret = soc_new_pcm(rtd, num);  
  44.         ........  
  45.     return 0;  
  46. }  

該函數出了挨個呼叫了codec，dai和platform驅動的probe函式外，在最後還呼叫了soc_new_pcm()函式用於建立標準alsa驅動的pcm邏輯裝置。現在把該函式的部分程式碼也貼出來：

  1. /* create a new pcm */
  2. int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)  
  3. {  
  4.     ......  
  5.     struct snd_pcm_ops *soc_pcm_ops = &rtd->ops;  
  6.     soc_pcm_ops->open    = soc_pcm_open;  
  7.     soc_pcm_ops->close   = soc_pcm_close;  
  8.     soc_pcm_ops->hw_params   = soc_pcm_hw_params;  
  9.     soc_pcm_ops->hw_free = soc_pcm_hw_free;  
  10.     soc_pcm_ops->prepare = soc_pcm_prepare;  
  11.     soc_pcm_ops->trigger = soc_pcm_trigger;  
  12.     soc_pcm_ops->pointer = soc_pcm_pointer;  
  13.     ret = snd_pcm_new(rtd->card->snd_card, new_name,  
  14.             num, playback, capture, &pcm);  
  15.     /* DAPM dai link stream work */
  16.     INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);  
  17.     rtd->pcm = pcm;  
  18.     pcm->private_data = rtd;  
  19.     if (platform->driver->ops) {  
  20.         soc_pcm_ops->mmap = platform->driver->ops->mmap;  
  21.         soc_pcm_ops->pointer = platform->driver->ops->pointer;  
  22.         soc_pcm_ops->ioctl = platform->driver->ops->ioctl;  
  23.         soc_pcm_ops->copy = platform->driver->ops->copy;  
  24.         soc_pcm_ops->silence = platform->driver->ops->silence;  
  25.         soc_pcm_ops->ack = platform->driver->ops->ack;  
  26.         soc_pcm_ops->page = platform->driver->ops->page;  
  27.     }  
  28.     if (playback)  
  29.         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, soc_pcm_ops);  
  30.     if (capture)  
  31.         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, soc_pcm_ops);  
  32.     if (platform->driver->pcm_new) {  
  33.         ret = platform->driver->pcm_new(rtd);  
  34.         if (ret < 0) {  
  35.             pr_err("asoc: platform pcm constructor failed\n");  
  36.             return ret;  
  37.         }  
  38.     }  
  39.     pcm->private_free = platform->driver->pcm_free;  
  40.     return ret;  
  41. }  

該函式首先初始化snd_soc_runtime中的snd_pcm_ops欄位，也就是rtd->ops中的部分成員，例如open，close，hw_params等，緊接著呼叫標準alsa驅動中的建立pcm的函式snd_pcm_new()建立音效卡的pcm例項，pcm的private_data欄位設定為該runtime變數rtd，然後用platform驅動中的snd_pcm_ops替換部分pcm中的snd_pcm_ops欄位，最後，呼叫platform驅動的pcm_new回撥，該回調實現該platform下的dma記憶體申請和dma初始化等相關工作。到這裡，音效卡和他的pcm例項建立完成。

回到snd_soc_instantiate_card函式，完成snd_card和snd_pcm的建立後，接著對dapm和dai支援的格式做出一些初始化合設定工作後，呼叫了 card->late_probe(card)進行一些最後的初始化合設定工作，最後則是呼叫標準alsa驅動的音效卡註冊函式對音效卡進行註冊：

[cpp] view plaincopy
  1. if (card->late_probe) {  
  2.     ret = card->late_probe(card);  
  3.     if (ret < 0) {  
  4.         dev_err(card->dev, "%s late_probe() failed: %d\n",  
  5.             card->name, ret);  
  6.         goto probe_aux_dev_err;  
  7.     }  
  8. }  
  9. snd_soc_dapm_new_widgets(&card->dapm);  
  10. if (card->fully_routed)  
  11.     list_for_each_entry(codec, &card->codec_dev_list, card_list)  
  12.         snd_soc_dapm_auto_nc_codec_pins(codec);  
  13. ret = snd_card_register(card->snd_card);  
  14. if (ret < 0) {  
  15.     printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);  
  16.     goto probe_aux_dev_err;  
  17. }  
  18. 至此，整個Machine驅動的初始化已經完成，通過各個子結構的probe呼叫，實際上，也完成了部分Platfrom驅動和Codec驅動的初始化工作，整個過程可以用一下的序列圖表示：


                                                                                   圖3.1  基於3.0核心  soc_probe序列圖

    下面的序列圖是本文章第一個版本，基於核心2.6.35，大家也可以參考一下兩個版本的差異：

                                                                                   圖3.2  基於2.6.35  soc_probe序列圖

1.  Codec簡介

在移動裝置中，Codec的作用可以歸結為4種，分別是：

  • 對PCM等訊號進行D/A轉換，把數字的音訊訊號轉換為模擬訊號
  • 對Mic、Linein或者其他輸入源的模擬訊號進行A/D轉換，把模擬的聲音訊號轉變CPU能夠處理的數字訊號
  • 對音訊通路進行控制，比如播放音樂，收聽調頻收音機，又或者接聽電話時，音訊訊號在codec內的流通路線是不一樣的
  • 對音訊訊號做出相應的處理，例如音量控制，功率放大，EQ控制等等

ASoC對Codec的這些功能都定義好了一些列相應的介面，以方便地對Codec進行控制。ASoC對Codec驅動的一個基本要求是：驅動程式的程式碼必須要做到平臺無關性，以方便同一個Codec的程式碼不經修改即可用在不同的平臺上。以下的討論基於wolfson的Codec晶片WM8994，kernel的版本3.3.x。

/*****************************************************************************************************/
宣告：本博內容均由http://blog.csdn.net/droidphone原創，轉載請註明出處，謝謝！
/*****************************************************************************************************/

2.  ASoC中對Codec的資料抽象

描述Codec的最主要的幾個資料結構分別是：snd_soc_codec，snd_soc_codec_driver，snd_soc_dai，snd_soc_dai_driver，其中的snd_soc_dai和snd_soc_dai_driver在ASoC的Platform驅動中也會使用到，Platform和Codec的DAI通過snd_soc_dai_link結構，在Machine驅動中進行繫結連線。下面我們先看看這幾個結構的定義，這裡我只貼出我要關注的欄位，詳細的定義請參照：/include/sound/soc.h。 snd_soc_codec：
[html] view plaincopy
  1. /* SoC Audio Codec device */  
  2. struct snd_soc_codec {  
  3.     const char *name;  /* Codec的名字*/  
  4.     struct device *dev; /* 指向Codec裝置的指標 */  
  5.     const struct snd_soc_codec_driver *driver; /* 指向該codec的驅動的指標 */  
  6.     struct snd_soc_card *card;    /* 指向Machine驅動的card例項 */  
  7.     int num_dai; /* 該Codec數字介面的個數，目前越來越多的Codec帶有多個I2S或者是PCM介面 */  
  8.     int (*volatile_register)(...);  /* 用於判定某一暫存器是否是volatile */  
  9.     int (*readable_register)(...);  /* 用於判定某一暫存器是否可讀 */  
  10.     int (*writable_register)(...);  /* 用於判定某一暫存器是否可寫 */  
  11.     /* runtime */  
  12.     ......  
  13.     /* codec IO */  
  14.     void *control_data; /* 該指標指向的結構用於對codec的控制，通常和read，write欄位聯合使用 */  
  15.     enum snd_soc_control_type control_type;/* 可以是SND_SOC_SPI，SND_SOC_I2C，SND_SOC_REGMAP中的一種 */  
  16.     unsigned int (*read)(struct snd_soc_codec *, unsigned int);  /* 讀取Codec暫存器的函式 */  
  17.     int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);  /* 寫入Codec暫存器的函式 */  
  18.     /* dapm */  
  19.     struct snd_soc_dapm_context dapm;  /* 用於DAPM控制元件 */  
  20. };  

snd_soc_codec_driver: [html] view plaincopy
  1. /* codec driver */  
  2. struct snd_soc_codec_driver {  
  3.     /* driver ops */  
  4.     int (*probe)(struct snd_soc_codec *);  /* codec驅動的probe函式，由snd_soc_instantiate_card回撥 */  
  5.     int (*remove)(struct snd_soc_codec *);    
  6.     int (*suspend)(struct snd_soc_codec *);  /* 電源管理 */  
  7.     int (*resume)(struct snd_soc_codec *);  /* 電源管理 */  
  8.     /* Default control and setup, added after probe() is run */  
  9.     const struct snd_kcontrol_new *controls;  /* 音訊控制元件指標 */  
  10.     const struct snd_soc_dapm_widget *dapm_widgets;  /* dapm部件指標 */  
  11.     const struct snd_soc_dapm_route *dapm_routes;  /* dapm路由指標 */  
  12.     /* codec wide operations */  
  13.     int (*set_sysclk)(...);  /* 時鐘配置函式 */  
  14.     int (*set_pll)(...);  /* 鎖相環配置函式 */  
  15.     /* codec IO */  
  16.     unsigned int (*read)(...);  /* 讀取codec暫存器函式 */  
  17.     int (*write)(...);  /* 寫入codec暫存器函式 */  
  18.     int (*volatile_register)(...);  /* 用於判定某一暫存器是否是volatile */  
  19.     int (*readable_register)(...);  /* 用於判定某一暫存器是否可讀 */  
  20.     int (*writable_register)(...);  /* 用於判定某一暫存器是否可寫 */  
  21.     /* codec bias level */  
  22.     int (*set_bias_level)(...);  /* 偏置電壓配置函式 */  
  23. };  
snd_soc_dai:
[html] view plaincopy
  1. /*  
  2.  * Digital Audio Interface runtime data.  
  3.  *  
  4.  * Holds runtime data for a DAI.  
  5.  */  
  6. struct snd_soc_dai {  
  7.     const char *name;  /* dai的名字 */  
  8.     struct device *dev;  /* 裝置指標 */  
  9.     /* driver ops */  
  10.     struct snd_soc_dai_driver *driver;  /* 指向dai驅動結構的指標 */  
  11.     /* DAI runtime info */  
  12.     unsigned int capture_active:1;      /* stream is in use */  
  13.     unsigned int playback_active:1;     /* stream is in use */  
  14.     /* DAI DMA data */  
  15.     void *playback_dma_data;  /* 用於管理playback dma */  
  16.     void *capture_dma_data;  /* 用於管理capture dma */  
  17.     /* parent platform/codec */  
  18.     union {  
  19.         struct snd_soc_platform *platform;  /* 如果是cpu dai，指向所繫結的平臺 */  
  20.         struct snd_soc_codec *codec;  /* 如果是codec dai指向所繫結的codec */  
  21.     };  
  22.     struct snd_soc_card *card;  /* 指向Machine驅動中的crad例項 */  
  23. };  
snd_soc_dai_driver:
[html] view plaincopy
  1. /*  
  2.  * Digital Audio Interface Driver.  
  3.  *  
  4.  * Describes the Digital Audio Interface in terms of its ALSA, DAI and AC97  
  5.  * operations and capabilities. Codec and platform drivers will register this  
  6.  * structure for every DAI they have.  
  7.  *  
  8.  * This structure covers the clocking, formating and ALSA operations for each  
  9.  * interface.  
  10.  */  
  11. struct snd_soc_dai_driver {  
  12.     /* DAI description */  
  13.     const char *name;  /* dai驅動名字 */  
  14.     /* DAI driver callbacks */  
  15.     int (*probe)(struct snd_soc_dai *dai);  /* dai驅動的probe函式，由snd_soc_instantiate_card回撥 */  
  16.     int (*remove)(struct snd_soc_dai *dai);    
  17.     int (*suspend)(struct snd_soc_dai *dai);  /* 電源管理 */  
  18.     int (*resume)(struct snd_soc_dai *dai);    
  19.     /* ops */  
  20.     const struct snd_soc_dai_ops *ops;  /* 指向本dai的snd_soc_dai_ops結構 */  
  21.     /* DAI capabilities */  
  22.     struct snd_soc_pcm_stream capture;  /* 描述capture的能力 */  
  23.     struct snd_soc_pcm_stream playback;  /* 描述playback的能力 */  
  24. };  
snd_soc_dai_ops用於實現該dai的控制盒引數配置： [html] view plaincopy
  1. struct snd_soc_dai_ops {  
  2.     /*  
  3.      * DAI clocking configuration, all optional.  
  4.      * Called by soc_card drivers, normally in their hw_params.  
  5.      */  
  6.     int (*set_sysclk)(...);  
  7.     int (*set_pll)(...);  
  8.     int (*set_clkdiv)(...);  
  9.     /*  
  10.      * DAI format configuration  
  11.      * Called by soc_card drivers, normally in their hw_params.  
  12.      */  
  13.     int (*set_fmt)(...);  
  14.     int (*set_tdm_slot)(...);  
  15.     int (*set_channel_map)(...);  
  16.     int (*set_tristate)(...);  
  17.     /*  
  18.      * DAI digital mute - optional.  
  19.      * Called by soc-core to minimise any pops.  
  20.      */  
  21.     int (*digital_mute)(...);  
  22.     /*  
  23.      * ALSA PCM audio operations - all optional.  
  24.      * Called by soc-core during audio PCM operations.  
  25.      */  
  26.     int (*startup)(...);  
  27.     void (*shutdown)(...);  
  28.     int (*hw_params)(...);  
  29.     int (*hw_free)(...);  
  30.     int (*prepare)(...);  
  31.     int (*trigger)(...);  
  32.     /*  
  33.      * For hardware based FIFO caused delay reporting.  
  34.      * Optional.  
  35.      */  
  36.     snd_pcm_sframes_t (*delay)(...);  
  37. };  

3.  Codec的註冊

因為Codec驅動的程式碼要做到平臺無關性，要使得Machine驅動能夠使用該Codec，Codec驅動的首要任務就是確定snd_soc_codec和snd_soc_dai的例項，並把它們註冊到系統中，註冊後的codec和dai才能為Machine驅動所用。以WM8994為例，對應的程式碼位置：/sound/soc/codecs/wm8994.c，模組的入口函式註冊了一個platform driver： [html] view plaincopy
  1. static struct platform_driver wm8994_codec_driver = {  
  2.     .driver = {  
  3.            .name = "wm8994-codec",  
  4.            .owner = THIS_MODULE,  
  5.            },  
  6.     .probe = wm8994_probe,  
  7.     .remove = __devexit_p(wm8994_remove),  
  8. };  
  9. module_platform_driver(wm8994_codec_driver);  
有platform driver，必定會有相應的platform device，這個platform device的來源後面再說，顯然，platform driver註冊後，probe回撥將會被呼叫，這裡是wm8994_probe函式：
[html] view plaincopy
  1. static int __devinit wm8994_probe(struct platform_device *pdev)  
  2. {  
  3.     return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wm8994,  
  4.             wm8994_dai, ARRAY_SIZE(wm8994_dai));  
  5. }  
其中，soc_codec_dev_wm8994和wm8994_dai的定義如下（程式碼中定義了3個dai，這裡只列出第一個）：
[html] view plaincopy
  1. static struct snd_soc_codec_driver soc_codec_dev_wm8994 = {  
  2.     .probe =    wm8994_codec_probe,  
  3.     .remove =   wm8994_codec_remove,  
  4.     .suspend =  wm8994_suspend,  
  5.     .resume =   wm8994_resume,  
  6.     .set_bias_level = wm8994_set_bias_level,  
  7.     .reg_cache_size = WM8994_MAX_REGISTER,  
  8.     .volatile_register = wm8994_soc_volatile,  
  9. };  
[html] view plaincopy
  1. static struct snd_soc_dai_driver wm8994_dai[] = {  
  2.     {  
  3.         .name = "wm8994-aif1",  
  4.         .id = 1,  
  5.         .playback = {  
  6.             .stream_name = "AIF1 Playback",  
  7.             .channels_min = 1,  
  8.             .channels_max = 2,  
  9.             .rates = WM8994_RATES,  
  10.             .formats = WM8994_FORMATS,  
  11.         },  
  12.         .capture = {  
  13.             .stream_name = "AIF1 Capture",  
  14.             .channels_min = 1,  
  15.             .channels_max = 2,  
  16.             .rates = WM8994_RATES,  
  17.             .formats = WM8994_FORMATS,  
  18.          },  
  19.         .ops = &wm8994_aif1_dai_ops,  
  20.     },  
  21.     ......  
  22. }  
可見，Codec驅動的第一個步驟就是定義snd_soc_codec_driver和snd_soc_dai_driver的例項，然後呼叫snd_soc_register_codec函式對Codec進行註冊。進入snd_soc_register_codec函式看看： 首先，它申請了一個snd_soc_codec結構的例項： [html] view plaincopy
  1. codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);  
確定codec的名字，這個名字很重要，Machine驅動定義的snd_soc_dai_link中會指定每個link的codec和dai的名字，進行匹配繫結時就是通過和這裡的名字比較，從而找到該Codec的！ [html] view plaincopy
  1. /* create CODEC component name */  
  2.     codec->name = fmt_single_name(dev, &codec->id);  
然後初始化它的各個欄位，多數字段的值來自上面定義的snd_soc_codec_driver的例項soc_codec_dev_wm8994： [html] view plaincopy
  1. codec->write = codec_drv->write;  
  2. codec->read = codec_drv->read;  
  3. codec->volatile_register = codec_drv->volatile_register;  
  4. codec->readable_register = codec_drv->readable_register;  
  5. codec->writable_register = codec_drv->writable_register;  
  6. codec->dapm.bias_level = SND_SOC_BIAS_OFF;  
  7. codec->dapm.dev = dev;  
  8. codec->dapm.codec = codec;  
  9. codec->dapm.seq_notifier = codec_drv->seq_notifier;  
  10. codec->dapm.stream_event = codec_drv->stream_event;  
  11. codec->dev = dev;  
  12. codec->driver = codec_drv;  
  13. codec->num_dai = num_dai;  
在做了一些暫存器快取的初始化和配置工作後，通過snd_soc_register_dais函式對本Codec的dai進行註冊： [html] view plaincopy
  1. /* register any DAIs */  
  2. if (num_dai) {  
  3.     ret = snd_soc_register_dais(dev, dai_drv, num_dai);  
  4.     if (ret <0)  
  5.         goto fail;  
  6. }  
最後，它把codec例項連結到全域性連結串列codec_list中，並且呼叫snd_soc_instantiate_cards是函式觸發Machine驅動進行一次匹配繫結操作： [html] view plaincopy
  1. list_add(&codec->list, &codec_list);  
  2. snd_soc_instantiate_cards();  
上面的snd_soc_register_dais函式其實也是和snd_soc_register_codec類似，顯示為每個snd_soc_dai例項分配記憶體，確定dai的名字，用snd_soc_dai_driver例項的欄位對它進行必要初始化，最後把該dai連結到全域性連結串列dai_list中，和Codec一樣，最後也會呼叫snd_soc_instantiate_cards函式觸發一次匹配繫結的操作。
               圖3.1 dai的註冊 關於snd_soc_instantiate_cards函式，請參閱另一篇博文：Linux音訊驅動之六：ASoC架構中的Machine。

4.  mfd裝置

前面已經提到，codec驅動把自己註冊為一個platform driver，那對應的platform device在哪裡定義？答案是在以下程式碼檔案中：/drivers/mfd/wm8994-core.c。

WM8994本身具備多種功能，除了codec外，它還有作為LDO和GPIO使用，這幾種功能共享一些IO和中斷資源，linux為這種裝置提供了一套標準的實現方法：mfd裝置。其基本思想是為這些功能的公共部分實現一個父裝置，以便共享某些系統資源和功能，然後每個子功能實現為它的子裝置，這樣既共享了資源和程式碼，又能實現合理的裝置層次結構，主要利用到的API就是：mfd_add_devices()，mfd_remove_devices()，mfd_cell_enable()，mfd_cell_disable()，mfd_clone_cell()。

回到wm8994-core.c中，因為WM8994使用I2C進行內部暫存器的存取，它首先註冊了一個I2C驅動：

[html] view plaincopy
  1. static struct i2c_driver wm8994_i2c_driver = {  
  2.     .driver = {  
  3.         .name = "wm8994",  
  4.         .owner = THIS_MODULE,  
  5.         .pm = &wm8994_pm_ops,  
  6.         .of_match_table = wm8994_of_match,  
  7.     },  
  8.     .probe = wm8994_i2c_probe,  
  9.     .remove = wm8994_i2c_remove,  
  10.     .id_table = wm8994_i2c_id,  
  11. };  
  12. static int __init wm8994_i2c_init(void)  
  13. {  
  14.     int ret;  
  15.     ret = i2c_add_driver(&wm8994_i2c_driver);  
  16.     if (ret != 0)  
  17.         pr_err("Failed to register wm8994 I2C driver: %d\n", ret);  
  18.     return ret;  
  19. }  
  20. module_init(wm8994_i2c_init);  

進入wm8994_i2c_probe()函式，它先申請了一個wm8994結構的變數，該變數被作為這個I2C裝置的driver_data使用，上面已經講過，codec作為它的子裝置，將會取出並使用這個driver_data。接下來，本函式利用regmap_init_i2c()初始化並獲得一個regmap結構，該結構主要用於後續基於regmap機制的暫存器I/O，關於regmap我們留在後面再講。最後，通過wm8994_device_init()來新增mfd子裝置：

[html] view plaincopy
  1. static int wm8994_i2c_probe(struct i2c_client *i2c,  
  2.                 const struct i2c_device_id *id)  
  3. {  
  4.     struct wm8994 *wm8994;  
  5.     int ret;  
  6.     wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);  
  7.     i2c_set_clientdata(i2c, wm8994);  
  8.     wm8994->dev = &i2c->dev;  
  9.     wm8994->irq = i2c->irq;  
  10.     wm8994->type = id->driver_data;  
  11.     wm8994->regmap = regmap_init_i2c(i2c, &wm8994_base_regmap_config);  
  12.     return wm8994_device_init(wm8994, i2c->irq);  
  13. }  
繼續進入wm8994_device_init()函式，它首先為兩個LDO新增mfd子裝置： [html] view plaincopy
  1. /* Add the on-chip regulators first for bootstrapping */  
  2. ret = mfd_add_devices(wm8994->dev, -1,  
  3.               wm8994_regulator_devs,  
  4.               ARRAY_SIZE(wm8994_regulator_devs),  
  5.               NULL, 0);  
因為WM1811，WM8994，WM8958三個晶片功能類似，因此這三個晶片都使用了WM8994的程式碼，所以wm8994_device_init()接下來根據不同的晶片型號做了一些初始化動作，這部分的程式碼就不貼了。接著，從platform_data中獲得部分配置資訊： [html] view plaincopy
  1. if (pdata) {  
  2.     wm8994->irq_base = pdata->irq_base;  
  3.     wm8994->gpio_base = pdata->gpio_base;  
  4.     /* GPIO configuration is only applied if it's non-zero */  
  5.     ......  
  6. }  
最後，初始化irq，然後新增codec子裝置和gpio子裝置： [html] view plaincopy
  1. wm8994_irq_init(wm8994);  
  2. ret = mfd_add_devices(wm8994->dev, -1,  
  3.               wm8994_devs, ARRAY_SIZE(wm8994_devs),  
  4.               NULL, 0);  
經過以上這些處理後，作為父裝置的I2C裝置已經準備就緒，它的下面掛著4個子裝置：ldo-0，ldo-1，codec，gpio。其中，codec子裝置的加入，它將會和前面所講codec的platform driver匹配，觸發probe回撥完成下面所說的codec驅動的初始化工作。

5.  Codec初始化

Machine驅動的初始化，codec和dai的註冊，都會呼叫snd_soc_instantiate_cards()進行一次音效卡和codec，dai，platform的匹配繫結過程，這裡所說的繫結，正如Machine驅動一文中所描述，就是通過3個全域性連結串列，按名字進行匹配，把匹配的codec，dai和platform例項賦值給音效卡每對dai的snd_soc_pcm_runtime變數中。一旦繫結成功，將會使得codec和dai驅動的probe回撥被呼叫，codec的初始化工作就在該回調中完成。對於WM8994，該回調就是wm8994_codec_probe函式：

                                                                   圖5.1  wm8994_codec_probe

  • 取出父裝置的driver_data，其實就是上一節的wm8994結構變數，取出其中的regmap欄位，複製到codec的control_data欄位中；
  • 申請一個wm8994_priv私有資料結構，並把它設為codec裝置的driver_data；
  • 通過snd_soc_codec_set_cache_io初始化regmap io，完成這一步後，就可以使用API：snd_soc_read()，snd_soc_write()對codec的暫存器進行讀寫了；
  • 把父裝置的driver_data（struct wm8994）和platform_data儲存到私有結構wm8994_priv中；
  • 因為要同時支援3個晶片型號，這裡要根據晶片的型號做一些特定的初始化工作；
  • 申請必要的幾個中斷；
  • 設定合適的偏置電平；
  • 通過snd_soc_update_bits修改某些暫存器；
  • 根據父裝置的platform_data，完成特定於平臺的初始化配置；
  • 新增必要的control，dapm部件進而dapm路由資訊；

至此，codec驅動的初始化完成。

5.  regmap-io

我們知道，要想對codec進行控制，通常都是通過讀寫它的內部暫存器完成的，讀寫的介面通常是I2C或者是SPI介面，不過每個codec晶片暫存器的位元位組成都有所不同，暫存器地址的位元位也有所不同。例如WM8753的暫存器地址是7bits，資料是9bits，WM8993的暫存器地址是8bits，資料也是16bits，而WM8994的暫存器地址是16bits，資料也是16bits。在kernel3.1版本，核心引入了一套regmap機制和相關的API，這樣就可以用統一的操作來實現對這些多樣的暫存器的控制。regmap使用起來也相對簡單：
  • 為codec定義一個regmap_config結構例項，指定codec暫存器的地址和資料位等資訊；
  • 根據codec的控制匯流排型別，呼叫以下其中一個函式，得到一個指向regmap結構的指標：
    • struct regmap *regmap_init_i2c(struct i2c_client *i2c, const struct regmap_config *config);
    • struct regmap *regmap_init_spi(struct spi_device *dev, const struct regmap_config *config);
  • 把獲得的regmap結構指標賦值給codec->control_data；
  • 呼叫soc-io的api：snd_so

相關推薦

ALSA音訊驅動研究

前面一節的內容我們提到，ASoC被分為Machine、Platform和Codec三大部分，其中的Machine驅動負責Platform和Codec之間的耦合以及部分和裝置或板子特定的程式碼，再次引用上一節的內容：Machine驅動負責處理機器特有的一些控制元件和音訊事件（

linux音訊alsa-uda134x驅動文件閱讀之五（動態音訊電源管理)(不完整)

Dynamic Audio Power Management for Portable Devices便攜裝置的動態音訊電源管理 =================================================== 1. Description1、概述 ============== Dyna

linux驅動：音訊驅動（一）ALSA

一、【基礎知識】 1、J2 《--HPR_OUT+HPL_OUT 《--  U13（TLV320AIC3104IRHBR）的HPROUT+HPLOUT 2、驅動原始碼 IPNC_RDK_V3.8.0.1/Source/ti_tools/ipnc_psp_arago/kern

linux音頻alsa-uda134x驅動文檔閱讀之一轉自http://blog.csdn.net/wantianpei/article/details/7817293

發出 hand 增加 int chang == 音頻 set device 前言 目前，linux系統常用的音頻驅動有兩種形式:alsa oss alsa:現在是linux下音頻驅動的主要形式，與簡單的oss兼容。oss：過去的形式而我們板子上的uda1341用的就是als

linux音頻alsa-uda134x驅動分析之二（時鐘)

lin pen play 個數 inter and 文本 ted word Audio Clocking音頻時鐘==============This text describes the audio clocking terms in ASoC and digital au

Linux ARM 使用USB麥克風ALSA音訊裝置程式設計

近期有一個專案要用到音訊處理，先是對標準的麥克風輸入裝置進行了測試，後來使用的USB麥克風，在程式設計時遇到了小問題，所以記下筆記。 一、環境 1.系統Linux （Lubuntu） 2.硬體CPU： RK3288(Coretex-A17) 3.USB 麥克風（本篇教程支援Alsa架

音訊驅動曲線

https://www.youtube.com/watch?v=SqFvO462yVw&t=6s音訊驅動曲線 {TimeLine} 修改同步:Av-Sync {Video Sequence Editor} 增加音訊檔案[shift A] sound (*.mp3) {世界場景} 黑色背景{3D視

alsa音訊播放過程中的基本概念

以下為 ALSA-Project/FramesPeriods[1] 學習筆記 1, sample_rate: 即每秒進行多少次取樣，常見的比如 8000、16000、44100和48000等 2, sample_bits: 即每次取樣多少個bit，多是 16bit。其他常見有 24bits、32bits等

Linux音訊驅動-PCM裝置

概述 1.  什麼是pcm？ pcm(Pulse-code modulation)脈衝編碼調製，是將模擬訊號轉化為數字訊號的一種方法。聲音的轉化的過程為，先對連續的模擬訊號按照固定頻率週期性取樣，將取樣到的資料按照一定的精度

ALSA音訊概念介紹

(1) 取樣位數 : 也就是codec取樣時一個點所佔的bit數,通常有8,16,24bit等. (2) 通道數[channel] : 是mono還是stereo,對應的是1或者是2通道. (3) 取樣率 : codec 每秒取樣的點數,如44.1KHZ,就是

Android音訊驅動-ASOC之PCM Open

status_t AudioALSAPlaybackHandlerBase::openPcmDriver(const unsigned int device) { mPcm = pcm_open(AudioALSADeviceParser::getIns

嵌入式Linux音訊驅動開發

1.嵌入式音訊系統硬體連線 下圖所示的嵌入式裝置使用IIS將音訊資料傳送給編解碼器。對編解碼器的I/O暫存器的程式設計通過IIC匯流排進行。 2.音訊體系結構-ALSA ALSA是Advanced Linux Sound Architecture 的縮寫，目前已經成為了li

君正 X1000 音訊驅動架構

X1000 音訊驅動架構筆記 使用開發板X1000_HALLEY2_V2.0，原始碼為北京君正官方原始碼V7.0版本，與V6.0無太多差異 專案中遇到的問題 這是核心原始碼中設定所導致的，可能官方認為X1000這樣設定會最好，可是我們需要小於30MS 的週期設定

Android音訊驅動-ASOC之建立裝置節點

建立裝置檔案的方法： 第一種是使用mknod手工建立：mknod filename type major minor 第二種是自動建立裝置節點：利用udev（mdev）來實現裝置檔案的自動建立，首先應保證支援udev（mdev），由busybox配置。

Linux ALSA音訊系統之音訊播放

1.amixer設定 a.查詢哪些引數可以控制 #amixer controls numid=2,iface=MIXER,name='DIN source' #通道源選擇 numid=3,iface=MIXER,name='I

Android 音訊驅動分析--A10

 A10+Android4.0 音訊驅動(樹莓派II 原始碼) linux-3.0目錄 make ARCH=arm menuconfig 進到核心配置介面，可以看到  知道我們的配置項名字，然後進 目錄 :\lichee\linux-3.0\sound\soc  看Kcon

Android音訊驅動簡析

指核心驅動程式，包括硬體相關的程式碼和一些公共程式碼，非常龐大，程式碼總量達數十萬行；alsa-libs指使用者空間的函式庫，提供給應用程式使用，應用程式應包含標頭檔案asoundlib.h，並使用共享庫libasound.so；alsa-utils包含一些基於ALSA的用於控制音效卡的應用程式，如alsac

ALSA音訊庫的移植 ARM 交叉編譯 環境變數

alsa 是在LINUX出現比較晚的音訊處理庫,主要是針對原有的OSS的庫進行改進.效能更好,支援多個播放源等.但相應的,增加的程式設計的複雜性.   舊的oss是採用標準檔案IO介面,裝置打開採用open,聲音播錄是採用資料IO介面(read/write),裝置的引數

alsa音訊採集和播放 (麥克風)

Alsa音訊採集 #include <stdio.h> #include <malloc.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include 

Android音訊驅動-ASOC之Platform

ASoC被分為Machine，Platform和Codec三大部件，Platform驅動的主要作用是完成音訊資料的管理， 最終通過CPU的數字音訊介面（DAI）把音訊資料傳送給Codec進行處理，最終由Codec輸出驅動耳機或者是喇叭的音信訊號。 在具體實現