linux驱动resume

① linux触摸屏驱动中什么时候会调用suspend这个函数

android系统摁下电源键后会让系统进入休眠以达到节电的目的。内核驱动中和休眠相关的就是suspend和resume函数。

suspend函数用于休眠，resume函数用于唤醒。下面分析驱动中的这两个函数是如何被调用到的。

驱动部分：

首先需要分析驱动的注册过程，较新的内核都是采用DTS方式来取代在内核中直接定义platform_device数据结构的注册方式，本文是基于DTS机制的内核来分析。

proct对应的dts文件在编译时被编译为dtb文件，uboot在启动时候会将其地址传给内核，内核在启动过程中会去解析，具体解析是在start_kernel()->setup_arch() --> unflatten_device_tree()中具体分析可以参考网上，解析的最终结果会存放在allnodes地址处，这个allnodes随后在machine的init函数
中被使用，init函数中会根据allnodes中的节点数据组合成platform_device数据结构，然后将其注册到platform总线上，下面简要分析一下并重点关注这些初始化过程中和
pm相关的初始化。

我参与的项目中machine的init函数就是via_init_machine函数，在这个函数中就是调用了of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL)这个函数来解析allnodes的。of_platform_populate是系统提供的接口。下面分析这个接口的实现：

[html] view plain
int of_platform_populate(struct device_node *root,
const struct of_device_id *matches,
const struct of_dev_auxdata *lookup,
struct device *parent)
{
struct device_node *child;
int rc = 0;

root = root ? of_node_get(root) : of_find_node_by_path("/");
if (!root)
return -EINVAL;

for_each_child_of_node(root, child) {
rc = of_platform_bus_create(child, matches, lookup, parent, true);
if (rc)
break;
}

of_node_put(root);
return rc;
}
root最后就是取到的根节点，然后其作为参数传递给of_platform_bus_create，of_platform_device_create_pdata的实现如下：

[html] view plain
static int of_platform_bus_create(struct device_node *bus,
const struct of_device_id *matches,
const struct of_dev_auxdata *lookup,
struct device *parent, bool strict)
{
const struct of_dev_auxdata *auxdata;
struct device_node *child;
struct platform_device *dev;
const char *bus_id = NULL;
void *platform_data = NULL;
int rc = 0;

/* Make sure it has a compatible property */
if (strict && (!of_get_property(bus, "compatible", NULL))) {
pr_debug("%s() - skipping %s, no compatible prop\n",
__func__, bus->full_name);
return 0;
}

auxdata = of_dev_lookup(lookup, bus);
if (auxdata) {
bus_id = auxdata->name;
platform_data = auxdata->platform_data;
}

if (of_device_is_compatible(bus, "arm,primecell")) {
of_amba_device_create(bus, bus_id, platform_data, parent);
return 0;
}

dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
if (!dev || !of_match_node(matches, bus))
return 0;

for_each_child_of_node(bus, child) {
pr_debug(" create child: %s\n", child->full_name);
rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
if (rc) {
of_node_put(child);
break;
}
}
return rc;
}
根据传入参数，我们这里直接分析of_platform_device_create_padate函数，如下:

[html] view plain
struct platform_device *of_platform_device_create_pdata(
struct device_node *np,
const char *bus_id,
void *platform_data,
struct device *parent)
{
struct platform_device *dev;

if (!of_device_is_available(np))
return NULL;

dev = of_device_alloc(np, bus_id, parent);
if (!dev)
return NULL;

#if defined(CONFIG_MICROBLAZE)
dev->archdata.dma_mask = 0xffffffffUL;
#endif
dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
dev->dev.bus = &platform_bus_type;
dev->dev.platform_data = platform_data;

/* We do not fill the DMA ops for platform devices by default.
* This is currently the responsibility of the platform code
* to do such, possibly using a device notifier
*/

if (of_device_add(dev) != 0) {
platform_device_put(dev);
return NULL;
}

return dev;
}

of_platform_device_create_padate->of_device_alloc->platform_device_alloc

便在platform_device_alloc函数中进行进行alloc和初始化了，实现如下：

[html] view plain
struct platform_device *platform_device_alloc(const char *name, int id)
{
struct platform_object *pa;

pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
if (pa) {
strcpy(pa->name, name);
pa->pdev.name = pa->name;
pa->pdev.id = id;
device_initialize(&pa->pdev.dev);
pa->pdev.dev.release = platform_device_release;
arch_setup_pdev_archdata(&pa->pdev);
}

return pa ? &pa->pdev : NULL;
}
可以看到有个device_initialize，这里面对pdev.dev做一些列的初始化，其中有一个函数就是device_pm_init，这个函数就是我们一直关心的device相关的pm函数，具体实现如下：

[html] view plain
void device_pm_init(struct device *dev)
{
dev->power.is_prepared = false;
dev->power.is_suspended = false;
init_completion(&dev->power.completion);
complete_all(&dev->power.completion);
dev->power.wakeup = NULL;
spin_lock_init(&dev->power.lock);
pm_runtime_init(dev);
INIT_LIST_HEAD(&dev->power.entry);
dev->power.power_state = PMSG_INVALID;
}

可以看见它对device和功耗相关的数据做了一些初始化，我们这里先重点关注下dev->power.entry，初始化一个链表头，所以他/它很有可能会在后面加到某个链表里面去，而那个链表应该是用来保存所有的device用的。系统中所有的platform_device都是通过这种方式注册到系统中的，那么应该所有的platform_device都会初始化一个dev->power.entry，如果到时候把所有的dev->power.entry都添加到某个链表上去，那么系统到时候查询的时候只要找到这个list head就可以找到所有的platform_device了。嗯，不过这是我们的猜测。我们接下去分析来验证下。

platform_device通过alloc之后已经初始化好了，那么接下去就可以添加到系统中了，所以我们再回头看of_platform_device_create_pdata的实现。
函数在of_device_alloc之后把dev->dev.bus赋值给了platform_bus_type，接着就调用了of_device_add函数，在of_device_add函数中最后通过device_add添加到了bus上，但是device_add中有个函数需要我们关系，就是device_pm_add(dev)，实现如下：

[html] view plain
void device_pm_add(struct device *dev)
{
pr_debug("PM: Adding info for %s:%s\n",
dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
mutex_lock(&dpm_list_mtx);
if (dev->parent && dev->parent->power.is_prepared)
dev_warn(dev, "parent %s should not be sleeping\n",
dev_name(dev->parent));
list_add_tail(&dev->power.entry, &dpm_list);
dev_pm_qos_constraints_init(dev);
mutex_unlock(&dpm_list_mtx);
}

可以看到这里list_add_tail(&dev->power.entry, &dpm_list);这就验证了我们之前的猜测。所有注册到系统中的设备，最终都是会添加到dpm_list这条链表上。

那么系统在休眠的时候是如何通过dmp_list这表链表来suspend设备的呢？接下去就是我们要分析的电源管理部分内容。

系统电源部分：
电源管理相关文件在kernel/power目录下，前面已经分析到。系统中注册的设备都是会添加到dmp_list这条链表上的。那么睡眠的时候系统应该是会查找dmp_list这条链表，
然后通过这条链表依次去查到对应的driver，然后调用driver中的suspend方法。下面我们来验证。

2.在suspend会轮询bus下的driver，然后一次调用到driver->pm->suspend方法，然后进入休眠。

3.state_store->pm_suspend->enter_state->suspend_devices_and_enter->dpm_suspend_start->dpm_suspend->device_suspend->__device_suspend->pm_op->(ops->suspend)

② 如何编写Linux 驱动程序

以装载和卸载模块为例：

1、首先输入代码

#include <linux/init.h>

#include <linux/mole.h>

③ linux重启网卡驱动 命令

在实际工作中，经常会遇到Linux系统进行重启网卡的操作。在这里整理一下，进行多种方法的网卡重启。
一、service network restart
1、首先用CRT工具连接到Linux命令行界面。 或者进入操作系统界面，选择终端输入。
2、如果我们对所有的网卡进行重启操作。 可以尝试输入：service network restart 命令进行操作。
3、样就完成了用service network restart命令重启网卡的操作。
二、ifconfig eth0 down / ifconfig eth0 up
1、连接到命令行界面，输入ifconfig查看网卡的基本信息。
2、查看到eth3的网卡信息。 输入ifconfig eth3 down ,卸载eth3网卡。
3、输入ifconfig eth3 up,重新加载eth3网卡。
三、ifdown eth0 / ifup eth0
1、连接到命令行界面。输入ifdown eth3,对网卡eth3进行卸载。
2、输入ifup eth3,对网卡eth3进行重新加载。
3、这样就完成了对网卡的重启操作。

④ 如何写linux pci设备驱动程序

Linux下PCI设备驱动开发
1. 关键数据结构
PCI设备上有三种地址空间：PCI的I/O空间、PCI的存储空间和PCI的配置空间。CPU可以访问PCI设备上的所有地址空间，其中I/O空间和存储空间提供给设备驱动程序使用，而配置空间则由Linux内核中的PCI初始化代码使用。内核在启动时负责对所有PCI设备进行初始化，配置好所有的PCI设备，包括中断号以及I/O基址，并在文件/proc/pci中列出所有找到的PCI设备，以及这些设备的参数和属性。
Linux驱动程序通常使用结构（struct）来表示一种设备，而结构体中的变量则代表某一具体设备，该变量存放了与该设备相关的所有信息。好的驱动程序都应该能驱动多个同种设备，每个设备之间用次设备号进行区分，如果采用结构数据来代表所有能由该驱动程序驱动的设备，那么就可以简单地使用数组下标来表示次设备号。
在PCI驱动程序中，下面几个关键数据结构起着非常核心的作用：
pci_driver
这个数据结构在文件include/linux/pci.h里，这是Linux内核版本2.4之后为新型的PCI设备驱动程序所添加的，其中最主要的是用于识别设备的id_table结构，以及用于检测设备的函数probe( )和卸载设备的函数remove( )：
struct pci_driver {
struct list_head node;
char *name;
const struct pci_device_id *id_table;
int (*probe) (struct pci_dev *dev, const struct pci_device_id *id);
void (*remove) (struct pci_dev *dev);
int (*save_state) (struct pci_dev *dev, u32 state);
int (*suspend)(struct pci_dev *dev, u32 state);
int (*resume) (struct pci_dev *dev);
int (*enable_wake) (struct pci_dev *dev, u32 state, int enable);
};
pci_dev
这个数据结构也在文件include/linux/pci.h里，它详细描述了一个PCI设备几乎所有的
硬件信息，包括厂商ID、设备ID、各种资源等：
struct pci_dev {
struct list_head global_list;
struct list_head bus_list;
struct pci_bus *bus;
struct pci_bus *subordinate;
void *sysdata;
struct proc_dir_entry *procent;
unsigned int devfn;
unsigned short vendor;
unsigned short device;
unsigned short subsystem_vendor;
unsigned short subsystem_device;
unsigned int class;
u8 hdr_type;
u8 rom_base_reg;
struct pci_driver *driver;
void *driver_data;
u64 dma_mask;
u32 current_state;
unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];
unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];
unsigned int irq;
struct resource resource[DEVICE_COUNT_RESOURCE];
struct resource dma_resource[DEVICE_COUNT_DMA];
struct resource irq_resource[DEVICE_COUNT_IRQ];
char name[80];
char slot_name[8];
int active;
int ro;
unsigned short regs;
int (*prepare)(struct pci_dev *dev);
int (*activate)(struct pci_dev *dev);
int (*deactivate)(struct pci_dev *dev);
};
2. 基本框架
在用模块方式实现PCI设备驱动程序时，通常至少要实现以下几个部分：初始化设备模块、设备打开模块、数据读写和控制模块、中断处理模块、设备释放模块、设备卸载模块。下面给出一个典型的PCI设备驱动程序的基本框架，从中不难体会到这几个关键模块是如何组织起来的。
/* 指明该驱动程序适用于哪一些PCI设备 */
static struct pci_device_id demo_pci_tbl [] __initdata = {
{PCI_VENDOR_ID_DEMO, PCI_DEVICE_ID_DEMO,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEMO},
{0,}
};
/* 对特定PCI设备进行描述的数据结构 */
struct demo_card {
unsigned int magic;
/* 使用链表保存所有同类的PCI设备 */
struct demo_card *next;
/* ... */
}
/* 中断处理模块 */
static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
/* ... */
}
/* 设备文件操作接口 */
static struct file_operations demo_fops = {
owner: THIS_MODULE, /* demo_fops所属的设备模块 */
read: demo_read, /* 读设备操作*/
write: demo_write, /* 写设备操作*/
ioctl: demo_ioctl, /* 控制设备操作*/
mmap: demo_mmap, /* 内存重映射操作*/
open: demo_open, /* 打开设备操作*/
release: demo_release /* 释放设备操作*/
/* ... */
};
/* 设备模块信息 */
static struct pci_driver demo_pci_driver = {
name: demo_MODULE_NAME, /* 设备模块名称 */
id_table: demo_pci_tbl, /* 能够驱动的设备列表 */
probe: demo_probe, /* 查找并初始化设备 */
remove: demo_remove /* 卸载设备模块 */
/* ... */
};
static int __init demo_init_mole (void)
{
/* ... */
}
static void __exit demo_cleanup_mole (void)
{
pci_unregister_driver(&demo_pci_driver);
}
/* 加载驱动程序模块入口 */
mole_init(demo_init_mole);
/* 卸载驱动程序模块入口 */
mole_exit(demo_cleanup_mole);
上面这段代码给出了一个典型的PCI设备驱动程序的框架，是一种相对固定的模式。需要注意的是，同加载和卸载模块相关的函数或数据结构都要在前面加上__init、__exit等标志符，以使同普通函数区分开来。构造出这样一个框架之后，接下去的工作就是如何完成框架内的各个功能模块了。
3. 初始化设备模块
在Linux系统下，想要完成对一个PCI设备的初始化，需要完成以下工作：
检查PCI总线是否被Linux内核支持；
检查设备是否插在总线插槽上，如果在的话则保存它所占用的插槽的位置等信息。
读出配置头中的信息提供给驱动程序使用。
当Linux内核启动并完成对所有PCI设备进行扫描、登录和分配资源等初始化操作的同时，会建立起系统中所有PCI设备的拓扑结构，此后当PCI驱动程序需要对设备进行初始化时，一般都会调用如下的代码：
static int __init demo_init_mole (void)
{
/* 检查系统是否支持PCI总线 */
if (!pci_present())
return -ENODEV;
/* 注册硬件驱动程序 */
if (!pci_register_driver(&demo_pci_driver)) {
pci_unregister_driver(&demo_pci_driver);
return -ENODEV;
}
/* ... */
return 0;
}
驱动程序首先调用函数pci_present( )检查PCI总线是否已经被Linux内核支持，如果系统支持PCI总线结构，这个函数的返回值为0，如果驱动程序在调用这个函数时得到了一个非0的返回值，那么驱动程序就必须得中止自己的任务了。在2.4以前的内核中，需要手工调用pci_find_device( )函数来查找PCI设备，但在2.4以后更好的办法是调用pci_register_driver( )函数来注册PCI设备的驱动程序，此时需要提供一个pci_driver结构，在该结构中给出的probe探测例程将负责完成对硬件的检测工作。
static int __init demo_probe(struct pci_dev *pci_dev, const struct
pci_device_id *pci_id)
{
struct demo_card *card;
/* 启动PCI设备 */
if (pci_enable_device(pci_dev))
return -EIO;
/* 设备DMA标识 */
if (pci_set_dma_mask(pci_dev, DEMO_DMA_MASK)) {
return -ENODEV;
}
/* 在内核空间中动态申请内存 */
if ((card = kmalloc(sizeof(struct demo_card), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "pci_demo: out of memory\n");
return -ENOMEM;
}
memset(card, 0, sizeof(*card));
/* 读取PCI配置信息 */
card->iobase = pci_resource_start (pci_dev, 1);
card->pci_dev = pci_dev;
card->pci_id = pci_id->device;
card->irq = pci_dev->irq;
card->next = devs;
card->magic = DEMO_CARD_MAGIC;
/* 设置成总线主DMA模式 */
pci_set_master(pci_dev);
/* 申请I/O资源 */
request_region(card->iobase, 64, card_names[pci_id->driver_data]);
return 0;
}
4. 打开设备模块
在这个模块里主要实现申请中断、检查读写模式以及申请对设备的控制权等。在申请控制权的时候，非阻塞方式遇忙返回，否则进程主动接受调度，进入睡眠状态，等待其它进程释放对设备的控制权。
static int demo_open(struct inode *inode, struct file *file)
{
/* 申请中断，注册中断处理程序 */
request_irq(card->irq, &demo_interrupt, SA_SHIRQ,
card_names[pci_id->driver_data], card)) {
/* 检查读写模式 */
if(file->f_mode & FMODE_READ) {
/* ... */
}
if(file->f_mode & FMODE_WRITE) {
/* ... */
}
/* 申请对设备的控制权 */
down(&card->open_sem);
while(card->open_mode & file->f_mode) {
if (file->f_flags & O_NONBLOCK) {
/* NONBLOCK模式，返回-EBUSY */
up(&card->open_sem);
return -EBUSY;
} else {
/* 等待调度，获得控制权 */
card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);
up(&card->open_sem);
/* 设备打开计数增1 */
MOD_INC_USE_COUNT;
/* ... */
}
}
}
5. 数据读写和控制信息模块
PCI设备驱动程序可以通过demo_fops 结构中的函数demo_ioctl( )，向应用程序提供对硬件进行控制的接口。例如，通过它可以从I/O寄存器里读取一个数据，并传送到用户空间里：
static int demo_ioctl(struct inode *inode, struct file *file, unsigned int
cmd, unsigned long arg)
{
/* ... */
switch(cmd) {
case DEMO_RDATA:
/* 从I/O端口读取4字节的数据 */
val = inl(card->iobae + 0x10);
/* 将读取的数据传输到用户空间 */
return 0;
}
/* ... */
}
事实上，在demo_fops里还可以实现诸如demo_read( )、demo_mmap( )等操作，Linux内核源码中的driver目录里提供了许多设备驱动程序的源代码，找那里可以找到类似的例子。在对资源的访问方式上，除了有I/O指令以外，还有对外设I/O内存的访问。对这些内存的操作一方面可以通过把I/O内存重新映射后作为普通内存进行操作，另一方面也可以通过总线主DMA（Bus Master DMA）的方式让设备把数据通过DMA传送到系统内存中。
6. 中断处理模块
PC的中断资源比较有限，只有0~15的中断号，因此大部分外部设备都是以共享的形式申请中断号的。当中断发生的时候，中断处理程序首先负责对中断进行识别，然后再做进一步的处理。
static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct demo_card *card = (struct demo_card *)dev_id;
u32 status;
spin_lock(&card->lock);
/* 识别中断 */
status = inl(card->iobase + GLOB_STA);
if(!(status & INT_MASK))
{
spin_unlock(&card->lock);
return; /* not for us */
}
/* 告诉设备已经收到中断 */
outl(status & INT_MASK, card->iobase + GLOB_STA);
spin_unlock(&card->lock);
/* 其它进一步的处理，如更新DMA缓冲区指针等 */
}
7. 释放设备模块
释放设备模块主要负责释放对设备的控制权，释放占用的内存和中断等，所做的事情正好与打开设备模块相反：
static int demo_release(struct inode *inode, struct file *file)
{
/* ... */
/* 释放对设备的控制权 */
card->open_mode &= (FMODE_READ | FMODE_WRITE);
/* 唤醒其它等待获取控制权的进程 */
wake_up(&card->open_wait);
up(&card->open_sem);
/* 释放中断 */
free_irq(card->irq, card);
/* 设备打开计数增1 */
MOD_DEC_USE_COUNT;
/* ... */
}
8. 卸载设备模块
卸载设备模块与初始化设备模块是相对应的，实现起来相对比较简单，主要是调用函数pci_unregister_driver( )从Linux内核中注销设备驱动程序：
static void __exit demo_cleanup_mole (void)
{
pci_unregister_driver(&demo_pci_driver);
}
小结
PCI总线不仅是目前应用广泛的计算机总线标准，而且是一种兼容性最强、功能最全的计算机总线。而Linux作为一种新的操作系统，其发展前景是无法估量的，同时也为PCI总线与各种新型设备互连成为可能。由于Linux源码开放，因此给连接到PCI总线上的任何设备编写驱动程序变得相对容易。本文介绍如何编译Linux下的PCI驱动程序，针对的内核版本是2.4。

⑤ linux 安装了驱动后，怎么运行驱动

linux的驱动一般有两种格式，分别为：tar和rpm格式。
rpm安装步骤：

1．将驱动程序文件bcm5700-.src.rpm复制到一个临时目录中，并在此目录中运行以下命令：
rpm –ivh bcm5700-.src.rpm
2．运行以下命令切换到驱动目录中：
cd /usr/src/redhat/SPECS/
3．此目录中会生成一个名字为bcm5700.spec的文件，运行以下命令对驱动程序进行编译：
rpmbuild –bb bcm5700.spec （对4.x.x版本的RPM适用）或 rpm -bb bcm5700.spec
4．运行以下命令切换到RPM目录中：
cd /usr/src/redhat/RPMS/i386/
5．运行以下命令安装驱动程序：
rpm –ivh bcm5700-.i386.rpm （对于Red Hat 7.2, 7.3, 2.1AS和其他包含老版本驱动的系统需要使用--force的参数，强制用新的驱动替换系统自带的老版本驱动）
6．运行以下命令加载驱动模块：
insmod bcm5700
7．运行kudzu命令，系统会自动搜索到硬件，进行配置即可。
或者重新启动系统，启动过程中系统会自动找到硬件，进行相应配置即可。
tar格式安装步骤：
1. 将驱动程序压缩文件bcm5700-.tar.gz复制到一个临时目录中，并使用以下命令解压缩：
tar xvzf bcm5700-.tar.gz
2．构建驱动程序为运行内核可加载模块
cd bcm5700-/src
make
3．加载测试
insmod bcm5700
4．加载驱动程序
make install
5．重新启动系统，启动过程中找到硬件，进行相应配置。
或者直接运行kudzu命令，系统会自动搜索到硬件，进行配置即可。

⑥ 如何在Android 或Linux 下，做Suspend /Resume 的Debug

在Linux或Android下，做power management 的调适时，常遇到没有足够的information，可以做为debug时的依据和参考

我们整理了几个常用的参数或Command，可供设计者，得到足够的Informaiton 做Suspend / Resume的function Debug。

加boot 参数 no_console_suspend
基本上我们常常使用console做为suspend function的debug的Information source，但原始的source code在suspend过程中，会将console关掉。所以我们看到一定程度後就再也看不到message了。

但是我们并不知道在Suspend的过程中，系统到底发生了什麼事，可能造成无法suspend。
为此，我们就会在kernel 启动参数中加上no_console_suspend这个参数。在AM/DM37x APM中是修改boot.scr档案参数
#!/bin/sh
cat <<EOF > boot.cmd
if fatload mmc 0 82000000 uImage
then
echo ***** Kernel: /dev/mmcblk0p1/uImage *****
fi
echo ***** RootFS: /dev/mmcblk0p2 *****
# Pantherboard DVI output
#setenv bootargs 'console=ttyO2,115200n8 androidboot.console=ttyO2 mem=512M root=/dev/mmcblk0p2 rw rootfstype=ext3 rootdelay=1 init=/init ip=off omap_vout.vid1_static_vrfb_alloc=y omapdss.def_disp=dvi vram=32M omapfb.mode=dvi:1280x720MR-32 omapfb.vram=0:16M mpurate=1000'
# Pantherboard LCD output
setenv bootargs 'console=ttyO2,115200n8 androidboot.console=ttyO2 mem=512M root=/dev/mmcblk0p2 rw rootfstype=ext3 rootdelay=1 init=/init ip=off omap_vout.vid1_static_vrfb_alloc=y omapdss.def_disp=lcd omapfb.mode=lcd:800x480MR-32 vram=8M omapfb.vram=0:8M mpurate=1000'

将no_console_suspend加上去到boot 参数後就好了

setenv bootargs 'console=ttyO2,115200n8 androidboot.console=ttyO2 mem=512M root=/dev/mmcblk0p2 rw rootfstype=ext3 rootdelay=1 init=/init ip=off omap_vout.vid1_static_vrfb_alloc=y omapdss.def_disp=lcd omapfb.mode=lcd:800x480MR-32 vram=8M omapfb.vram=0:8M mpurate=1000 no_console_suspend'

如果是OMAP4 APM的话，请修改Kernel 参数的所在档案即可(在U-boot Source code中)

这个是基本的参数，所以在Android或Linux上都可以使用。 kernel把console suspend掉以後， 不管里面出了什麼事情， 在Console上都看不到。 而使用这个参数後，大部分在suspend/resume时候的死机都可以通过Console看到kernel Panic的信息， 这样我们才会知道是哪里出了问题。 因为有的时候resume出错， 或者suspend到很後面出错的console不加这个参数都看不到。

但这个参数在TI OMAP3/OMAP4/AM37x/DM37x有可能造成有时Suspend 完当掉或是resume 失败的问题，假如已经抓到问题在那的时候，您就可以将这个参数Disable，不然很可能就会Debug不下去。

initcall_debug
这个同样kernel参数，使用的时机是，当我们不知道是那个driver在suspend/resume过程中出错的时候，可以使用这个参数来找出问题所在。在下完这个参数後，Kernel在suspend时，会将每个driver或task的状况report出来。我们可以藉由这些information，Check 在suspend时，每个task和driver是否已经完成进suspend 的相关准备工作…

打开这个参数的方法有二种
一种是在console下Command，启动这个function…

echo 1 > /sys/mole/kernel/parameters/initcall_debug
echo 9 > /proc/sys/kernel/printk

其中上面的第一条命令是打开initcall_debug， 这个是所有的kernel都会有的。

而第二条命令是要提高kernel message 级别，因为initcall的这些信息都是KERN_DEBUG级别的， 所以需要提高printk的级别才可以看到， 要不然suspend/resume的时候挂了，你就没有机会看到这些信息了。

另一种启动方法是写在kernel的启动参数下，就可以了。

setenv bootargs 'console=ttyO2,115200n8 androidboot.console=ttyO2 mem=512M root=/dev/mmcblk0p2 rw rootfstype=ext3 rootdelay=1 init=/init ip=off omap_vout.vid1_static_vrfb_alloc=y omapdss.def_disp=lcd omapfb.mode=lcd:800x480MR-32 vram=8M omapfb.vram=0:8M mpurate=1000 initcall_debug no_console_suspend'

同样的，这个参数也有可能造成AM37x/DM37x/OMAP4 APM发生进suspend当掉的问题。所以一旦知道问题所在，麻烦请将这个参数Disable掉。
suspend_test
这个方法可以用rtc这种软件的方式来做循环的suspend/resume， 尽管对於Android这样并不是很足够， （还要再模拟一个POWER_KEY上去才够）， 但是对於测试Driver的稳定性， 还是有一定用处的。不要认为suspend了几次可以，那麼就可以通过几千次的测试。这个suspend是5秒钟用RTC唤醒，然後回到Android後5秒钟又会自动睡下去，但是对於通用Linux，你可以写个script来让他起来一会再睡下去，或许这个工具比较有用rtcwakeup（google rtcwakeup)。

使用方法：
编译一个有这个功能的kernel， make menuconfig 以後选上

CONFIG_PM_DEBUG=y
CONFIG_PM_TEST_SUSPEND=y

这两个选项，烧写新的kernel，然後打开你需要测试的Device， 比如WIFI，3G

echo "core" > /sys/power/pm_test
echo "mem" > /sys/power/state

这样， 它就会循环休眠和唤醒了。

wakelock
Android和Linux在Power Management相关的最大的就是wakelock机制的有无。Android有时候会碰到suspend进不去，或者suspend到最後又莫名奇妙的wake up的问题。这些都有可能是wakelock引起的，或者说是wakelock的使用者引起的。怎麼fine tune呢，使用Console在Android 系统下设定：
echo 15 > /sys/mole/wakelock/parameters/debug_mask
echo 15 > /sys/mole/userwakelock/parameters/debug_mask

15是代表16进制的F， 在wakelock里面就是把所有的debug信息打开， 起码现在是这样设定的。如果以後不够用了，可能就会改成255.
这样你能看到kernel和frameworks层对於wakelock的操作、申请及释放。这样看申请和释放成对否就可以了。
注意： wakelock有一种是timeout的，就是说多少毫秒以後，会自动释放，对於这些wakelock，申请和释放可能是不成对的。

power.0
有时看到系统suspend到了最後， 然後遇到power.0後suspend失败，然後整个系统又resume回来。这个是android专有的，因为power.0是android注册到suspend最後的一个行程， 它会在CPU进入suspend之前检查一下有没有wakelock存在， 如果这时候还有没有释放的wakelock， 那麼它会return -EBUSY然後导致整个suspend失败。 Check这个问题的方法就是把上面wakelock的debug信息打开，然後看看是哪个去申请了wakelock，然後Release它。

这个错误的错误信息大概是这样的：

pm_noirq_op(): platform_pm_suspend_noirq+0x0/0x38 returns -11
PM: Device power.0 failed to suspend late: error -11

earlysuspend
在android里面中另外一个和Power Management有相关的机制叫earlysuspend， 同样可以打开debug message，用来做Android earlysuspend debug之用：
echo 15 > /sys/mole/earlysuspend/parameters/debug_mask

来把相关的debug信息印出来， 例如那个earlysuspend要被call之类的。
suspend/resume 时间 fine tune
有的时候你要调试suspend/resume的时间太慢的问题。 一种方法是用initcall_debug， 然後把printk的时间戳打上， 然後看那个process最慢，再来Check原因是什麼
我有一个patch，专门用来调试这个问题的，但是upstream不接受， 说非要用这种折磨人的方法才行， 但是如果你想用可以下下来打上去用一下。
地址在这里:http://www.spinics.net/lists/linux-pm/msg24063.html
用法是, 打上这个PATCH以後, 在KERNEL里面选择上PM_DEBUG， SUSPEND_DEVICE_TIME_DEBUG 这两个选项。
然後
echo 微秒> /sys/power/device_suspend_time_threshold

比如
echo 50000 > /sys/power/device_suspend_time_threshold

注意这里是微秒哦。 。 。 它会把在suspend/resume的时候慢的那些driver打出来，然後你去干掉它。 。

⑦ 怎样写linux下的USB设备驱动程序

写一个USB的驱动程序最 基本的要做四件事：驱动程序要支持的设备、注册USB驱动程序、探测和断开、提交和控制urb（USB请求块）
驱动程序支持的设备：有一个结构体struct usb_device_id，这个结构体提供了一列不同类型的该驱动程序支持的USB设备，对于一个只控制一个特定的USB设备的驱动程序来说，struct usb_device_id表被定义为：
/* 驱动程序支持的设备列表 */
static struct usb_device_id skel_table [] = {
{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
{ } /* 终止入口 */
};
MODULE_DEVICE_TABLE (usb, skel_table);
对 于PC驱动程序，MODULE_DEVICE_TABLE是必需的，而且usb必需为该宏的第一个值，而USB_SKEL_VENDOR_ID和 USB_SKEL_PRODUCT_ID就是这个特殊设备的制造商和产品的ID了，我们在程序中把定义的值改为我们这款USB的，如：
/* 定义制造商和产品的ID号 */
#define USB_SKEL_VENDOR_ID 0x1234
#define USB_SKEL_PRODUCT_ID 0x2345
这两个值可以通过命令lsusb，当然你得先把USB设备先插到主机上了。或者查看厂商的USB设备的手册也能得到，在我机器上运行lsusb是这样的结果：
Bus 004 Device 001: ID 0000:0000
Bus 003 Device 002: ID 1234:2345 Abc Corp.
Bus 002 Device 001: ID 0000:0000
Bus 001 Device 001: ID 0000:0000
得到这两个值后把它定义到程序里就可以了。
注册USB驱动程序：所 有的USB驱动程序都必须创建的结构体是struct usb_driver。这个结构体必须由USB驱动程序来填写，包括许多回调函数和变量，它们向USB核心代码描述USB驱动程序。创建一个有效的 struct usb_driver结构体，只须要初始化五个字段就可以了，在框架程序中是这样的：
static struct usb_driver skel_driver = {
.owner = THIS_MODULE,
.name = "skeleton",
.probe = skel_probe,
.disconnect = skel_disconnect,
.id_table = skel_table,
};
探测和断开：当 一个设备被安装而USB核心认为该驱动程序应该处理时，探测函数被调用，探测函数检查传递给它的设备信息，确定驱动程序是否真的适合该设备。当驱动程序因 为某种原因不应该控制设备时，断开函数被调用，它可以做一些清理工作。探测回调函数中，USB驱动程序初始化任何可能用于控制USB设备的局部结构体，它 还把所需的任何设备相关信息保存到一个局部结构体中，
提交和控制urb：当驱动程序有数据要发送到USB设备时（大多数情况是在驱动程序的写函数中），要分配一个urb来把数据传输给设备：
/* 创建一个urb,并且给它分配一个缓存*/
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb) {
retval = -ENOMEM;
goto error;
}
当urb被成功分配后，还要创建一个DMA缓冲区来以高效的方式发送数据到设备，传递给驱动程序的数据要复制到这块缓冲中去：
buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
if (!buf) {
retval = -ENOMEM;
goto error;
}

if (_from_user(buf, user_buffer, count)) {
retval = -EFAULT;
goto error;
}
当数据从用户空间正确复制到局部缓冲区后，urb必须在可以被提交给USB核心之前被正确初始化：
/* 初始化urb */
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
buf, count, skel_write_bulk_callback, dev);
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
然后urb就可以被提交给USB核心以传输到设备了：
/* 把数据从批量OUT端口发出 */
retval = usb_submit_urb(urb, GFP_KERNEL);
if (retval) {
err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);
goto error;
}
当urb被成功传输到USB设备之后，urb回调函数将被USB核心调用，在我们的例子中，我们初始化urb，使它指向skel_write_bulk_callback函数，以下就是该函数：
static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs)
{
struct usb_skel *dev;

dev = (struct usb_skel *)urb->context;

if (urb->status &&
!(urb->status == -ENOENT ||
urb->status == -ECONNRESET ||
urb->status == -ESHUTDOWN)) {
dbg("%s - nonzero write bulk status received: %d",
__FUNCTION__, urb->status);
}

/* 释放已分配的缓冲区 */
usb_buffer_free(urb->dev, urb->transfer_buffer_length,
urb->transfer_buffer, urb->transfer_dma);
}
有时候USB驱动程序只是要发送或者接收一些简单的数据，驱动程序也可以不用urb来进行数据的传输，这是里涉及到两个简单的接口函数：usb_bulk_msg和usb_control_msg ，在这个USB框架程序里读操作就是这样的一个应用：
/* 进行阻塞的批量读以从设备获取数据 */
retval = usb_bulk_msg(dev->udev,
usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
dev->bulk_in_buffer,
min(dev->bulk_in_size, count),
&count, HZ*10);

/*如果读成功，复制到用户空间 */
if (!retval) {
if (_to_user(buffer, dev->bulk_in_buffer, count))
retval = -EFAULT;
else
retval = count;
}
usb_bulk_msg接口函数的定义如下：
int usb_bulk_msg(struct usb_device *usb_dev,unsigned int pipe,
void *data,int len,int *actual_length,int timeout);
其参数为：
struct usb_device *usb_dev：指向批量消息所发送的目标USB设备指针。
unsigned int pipe：批量消息所发送目标USB设备的特定端点，此值是调用usb_sndbulkpipe或者usb_rcvbulkpipe来创建的。
void *data：如果是一个OUT端点，它是指向即将发送到设备的数据的指针。如果是IN端点，它是指向从设备读取的数据应该存放的位置的指针。
int len：data参数所指缓冲区的大小。
int *actual_length：指向保存实际传输字节数的位置的指针，至于是传输到设备还是从设备接收取决于端点的方向。
int timeout：以Jiffies为单位的等待的超时时间，如果该值为0，该函数一直等待消息的结束。
如果该接口函数调用成功，返回值为0，否则返回一个负的错误值。
usb_control_msg接口函数定义如下：
int usb_control_msg(struct usb_device *dev,unsigned int pipe,__u8 request,__u8requesttype,__u16 value,__u16 index,void *data,__u16 size,int timeout)
除了允许驱动程序发送和接收USB控制消息之外，usb_control_msg函数的运作和usb_bulk_msg函数类似，其参数和usb_bulk_msg的参数有几个重要区别：
struct usb_device *dev：指向控制消息所发送的目标USB设备的指针。
unsigned int pipe：控制消息所发送的目标USB设备的特定端点，该值是调用usb_sndctrlpipe或usb_rcvctrlpipe来创建的。
__u8 request：控制消息的USB请求值。
__u8 requesttype：控制消息的USB请求类型值。
__u16 value：控制消息的USB消息值。
__u16 index：控制消息的USB消息索引值。
void *data：如果是一个OUT端点，它是指身即将发送到设备的数据的指针。如果是一个IN端点，它是指向从设备读取的数据应该存放的位置的指针。
__u16 size：data参数所指缓冲区的大小。
int timeout：以Jiffies为单位的应该等待的超时时间，如果为0，该函数将一直等待消息结束。
如果该接口函数调用成功，返回传输到设备或者从设备读取的字节数；如果不成功它返回一个负的错误值。
这两个接口函数都不能在一个中断上下文中或者持有自旋锁的情况下调用，同样，该函数也不能被任何其它函数取消，使用时要谨慎。
我们要给未知的USB设备写驱动程序，只需要把这个框架程序稍做修改就可以用了，前面我们已经说过要修改制造商和产品的ID号，把0xfff0这两个值改为未知USB的ID号。
#define USB_SKEL_VENDOR_ID 0xfff0
#define USB_SKEL_PRODUCT_ID 0xfff0
还 有就是在探测函数中把需要探测的接口端点类型写好，在这个框架程序中只探测了批量（USB_ENDPOINT_XFER_BULK）IN和OUT端点，可 以在此处使用掩码（USB_ENDPOINT_XFERTYPE_MASK）让其探测其它的端点类型，驱动程序会对USB设备的每一个接口进行一次探测， 当探测成功后，驱动程序就被绑定到这个接口上。再有就是urb的初始化问题，如果你只写简单的USB驱动，这块不用多加考虑，框架程序里的东西已经够用 了，这里我们简单介绍三个初始化urb的辅助函数：
usb_fill_int_urb ：它的函数原型是这样的：
void usb_fill_int_urb(struct urb *urb,struct usb_device *dev,
unsigned int pipe,void *transfer_buff,
int buffer_length,usb_complete_t complete,
void *context,int interval);
这个函数用来正确的初始化即将被发送到USB设备的中断端点的urb。
usb_fill_bulk_urb ：它的函数原型是这样的：
void usb_fill_bulk_urb(struct urb *urb,struct usb_device *dev,
unsigned int pipe,void *transfer_buffer,
int buffer_length,usb_complete_t complete)
这个函数是用来正确的初始化批量urb端点的。
usb_fill_control_urb ：它的函数原型是这样的：
void usb_fill_control_urb(struct urb *urb,struct usb_device *dev,unsigned int pipe,unsigned char *setup_packet,void *transfer_buffer,int buffer_length,usb_complete_t complete,void *context);
这个函数是用来正确初始化控制urb端点的。
还有一个初始化等时urb的，它现在还没有初始化函数，所以它们在被提交到USB核心前，必须在驱动程序中手工地进行初始化，可以参考内核源代码树下的/usr/src/~/drivers/usb/media下的konicawc.c文件。

⑧ linux下无线网卡如何驱动

linux下无线网卡具体驱动的操作方法如下：

1、首先需要确定网卡的类型，打开linux的输入窗口，然后继续在linux终端下输入lsusb命令，此时在输出栏的第一行可以查看网卡类型，记录下来。

⑨ Linux内核睡眠唤醒调试

本文基于 RockPI 4A 单板 Debian 系统 Linux4.4 内核介绍下睡眠唤醒（ suspend/resume ）的一些调试方法。

1、关闭串口睡眠

在Linux内核睡眠过程中，会先调用 suspend_console() 函数使串口进入睡眠状态，这样会导致后续设备驱动的睡眠过程不可见。可以在boot启动参数中增加 no_console_suspend 参数，显示设备驱动睡眠日志。

2、修改串口日志等级

修改串口日志打印等级，显示更多调试信息。

3、打开设备睡眠唤醒时间

设置 pm_print_times 参数，可以显示设备驱动睡眠唤醒时间，方便调试时查看哪个函数处理占用时间过长。

在调试Linux内核睡眠唤醒功能时，可以使用 RTC 做唤醒源，在系统睡眠5秒后，自动唤醒系统。

在 arch/arm64/configs/rockchip_linux_defconfig 文件中配置宏 CONFIG_PM_TEST_SUSPEND 。

唤醒日志如下：