ALSA声卡09_从零编写之参数设置_学习笔记

超、凢脫俗 2022-06-01 23:07 604阅读 0赞

1、参数设置分析

（1）open: soc\_pcm\_open 依次调用cpu\_dai, dma, codec\_dai, machine的open或startup函数  
  
  
只在dma的open函数里添加参数相关的代码  
  
  
（2）SNDRV\_PCM\_IOCTL\_HW\_PARAMS: soc\_pcm\_hw\_params 依次调用machine,codec\_dai,cpu\_dai,platform(dma)的hw\_params函数  
      
在uda1341.c, s3c2440-iis.c里实现hw\_params函数（把裸板程序里面的相关代码移过来）  
  
  
(s3c2440-dma.c 主要涉及数据传输，在下一节实现hw\_params函数)

（3）打开声卡的时候会调用到machine部分的dma.c的snd\_pcm\_ops的dma\_open函数)

2、open函数

（1）s3c2440\_dma.c(Platform)

static int s3c2440\_dma\_open(struct snd\_pcm\_substream \*substream)  
\{  
struct snd\_pcm\_runtime \*runtime = substream->runtime;  
    int ret;  
    /\* 设置属性 \*/  
snd\_pcm\_hw\_constraint\_integer(runtime, SNDRV\_PCM\_HW\_PARAM\_PERIODS);  
snd\_soc\_set\_runtime\_hwparams(substream, &s3c2440\_dma\_hardware);  
    \}  
return 0;  
\}

（2）snd\_pcm\_hardware结构体

static const struct snd\_pcm\_hardware s3c2440\_dma\_hardware = \{   
.info= SNDRV\_PCM\_INFO\_INTERLEAVED | //数据的排列方式（左右左右左右还是左左左右右右）  
   SNDRV\_PCM\_INFO\_BLOCK\_TRANSFER |  
   SNDRV\_PCM\_INFO\_MMAP |  
   SNDRV\_PCM\_INFO\_MMAP\_VALID |  
   SNDRV\_PCM\_INFO\_PAUSE |  
   SNDRV\_PCM\_INFO\_RESUME,  
.formats= SNDRV\_PCM\_FMTBIT\_S16\_LE |  //所支持的音频数据格式  
   SNDRV\_PCM\_FMTBIT\_U16\_LE |  
   SNDRV\_PCM\_FMTBIT\_U8 |  
   SNDRV\_PCM\_FMTBIT\_S8,  
.channels\_min= 2,//通道数  
.channels\_max= 2,  
.buffer\_bytes\_max= 128\*1024,  
.period\_bytes\_min= PAGE\_SIZE,  
.period\_bytes\_max= PAGE\_SIZE\*2,  
.periods\_min= 2,  
.periods\_max= 128,  
.fifo\_size= 32,  
\};  
  
3、hw\_params函数(硬件参数)

（1）uda1341.c(codec)

static int uda1341\_hw\_params(struct snd\_pcm\_substream \*substream,  
struct snd\_pcm\_hw\_params \*params,  
struct snd\_soc\_dai \*dai)  
\{  
    /\* 根据params的值,设置UDA1341的寄存器   
     \* 比如时钟设置,格式  
     \*/  
    /\* 为了简单, 在uda1341\_init\_regs里就设置好时钟、格式等参数 \*/  
    return 0;  
\}  
  
Uda1341的初始化

static void uda1341\_init\_regs(struct snd\_soc\_codec \*codec)  
\{  
  
  
/\* GPB 4: L3CLOCK \*/  
/\* GPB 3: L3DATA \*/  
/\* GPB 2: L3MODE \*/  
    \*gpbcon &= ~((3<<4) | (3<<6) | (3<<8));  
    \*gpbcon |= ((1<<4) | (1<<6) | (1<<8));  
  
    uda1341\_write\_reg(codec, UDA1341\_STATUS0, 0x40 | STAT0\_SC\_384FS | STAT0\_DC\_FILTER); // reset uda1341  
    uda1341\_write\_reg(codec, UDA1341\_STATUS1, STAT1\_ADC\_ON | STAT1\_DAC\_ON);  
  
  
    uda1341\_write\_reg(codec, UDA1341\_DATA00, DATA0\_VOLUME(0x0)); // maximum volume  
    uda1341\_write\_reg(codec, UDA1341\_DATA01, DATA1\_BASS(0)| DATA1\_TREBLE(0));  
    uda1341\_write\_reg(codec, UDA1341\_DATA10, 0);  // not mute  
\}  
  
驱动程序函数uda1341\_soc\_probe调用uda1341\_init\_regs函数

/\* 所有寄存器的默认值 \*/  
static const char uda1341\_reg\[UDA1341\_REG\_NUM\] = \{  
    /\* DATA0 \*/  
    0x00, 0x40, 0x80,  
      
/\* Extended address registers \*/  
0x04, 0x04, 0x04, 0x00, 0x00, 0x00,  
  
  
    /\* data1 \*/  
    0x00,  
      
    /\* status regs \*/  
    0x00, 0x83,  
\};

probe函数

static int uda1341\_soc\_probe(struct snd\_soc\_codec \*codec)  
\{  
    int ret;  
    uda1341\_init\_regs(codec);  
    return ret;  
\}  
  
（2）s3c2440\_iis.c(Platform)

static int s3c2440\_i2s\_hw\_params(struct snd\_pcm\_substream \*substream,  
struct snd\_pcm\_hw\_params \*params,  
struct snd\_soc\_dai \*dai)  
\{   
    /\* 根据params设置IIS控制器 \*/  
  
  
    int tmp\_fs;  
    int i;  
    int min = 0xffff;  
    int pre = 0;  
    unsigned int fs;  
    struct clk \*clk = clk\_get(NULL, "pclk");  
  
入口函数映射寄存器（出口函数取消映射）  
    /\*gpecon   = ioremap(0x56000040, 4);//0x56000040是物理地址，大小是4字节  
    iis\_regs = ioremap(0x55000000, sizeof(struct s3c2440\_iis\_regs));\*/  
    /\* 配置GPIO用于IIS \*/

\*gpecon &= ~((3<<0) | (3<<2) | (3<<4) | (3<<6) | (3<<8));  
    \*gpecon |= ((2<<0) | (2<<2) | (2<<4) | (2<<6) | (2<<8));  
      
      
    /\* bit\[9\] : Master clock select, 0-PCLK  
     \* bit\[8\] : 0 = Master mode  
     \* bit\[7:6\] : 10 = Transmit mode  
     \* bit\[4\] : 0-IIS compatible format  
     \* bit\[2\] : 384fs, 确定了MASTER CLOCK之后, fs = MASTER CLOCK/384  
     \* bit\[1:0\] : Serial bit clock frequency select, 32fs  
     \*/  
     寄存器映射（写入一个结构体后再映射）

static volatile struct s3c2440\_iis\_regs \*iis\_regs;

struct s3c2440\_iis\_regs \{  
    unsigned int iiscon ;   
    unsigned int iismod ;   
    unsigned int iispsr ;   
    unsigned int iisfcon;   
    unsigned int iisfifo;   
\};  
    iis\_regs = ioremap(0x55000000, sizeof(struct s3c2440\_iis\_regs));//寄存器映射

if (params\_format(params) == SNDRV\_PCM\_FORMAT\_S16\_LE)//每个采样值占据的位数（是8位还是16位根据params决定）  
        iis\_regs->iismod = (2<<6) | (0<<4) | (1<<3) | (1<<2) | (1);  
    else if (params\_format(params) == SNDRV\_PCM\_FORMAT\_S8)  
        iis\_regs->iismod = (2<<6) | (0<<4) | (0<<3) | (1<<2) | (1);  
    else  
        return -EINVAL;//其他值是错误的  
    struct clk \*clk = clk\_get(NULL, "pclk");

PCLK=clk\_get\_rate(clk）；最后要用clk\_put(clk);  
    /\* Master clock = PCLK/(n+1)  
     \* fs = Master clock / 384//fs是采样率  
     \* fs = PCLK / (n+1) / 384  
     \*/  
    fs = params\_rate(params);//采样频率根据params得到  
    for (i = 0; i <= 31; i++)  
    \{   
        tmp\_fs = clk\_get\_rate(clk)/384/(i+1);  
        if (ABS(tmp\_fs, fs) < min)  
        \{   
            min = ABS(tmp\_fs, fs);  
            pre = i;  
        \}  
    \}  
    iis\_regs->iispsr = (pre << 5) | (pre);  
  
  
    /\*  
     \* bit15 : Transmit FIFO access mode select, 1-DMA  
     \* bit13 : Transmit FIFO, 1-enable  
     \*/  
    iis\_regs->iisfcon = (1<<15) | (1<<13);  
      
    /\*  
     \* bit\[5\] : Transmit DMA service request, 1-enable  
     \* bit\[1\] : IIS prescaler, 1-enable  
     \*/  
    iis\_regs->iiscon = (1<<5) | (1<<1) ;  
  
  
    clk\_put(clk);  
      
    return 0;  
\}  
（3）s3c2440\_dma.c(Platform)

static int s3c2440\_dma\_hw\_params(struct snd\_pcm\_substream \*substream,  
struct snd\_pcm\_hw\_params \*params)  
\{   
struct snd\_pcm\_runtime \*runtime = substream->runtime;  
unsigned long totbytes = params\_buffer\_bytes(params);  
      
    /\* 根据params设置DMA \*/  
snd\_pcm\_set\_runtime\_buffer(substream, &substream->dma\_buffer);  
  
  
    /\* s3c2440\_dma\_new分配了很大的DMA BUFFER  
     \* params决定使用多大  
     \*/  
runtime->dma\_bytes            = totbytes;  
    playback\_dma\_info.buffer\_size = totbytes;  
    playback\_dma\_info.period\_size = params\_period\_bytes(params);  
  
  
    return 0;  
\}  
  
4、uda1341.c

codec部分

static struct snd\_soc\_codec\_driver soc\_codec\_dev\_uda1341 = \{  
    .probe = uda1341\_soc\_probe,  
    /\* UDA1341的寄存器不支持读操作，只支持写操作  
     \* 要知道某个寄存器的当前值,  
     \* 只能在写入时保存起来（cache）  
     \*/  
.reg\_cache\_size = sizeof(uda1341\_reg), //存放的是寄存器的值(cache有多大，看看寄存器个数)  
.reg\_word\_size = sizeof(u8),//每个寄存器占的数据位数  
.reg\_cache\_default = uda1341\_reg,//默认值  
.reg\_cache\_step = 1,  
.read  = uda1341\_read\_reg\_cache,//读寄存器的函数  
.write = uda1341\_write\_reg,  /\* 写寄存器 \*/  
\};  
(1)读寄存器（支持寄存器的读操作的编解码芯片可用读寄存器函数）

/\*  
 \* The codec has no support for reading its registers except for peak level...  
 \*/

对于uda1341智能在cache中读出来  
static inline unsigned int uda1341\_read\_reg\_cache(struct snd\_soc\_codec \*codec,  
unsigned int reg)  
\{   
u8 \*cache = codec->reg\_cache;//对于uda1341智能在cache中读出来  
  
  
if (reg >= UDA1341\_REG\_NUM)//寄存器的个数大于某个值，返回-1  
return -1;  
return cache\[reg\];  
\}  
（2）写寄存器

static int uda1341\_write\_reg(struct snd\_soc\_codec \*codec, unsigned int reg,  
unsigned int value)  
\{  
u8 \*cache = codec->reg\_cache;//把写寄存器的值写到cache里面去（备份下来，因为uda1341不允许读寄存器操作）  
  
  
    /\* 先保存 \*/  
if (reg >= UDA1341\_REG\_NUM)//寄存器个数为12  
return -1;  
cache\[reg\] = value;//保存值  
  
  
    /\* 再写入硬件 \*/  
    ![Center][]  
    /\* 对于EA（扩展寄存器）,需要调用2次l3\_write \*/先把EA地址值作为数据发送出去，再把ED作为数据值发送出去  
    if ((reg >= UDA1341\_EA000) && (reg <= UDA1341\_EA110))  
    \{ //左边的参数是地址（data0），右边的参数是数据  (uda1341\_reg\_addr\[reg\]对应的是扩展地址)，最高两位或上1  
        l3\_write(UDA1341\_DATA0\_ADDR, uda1341\_reg\_addr\[reg\] | UDA1341\_EXTADDR\_PREFIX);  
        l3\_write(UDA1341\_DATA0\_ADDR, value | UDA1341\_EXTDATA\_PREFIX);  
    \}  
    else  
    \{  
        l3\_write(uda1341\_reg\_addr\[reg\], value | uda1341\_data\_bit\[reg\]);//我们访问某个寄存器的时候，数据值要或上某一些位，才能定位到uda1341的某一类下的某个寄存器  
    \}  
  
  
    return 0;  
\}

dai部分

static struct snd\_soc\_dai\_driver uda1341\_dai = \{  
.ops = &uda1341\_dai\_ops,  
\};

static const struct snd\_soc\_dai\_ops uda1341\_dai\_ops = \{  
.hw\_params = uda1341\_hw\_params,  
\};

5、uda1341硬件分析

（1）2440通过3条线连接uda1341,想写uda1341的寄存器，肯定需要地址和数据，L3MODE等于0时表示线L3DATA线上传输的是地址，为1时传输的是数据。L3CLOCK表示每一个时钟 传输1位。

![Center 1][]

（2）看芯片手册（UDA1341TS.pdf）有多少个寄存器

数据位7~2代表设备地址（表示uda1341），数据位0和1表示地址

![Center 2][]

（3）L3接口

先发出地址，再发出数据。地址里bit7~bit2用于表示uda1341,数据位0和1表示访问哪类寄存器，有3类

![Center 3][]

data0类能访问多少个寄存器

可认为第1、2、3三行代表的是寄存器，第4、5行不是寄存器，是扩展地址，发出的数据是data0这1类，并且前面两个数据是11的话，后面的3位表示扩展地址。

![Center 4][]

想访问某个扩展地址，如访问EA，先是地址，后是数据（数据是扩展寄存器的地址（高两位是1））

下面的1、2、3、4、5、6、7代表寄存器，对于data0这1类有9个寄存器

![Center 5][]

![Center 6][]

data1这1类只有1个

status这1类，先发出地址，再发出数据，如果数据的最高位是0，选第1行数据，否则选第2行数据。

![Center 7][]

所以uda1341会根据第2个周期的某些位来分辨访问哪些寄存器，共有3类12个寄存器。

![Center 8][]

[Center]: /images/20220602/660858e89c224702a6751addd5c3a6e4.png
[Center 1]: /images/20220602/9a60b59000fa4beb839d31236cabe485.png
[Center 2]: /images/20220602/ee50fab60e0947cabb7a5092c46db88e.png
[Center 3]: /images/20220602/b05856d7ff664ce3a85e99337bc3d5f4.png
[Center 4]: /images/20220602/268a1684b0924bd99961eb8605c692ec.png
[Center 5]: /images/20220602/370ae912071c4adfad23be8e5831e7f8.png
[Center 6]: /images/20220602/e3d8ebf40deb4ab7a377a2c8a0dfd735.png
[Center 7]: /images/20220602/6fefc0deef264e0ca88d7c39956dd17e.png
[Center 8]: /images/20220602/8eca879a68ed4986b29eaea82e98fd6a.png