解析下面程序: mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); chip->regs = devm_ioremap_resource(chip->dev, mem);
时间: 2024-05-30 14:14:40 浏览: 10
这段程序的作用是获取pdev设备的IORESOURCE_MEM资源,并将其映射到chip->regs变量上。其中,platform_get_resource用于获取pdev设备的资源,IORESOURCE_MEM表示资源类型为内存,0表示获取第一个IORESOURCE_MEM类型的资源。devm_ioremap_resource用于将资源映射到内存空间,并返回映射后的内存地址。
相关问题
linux adc_keys_probe函数代码分析
adc_keys_probe函数是Linux内核中用于处理ADC键盘的函数之一,它的主要作用是寻找并初始化设备。
代码如下:
static int adc_keys_probe(struct platform_device *pdev)
{
struct adc_keys *keys;
struct input_dev *input_dev;
struct resource *res;
int error;
keys = devm_kzalloc(&pdev->dev, sizeof(*keys), GFP_KERNEL);
if (!keys) {
dev_err(&pdev->dev, "Failed to allocate memory for adc_keys\n");
return -ENOMEM;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Failed to get memory resource\n");
return -ENODEV;
}
keys->regs = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(keys->regs)) {
dev_err(&pdev->dev, "Failed to ioremap memory\n");
return PTR_ERR(keys->regs);
}
error = adc_keys_init_pins(pdev, keys);
if (error) {
return error;
}
keys->irq = platform_get_irq(pdev, 0);
if (keys->irq < 0) {
dev_err(&pdev->dev, "Failed to get irq resource\n");
return keys->irq;
}
error = devm_request_irq(&pdev->dev, keys->irq, adc_keys_irq,
IRQ_TYPE_EDGE_FALLING, "adc_keys", keys);
if (error) {
dev_err(&pdev->dev, "Failed to request irq\n");
return error;
}
input_dev = devm_input_allocate_device(&pdev->dev);
if (!input_dev) {
dev_err(&pdev->dev, "Failed to allocate input device\n");
return -ENOMEM;
}
input_dev->name = "ADC Keys";
input_dev->phys = "adc_keys/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->dev.parent = &pdev->dev;
input_set_capability(input_dev, EV_KEY, KEY_POWER);
input_set_capability(input_dev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(input_dev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(input_dev, EV_KEY, KEY_HOME);
error = input_register_device(input_dev);
if (error) {
dev_err(&pdev->dev, "Failed to register input device\n");
return error;
}
platform_set_drvdata(pdev, keys);
return 0;
}
该函数主要包含以下步骤:
1. 使用devm_kzalloc函数分配一个结构体用于存储ADC键盘设备的信息;
2. 使用platform_get_resource函数获取并检查设备的内存资源;
3. 使用devm_ioremap_resource函数将设备内存映射到内核空间;
4. 使用adc_keys_init_pins函数初始化设备引脚;
5. 使用platform_get_irq函数获取设备的IRQ资源;
6. 使用devm_request_irq函数请求IRQ资源;
7. 使用devm_input_allocate_device函数分配一个input_dev结构体,用于表示输入设备;
8. 初始化输入设备,并注册到内核;
9. 设置设备特定数据,并将其保存在设备私有数据中;
10. 返回0或错误码。
总的来说,adc_keys_probe函数就是用于初始化ADC键盘设备的函数,它包含了许多重要的步骤,如分配内存空间、初始化设备引脚、获取IRQ资源等。在完成这些步骤之后,该函数会将输入设备注册到内核中,从而实现对设备的控制和数据输入。
linux XDMA驱动程序代码
下面是一个简单的 Linux XDMA 驱动程序的代码示例:
```
#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/io.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
// XDMA 寄存器的偏移量
#define XDMA_CTRL_OFFSET 0x00
#define XDMA_STATUS_OFFSET 0x04
#define XDMA_SRC_ADDR_OFFSET 0x08
#define XDMA_DEST_ADDR_OFFSET 0x0C
#define XDMA_TRANSFER_LEN_OFFSET 0x10
// XDMA 寄存器的位域定义
#define XDMA_CTRL_START_BIT 0
#define XDMA_CTRL_RESET_BIT 1
#define XDMA_STATUS_DONE_BIT 0
struct xdma_device {
struct platform_device *pdev;
void __iomem *regs;
dma_addr_t src_phys;
dma_addr_t dest_phys;
size_t len;
struct dma_chan *chan;
};
static void xdma_transfer_complete(void *arg)
{
struct xdma_device *dev = arg;
unsigned long flags;
spin_lock_irqsave(&dev->chan->lock, flags);
dma_cookie_complete(dev->chan, dev->cookie);
spin_unlock_irqrestore(&dev->chan->lock, flags);
}
static int xdma_transfer(struct xdma_device *dev)
{
int ret;
ret = dmaengine_prep_dma_memcpy(dev->chan, dev->dest_phys,
dev->src_phys, dev->len,
DMA_PREP_INTERRUPT |
DMA_CTRL_ACK);
if (ret < 0) {
dev_err(&dev->pdev->dev, "dmaengine_prep_dma_memcpy failed: %d\n", ret);
return ret;
}
dev->cookie = dmaengine_submit(dev->chan, &desc);
dma_async_issue_pending(dev->chan);
return 0;
}
static int xdma_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct xdma_device *xdma;
struct resource *res;
int ret;
xdma = devm_kzalloc(dev, sizeof(*xdma), GFP_KERNEL);
if (!xdma)
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
xdma->regs = devm_ioremap_resource(dev, res);
if (IS_ERR(xdma->regs))
return PTR_ERR(xdma->regs);
xdma->src_phys = dma_map_single(dev, xdma->src, xdma->len, DMA_TO_DEVICE);
if (dma_mapping_error(dev, xdma->src_phys)) {
dev_err(dev, "dma_map_single failed for source\n");
return -ENOMEM;
}
xdma->dest_phys = dma_map_single(dev, xdma->dest, xdma->len, DMA_FROM_DEVICE);
if (dma_mapping_error(dev, xdma->dest_phys)) {
dev_err(dev, "dma_map_single failed for destination\n");
ret = -ENOMEM;
goto unmap_src;
}
xdma->chan = dma_request_chan(dev, "dma0");
if (IS_ERR(xdma->chan)) {
dev_err(dev, "dma_request_chan failed\n");
ret = PTR_ERR(xdma->chan);
goto unmap_dest;
}
ret = xdma_transfer(xdma);
if (ret < 0) {
dev_err(dev, "xdma_transfer failed: %d\n", ret);
goto release_chan;
}
return 0;
release_chan:
dma_release_channel(xdma->chan);
unmap_dest:
dma_unmap_single(dev, xdma->dest_phys, xdma->len, DMA_FROM_DEVICE);
unmap_src:
dma_unmap_single(dev, xdma->src_phys, xdma->len, DMA_TO_DEVICE);
return ret;
}
static int xdma_remove(struct platform_device *pdev)
{
struct xdma_device *xdma = platform_get_drvdata(pdev);
dmaengine_terminate_all(xdma->chan);
dma_release_channel(xdma->chan);
dma_unmap_single(&pdev->dev, xdma->dest_phys, xdma->len, DMA_FROM_DEVICE);
dma_unmap_single(&pdev->dev, xdma->src_phys, xdma->len, DMA_TO_DEVICE);
return 0;
}
static const struct of_device_id xdma_of_match[] = {
{ .compatible = "xlnx,axi-dma-1.00.a", },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, xdma_of_match);
static struct platform_driver xdma_driver = {
.driver = {
.name = "xdma",
.of_match_table = xdma_of_match,
},
.probe = xdma_probe,
.remove = xdma_remove,
};
module_platform_driver(xdma_driver);
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple XDMA Driver");
MODULE_LICENSE("GPL");
```
请注意,上述代码只是一个简单的示例,可能需要针对您的特定硬件进行修改和调整。建议您仔细阅读 Linux DMA 引擎的文档以及您的硬件的数据手册。