linux 3.15.2 UDA1341 声卡移植

最新推荐文章于 2021-03-19 14:50:53 发布
最新推荐文章于 2021-03-19 14:50:53 发布
阅读量867 收藏 1
点赞数
分类专栏： linux经典知识解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fz835304205/article/details/37817993
版权

linux3.15 相对于linux2.6.32的sound有些改动，移植方法基本和原来的相似

static struct map_desc mini2440_iodesc[] __initdata = {
	/* nothing to declare, move along */
    {
		.virtual	= (u32)S3C24XX_VA_ISA_WORD,
		.pfn		= __phys_to_pfn(S3C2410_CS2),
		.length		= 0x10000,
		.type		= MT_DEVICE,
	}, {
		.virtual	= (u32)S3C24XX_VA_ISA_WORD + 0x10000,
		.pfn		= __phys_to_pfn(S3C2410_CS2 + (1<<24)),
		.length		= SZ_4M,
		.type		= MT_DEVICE,
	}, {
		.virtual	= (u32)S3C24XX_VA_ISA_BYTE,
		.pfn		= __phys_to_pfn(S3C2410_CS2),
		.length		= 0x10000,
		.type		= MT_DEVICE,
	}, {
		.virtual	= (u32)S3C24XX_VA_ISA_BYTE + 0x10000,
		.pfn		= __phys_to_pfn(S3C2410_CS2 + (1<<24)),
		.length		= SZ_4M,
		.type		= MT_DEVICE,
	}, {
		.virtual	= 0xE0000000,
		.pfn		= __phys_to_pfn(0x19000000),
		.length		= SZ_1M,
		.type		= MT_DEVICE,
	}
};
static struct s3c24xx_uda134x_platform_data mini2440_audio_pins = {
	.l3_clk = S3C2410_GPB(4),
	.l3_mode = S3C2410_GPB(2),
	.l3_data = S3C2410_GPB(3),
	.model = UDA134X_UDA1341
};

static struct platform_device mini2440_audio = {
	.name		= "s3c24xx_uda134x",
	.id		= 0,
	.dev		= {
		.platform_data	= &mini2440_audio_pins,
	},
};
static struct platform_device uda1340_codec = {
		.name = "uda134x-codec",
		.id = -1,
};
static struct platform_device *mini2440_devices[] __initdata = {
	&s3c_device_ohci,
	&s3c_device_wdt,
	&s3c_device_i2c0,
	&s3c_device_rtc,
	&s3c_device_usbgadget,
	&s3c_device_led,
	&mini2440_button_device,
	&s3c_device_nand,
	&s3c_device_sdi,
	&s3c_device_adc,
	&s3c_device_hwmon,
	&s3c_device_ts,
	&s3c_device_iis,
	&uda1340_codec,
	&mini2440_audio,
	&samsung_asoc_dma,
};

添加上述文件后，基本就可以了，make menuconfig 启动声卡的支持

但是声卡驱动虽然移植注册成功在放音的时候噪声很大，基本都是噪音，而linux2.6.32内核的却没此问题，在网上找解决方案无果，于是尝试找到内核升级sound部分的更改，发现原来的s3c24xx_pcm.c 变为dma.c，对比两个文件确实有改动，把dma.c的内容更改后放音正常，喜悦之情不敢独享，与网友分享，希望网友少走弯路。我想给内核提交个补丁，可是流程太麻烦了。

修改后dma.c的内容

/*
 * dma.c  --  ALSA Soc Audio Layer
 *
 * (c) 2006 Wolfson Microelectronics PLC.
 * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
 *
 * Copyright 2004-2005 Simtec Electronics
 *	http://armlinux.simtec.co.uk/
 *	Ben Dooks <ben@simtec.co.uk>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 */

#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <linux/module.h>

#include <sound/soc.h>
#include <sound/pcm_params.h>

#include <asm/dma.h>
#include <mach/hardware.h>
#include <mach/dma.h>

#include "dma.h"

#define ST_RUNNING		(1<<0)
#define ST_OPENED		(1<<1)

static const struct snd_pcm_hardware 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,
};

struct runtime_data {
	spinlock_t lock;
	int state;
	unsigned int dma_loaded;
	unsigned int dma_period;
	dma_addr_t dma_start;
	dma_addr_t dma_pos;
	dma_addr_t dma_end;
    unsigned int dma_limit;
	struct s3c_dma_params *params;
};

//static void audio_buffdone(void *data);

/* dma_enqueue
 *
 * place a dma buffer onto the queue for the dma system
 * to handle.
 */
static void dma_enqueue(struct snd_pcm_substream *substream)
{
       struct runtime_data *prtd = substream->runtime->private_data;
       dma_addr_t pos = prtd->dma_pos;
       unsigned int limit;
       int ret;
 
       pr_debug("Entered%s\n", __func__);
 
       if (samsung_dma_has_circular()) {
		   limit = (prtd->dma_end - prtd->dma_start) / prtd->dma_period;
	   } else
		   limit = prtd->dma_limit;
 
       pr_debug("%s:loaded %d, limit %d\n",
                            __func__,prtd->dma_loaded, limit);
 
       while(prtd->dma_loaded < limit) {
              unsigned long len = prtd->dma_period;
              pr_debug("dma_loaded:%d\n", prtd->dma_loaded);

              if ((pos + len) > prtd->dma_end) {
    			 len  = prtd->dma_end - pos;
    			 pr_debug(KERN_DEBUG "%s: corrected dma len %ld\n",
    			       __func__, len);
    		  }
              
              ret = s3c2410_dma_enqueue(prtd->params->channel,
                     substream,pos,len);
 
              if(ret == 0){
                     prtd->dma_loaded++;
                     pos+= prtd->dma_period;
                     if(pos>=prtd->dma_end)
                            pos= prtd->dma_start;
              }else
                     break;
       }
 
       prtd->dma_pos= pos;
}
static void audio_buffdone(struct s3c2410_dma_chan *channel,
                                   void* dev_id, int size,
                                   enum s3c2410_dma_buffresult result)
{
       struct snd_pcm_substream *substream = dev_id;
       struct runtime_data *prtd;
 
       pr_debug("Entered%s\n", __func__);
 
       if(result == S3C2410_RES_ABORT || result == S3C2410_RES_ERR)
              return;
 
       prtd = substream->runtime->private_data;
 
       if(substream)
              snd_pcm_period_elapsed(substream);
 
       spin_lock(&prtd->lock);
       if(prtd->state & ST_RUNNING && !samsung_dma_has_circular()){
              prtd->dma_loaded--;
              dma_enqueue(substream);
       }
 
       spin_unlock(&prtd->lock);
}

static int dma_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct runtime_data *prtd = runtime->private_data;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	unsigned long totbytes = params_buffer_bytes(params);
	struct s3c_dma_params *dma =
		snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
	struct samsung_dma_req req;
	struct samsung_dma_config config;

	pr_debug("Entered %s\n", __func__);

	/* return if this is a bufferless transfer e.g.
	 * codec <--> BT codec or GSM modem -- lg FIXME */
	if (!dma)
		return 0;

	/* this may get called several times by oss emulation
	 * with different params -HW */
	if (prtd->params == NULL) {
		/* prepare DMA */
		prtd->params = dma;

		pr_debug("params %p, client %p, channel %d\n", prtd->params,
			prtd->params->client, prtd->params->channel);

		prtd->params->ops = samsung_dma_get_ops();

		req.cap = (samsung_dma_has_circular() ?
			DMA_CYCLIC : DMA_SLAVE);
		req.client = prtd->params->client;
		config.direction =
			(substream->stream == SNDRV_PCM_STREAM_PLAYBACK
			? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM);
		config.width = prtd->params->dma_size;
		config.fifo = prtd->params->dma_addr;
		prtd->params->ch = prtd->params->ops->request(
				prtd->params->channel, &req, rtd->cpu_dai->dev,
				prtd->params->ch_name);
		if (!prtd->params->ch) {
			pr_err("Failed to allocate DMA channel\n");
			return -ENXIO;
		}
		prtd->params->ops->config(prtd->params->ch, &config);
	}

	s3c2410_dma_set_buffdone_fn(prtd->params->channel,audio_buffdone);

	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);

	runtime->dma_bytes = totbytes;

	spin_lock_irq(&prtd->lock);
	prtd->dma_loaded = 0;
	prtd->dma_period = params_period_bytes(params);
	prtd->dma_start = runtime->dma_addr;
	prtd->dma_pos = prtd->dma_start;
	prtd->dma_end = prtd->dma_start + totbytes;

    prtd->dma_limit = runtime->hw.periods_min;
	spin_unlock_irq(&prtd->lock);

	return 0;
}

static int dma_hw_free(struct snd_pcm_substream *substream)
{
	struct runtime_data *prtd = substream->runtime->private_data;

	pr_debug("Entered %s\n", __func__);

	snd_pcm_set_runtime_buffer(substream, NULL);

	if (prtd->params) {
		prtd->params->ops->flush(prtd->params->ch);
		prtd->params->ops->release(prtd->params->ch,
					prtd->params->client);
		prtd->params = NULL;
	}

	return 0;
}

static int dma_prepare(struct snd_pcm_substream *substream)
{
	struct runtime_data *prtd = substream->runtime->private_data;
	int ret = 0;
    struct samsung_dma_config config;

	pr_debug("Entered %s\n", __func__);

	/* return if this is a bufferless transfer e.g.
	 * codec <--> BT codec or GSM modem -- lg FIXME */
	if (!prtd->params)
		return 0;
    config.direction =
		(substream->stream == SNDRV_PCM_STREAM_PLAYBACK
		? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM);
	config.width = prtd->params->dma_size;
	config.fifo = prtd->params->dma_addr;
    prtd->params->ops->config(prtd->params->ch, &config);
	/* flush the DMA channel */
	prtd->params->ops->flush(prtd->params->ch);

	prtd->dma_loaded = 0;
	prtd->dma_pos = prtd->dma_start;

	/* enqueue dma buffers */
	dma_enqueue(substream);

	return ret;
}

static int dma_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct runtime_data *prtd = substream->runtime->private_data;
	int ret = 0;

	pr_debug("Entered %s\n", __func__);

	spin_lock(&prtd->lock);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
    case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		prtd->state |= ST_RUNNING;
		prtd->params->ops->trigger(prtd->params->ch);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
    case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		prtd->state &= ~ST_RUNNING;
		prtd->params->ops->stop(prtd->params->ch);
		break;

	default:
		ret = -EINVAL;
		break;
	}

	spin_unlock(&prtd->lock);

	return ret;
}

static snd_pcm_uframes_t
dma_pointer(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct runtime_data *prtd = runtime->private_data;
	unsigned long res;

	//pr_debug("Entered %s\n", __func__);

	//res = prtd->dma_pos - prtd->dma_start;
    dma_addr_t src, dst;

	pr_debug("Entered %s\n", __func__);

	spin_lock(&prtd->lock);
	s3c2410_dma_getposition(prtd->params->channel, &src, &dst);

	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
		res = dst - prtd->dma_start;
	else
		res = src - prtd->dma_start;

	spin_unlock(&prtd->lock);

	pr_debug("Pointer offset: %lu\n", res);

	/* we seem to be getting the odd error from the pcm library due
	 * to out-of-bounds pointers. this is maybe due to the dma engine
	 * not having loaded the new values for the channel before being
	 * called... (todo - fix )
	 */

	if (res >= snd_pcm_lib_buffer_bytes(substream)) {
		if (res == snd_pcm_lib_buffer_bytes(substream))
			res = 0;
	}

	return bytes_to_frames(substream->runtime, res);
}

static int dma_open(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct runtime_data *prtd;

	pr_debug("Entered %s\n", __func__);

	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
	snd_soc_set_runtime_hwparams(substream, &dma_hardware);

	prtd = kzalloc(sizeof(struct runtime_data), GFP_KERNEL);
	if (prtd == NULL)
		return -ENOMEM;

	spin_lock_init(&prtd->lock);

	runtime->private_data = prtd;
	return 0;
}

static int dma_close(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct runtime_data *prtd = runtime->private_data;

	pr_debug("Entered %s\n", __func__);

	if (!prtd)
		pr_debug("dma_close called with prtd == NULL\n");

	kfree(prtd);

	return 0;
}

static int dma_mmap(struct snd_pcm_substream *substream,
	struct vm_area_struct *vma)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	pr_debug("Entered %s\n", __func__);

	return dma_mmap_writecombine(substream->pcm->card->dev, vma,
				     runtime->dma_area,
				     runtime->dma_addr,
				     runtime->dma_bytes);
}

static struct snd_pcm_ops dma_ops = {
	.open		= dma_open,
	.close		= dma_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= dma_hw_params,
	.hw_free	= dma_hw_free,
	.prepare	= dma_prepare,
	.trigger	= dma_trigger,
	.pointer	= dma_pointer,
	.mmap		= dma_mmap,
};

static int preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
{
	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	struct snd_dma_buffer *buf = &substream->dma_buffer;
	size_t size = dma_hardware.buffer_bytes_max;

	pr_debug("Entered %s\n", __func__);

	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	buf->dev.dev = pcm->card->dev;
	buf->private_data = NULL;
	buf->area = dma_alloc_writecombine(pcm->card->dev, size,
					   &buf->addr, GFP_KERNEL);
	if (!buf->area)
		return -ENOMEM;
	buf->bytes = size;
	return 0;
}

static void dma_free_dma_buffers(struct snd_pcm *pcm)
{
	struct snd_pcm_substream *substream;
	struct snd_dma_buffer *buf;
	int stream;

	pr_debug("Entered %s\n", __func__);

	for (stream = 0; stream < 2; stream++) {
		substream = pcm->streams[stream].substream;
		if (!substream)
			continue;

		buf = &substream->dma_buffer;
		if (!buf->area)
			continue;

		dma_free_writecombine(pcm->card->dev, buf->bytes,
				      buf->area, buf->addr);
		buf->area = NULL;
	}
}

static int dma_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_card *card = rtd->card->snd_card;
	struct snd_pcm *pcm = rtd->pcm;
	int ret;

	pr_debug("Entered %s\n", __func__);

	ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
	if (ret)
		return ret;

	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
		ret = preallocate_dma_buffer(pcm,
			SNDRV_PCM_STREAM_PLAYBACK);
		if (ret)
			goto out;
	}

	if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
		ret = preallocate_dma_buffer(pcm,
			SNDRV_PCM_STREAM_CAPTURE);
		if (ret)
			goto out;
	}
out:
	return ret;
}

static struct snd_soc_platform_driver samsung_asoc_platform = {
	.ops		= &dma_ops,
	.pcm_new	= dma_new,
	.pcm_free	= dma_free_dma_buffers,
};

void samsung_asoc_init_dma_data(struct snd_soc_dai *dai,
				struct s3c_dma_params *playback,
				struct s3c_dma_params *capture)
{
	snd_soc_dai_init_dma_data(dai, playback, capture);
}
EXPORT_SYMBOL_GPL(samsung_asoc_init_dma_data);

int samsung_asoc_dma_platform_register(struct device *dev)
{
	return snd_soc_register_platform(dev, &samsung_asoc_platform);
}
EXPORT_SYMBOL_GPL(samsung_asoc_dma_platform_register);

void samsung_asoc_dma_platform_unregister(struct device *dev)
{
	snd_soc_unregister_platform(dev);
}
EXPORT_SYMBOL_GPL(samsung_asoc_dma_platform_unregister);

MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
MODULE_DESCRIPTION("Samsung ASoC DMA Driver");
MODULE_LICENSE("GPL");


fz835304205
关注
专栏目录
Linux声卡驱动移植和测试
suaoyang的专栏
06-13 5859
一、分析驱动程序，根据开发板修改代码； 代码太长，就不贴了，几个注意点： 1、 查看开发板原理图和S3C2410的datasheet，UDA1341的L3MODE、L3DATA、L3CLOCK分别与S3C2410的GPB2、GPB3、GPB4相连，IISLRCK=GPE0, IISSCLK=GPE1, CDCLK=GPE2,IISSDI=GPE3, IISSDO=GPE4，部分代码如下:
linux声卡驱动源码,Linux声卡驱动移植和測试(示例代码)
weixin_31948907的博客
05-12 1091
一、分析驱动程序，依据开发板改动代码代码太长，就不贴了，几个注意点：1、查看开发板原理图和S3C2410的datasheet，UDA1341的L3MODE、L3DATA、L3CLOCK分别与S3C2410的GPB2、GPB3、GPB4相连。IISLRCK=GPE0, IISSCLK=GPE1, CDCLK=GPE2,IISSDI=GPE3, IISSDO=GPE4，部分代码例如以下:2、两个重...
31.Linux-wm9876声卡驱动(移植+测试)
weixin_34250709的博客
11-20 385
本节学习目的 1)分析Linux中的OSS声卡系统 2)移植wm9876声卡 3)使用madplay应用程序播放mp3   1.声音三要素 采样频率 音频采样率是指录音设备在一秒钟内对声音信号的采样次数, 常用的采样率有: 8KHz      - 电话所用采样率, 对于人的说话已经足够清除 22.05KHz - 无线电广播所用采样率 32KHz   -  min...
Linux声卡驱动移植和測试
weixin_34062469的博客
07-07 270
一、分析驱动程序，依据开发板改动代码 代码太长，就不贴了，几个注意点： 1、 查看开发板原理图和S3C2410的datasheet，UDA1341的L3MODE、L3DATA、L3CLOCK分别与S3C2410的GPB2、GPB3、GPB4相连。IISLRCK=GPE0, IISSCLK=GPE1, CDCLK=GPE2,IISSDI=GPE3, IISSDO=GPE4，部分代码例如以...
UDA1341在linux2.6.30上的移植 (2011-03-10 12:55)转载
fyyy4030的专栏
01-29 744
UDA1341在linux2.6.30上的移植 (2011-03-10 12:55)转载 标签: color style 分类： 音、视频驱动 1． 定义并添加声卡设备到系统平台设备初始化列表中 修改arch/arm/plat-s3c24xx/devs.c，添加如下内容 #include #include   /* UDA1341 */ static struct s
嵌入式Linux驱动教程(韦东山2期)
07-07
1.没有废话，句句都是干货！学习后保证可以跟着视频完成相应的实验。2.现场从0编写/调试工作中的绝大部分驱动，内容--- 理论 +
STM32】 DMA原理，步骤超细详解，一文看懂DMA
modi000的博客
03-19 6297
如需转载请注明地址：https://blog.csdn.net/as480133937/article/details/104927922 DMA的基本介绍 什么是DMA (DMA的基本定义) DMA，全称Direct Memory Access，即直接存储器访问。 DM...
nexus-3.15.2-01-linux.zip
04-11
在这个场景中，我们讨论的是Nexus在Linux环境下的安装和使用，主要涉及的文件是"nexus-3.15.2-01-unix.tar.gz"。 首先，我们来看"nexus-3.15.2-01-unix.tar.gz"这个文件。这是一个经过gzip压缩的tar归档文件，常见...
cmake-3.15.2-Linux-x86_64.tar.gz
最新发布
02-03
CMake-3.15.2-Linux-x86_64.tar.gz 是一个针对Linux x86_64架构的CMake版本3.15.2的打包文件。 这个压缩包包含了CMake的完整可执行文件和库，使得用户可以在本地环境中快速安装和使用CMake，而无需从源代码编译。...
cmake-3.15.2-Linux-x86_64.sh
02-03
cmake安装包
cmake-3.15.2-win32-x86.zip
08-13
CMake的这种特性使得开发者能够在Windows、Linux、Mac OS X等多个平台上进行一致的构建。 标题中的"cmake-3.15.2-win32-x86.zip"表示这是一个针对32位Windows系统的CMake版本3.15.2的压缩包文件。这个版本发布于...
nexus-3.15.2-win64.rar
11-05
nexus-3.15.2-win64.rar官网对应的最新版nexus私服包用于配置私服。要在局域网里找一台有外网权限的机器，搭建nexus私服，然后开发人员连到这台私服上，这样的话就可以通过这台搭建了nexus私服的电脑访问maven的远程...
一个DMA 分配失败问题研究
zjujoe的专栏
11-27 9763
 一个DMA 分配失败问题研究作者： 宋立新Email：zjujoe@yahoo.com现象：最近好几个模块的同事都反应驱动中调用：dma_alloc_writecombine 会失败！研究：首先重现该问题， 在 nand 驱动的 probe 函数：  pxa3xx_nand_probe 中调用 dma_alloc_writecombine: 测试代码：    #i
Linux 驱动之DMA 子系统
热门推荐
勇敢的蜗牛
04-01 1万+
DMA子是CPU中实现数据传输的一种方式,CPU配置好DMA控制器之后发起数据传输，CPU本身不参与数据传输的动作中去。DMA种类： 分为外设DMA和DMA控制器。其中外设DMA实现的为特定的外设与内存之间的数据传输，一般是外设向RAM单向传输数据。而DMA控制器则可以实现任意外设与内存之间的数据传输。此时外设跟CPU控制器之间通过流控制信号来保证传输通道的正常运行。DMA传输的数据宽度不固定。
linux驱动编写（声卡驱动之asoc移植）
嵌入式-老费，一个分享专业嵌入式知识的blog
04-07 3323
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】    Linux下面的声卡驱动很复杂，根本不是一篇博客能够说清楚的。所以，本片文章的目的就是让同学门快速入门。或者，换句话说，它可以帮助大家在基本了解linux声卡框架的条件下完成声卡移植工作。1、linux声卡驱动在哪个目录sound/2、oss、alsa、asoc是什么关系oss是最老的声卡...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值