arm linux内核 电源,Linux 电源管理在ARM上的实现原理

内核版本号：linux2.6.32

由于arm系统中没有bios设备,

所以只能为arm系统创建一个虚拟的字符设备与用户空间进行通讯. 即在apm中实现一个misc设备,实质上也是一个字符设备,

misc设备的主设备号是10, 而apm_bios作为个misc设备, 次设备号是134。

Linux2.6.30.10内核的/drivers/char/apm-emulation.c提供了apm_bios的驱动模型，也就是系统进入睡眠的入口函数，更早的版本的接口文件为：arch/arm/kernel/apm.c

在apm-emulation.c中：

#define APM_MINOR_DEV 134

这个apm_bios设备通过ioctl系统调用和用户空间进行通讯, 即当用户进程通过ioctl发来suspend命令时,

它就传给内核, 使系统进入suspend状态.

1，初始化

static int __init apm_init(void)

{

int

ret;

if

(apm_disabled) {

printk(KERN_NOTICE

"apm: disabled on user request.\n");

return

-ENODEV;

}

//创建一个线程, 用于处理事件队列, 工作函数是kapmd

kapmd_tsk = kthread_create(kapmd, NULL, "kapmd");

if (IS_ERR(kapmd_tsk)) {

ret =

PTR_ERR(kapmd_tsk);

kapmd_tsk = NULL;

goto out;

}

wake_up_process(kapmd_tsk);

//通过proc，向用户空间输出apm信息

#ifdef CONFIG_PROC_FS

proc_create("apm", 0, NULL, &apm_proc_fops);

#endif

//注册misc设备

ret = misc_register(&apm_device);

if (ret)

goto out_stop;

ret = register_pm_notifier(&apm_notif_block);

if (ret)

goto out_unregister;

return 0;

out_unregister:

misc_deregister(&apm_device);

out_stop:

remove_proc_entry("apm",

NULL);

kthread_stop(kapmd_tsk);

out:

return ret;

}

//注册结构为：

static struct file_operations apm_bios_fops = {

.owner = THIS_MODULE,

.read = apm_read,

.poll = apm_poll,

.ioctl = apm_ioctl,

.open = apm_open,

.release = apm_release,

};

static struct miscdevice apm_device = {

.minor = APM_MINOR_DEV,

.name = "apm_bios",

.fops = &apm_bios_fops

};

这样就我们就可以像对一般的设备文件一样，读取apm_bios的相关信息了。

2，结构中函数实现

当一个用户进程打开apm_bios设备时, 它就会调用这个函数

static int apm_open(struct inode * inode, struct file * filp)

{

//这个关键是apm_user结构变量as，它是用户和apm内核部分沟通的桥梁，当有apm事件发生时，就把event挂到apm_user的queue上，这样当用户读时就会读到相关事件然后处理。

struct apm_user *as;

lock_kernel();

//分配一个apm_user结构, 来表示一个用户进程

as = kzalloc(sizeof(*as), GFP_KERNEL);

//读写等权限设置

if (as) {

as->suser =

capable(CAP_SYS_ADMIN);

as->writer =

(filp->f_mode & FMODE_WRITE) ==

FMODE_WRITE;

as->reader =

(filp->f_mode & FMODE_READ) ==

FMODE_READ;

//将这个用户加入用户队列

down_write(&user_list_lock);

list_add(&as->list,

&apm_user_list);

up_write(&user_list_lock);

//这是一个传递私有数据的一个通用方式

filp->private_data = as;

}

unlock_kernel();

return as ? 0 : -ENOMEM;

}

当用户空间进程去读这个设备时, 这个函数就会被调用. 这个函数的主要作用是将事件读出到用户空间.

static ssize_t apm_read(struct file *fp, char __user *buf, size_t

count, loff_t *ppos)

{

struct apm_user *as =

fp->private_data;

apm_event_t event;

int i = count, ret = 0;

if (count <

sizeof(apm_event_t))

return -EINVAL;

//队列空, 且进程非阻塞读, 立刻返回

if

(queue_empty(&as->queue)

&& fp->f_flags

& O_NONBLOCK)

return -EAGAIN;

//否则等待到队列非空为止,

wait_event_interruptible(apm_waitqueue,

!queue_empty(&as->queue));

//将队列中的事件复制给用户空间

while ((i >= sizeof(event))

&&

!queue_empty(&as->queue)) {

event =

queue_get_event(&as->queue);

ret = -EFAULT;

if (copy_to_user(buf, &event, sizeof(event)))

break;

//设置状态

mutex_lock(&state_lock);

if (as->suspend_state ==

SUSPEND_PENDING &&

(event == APM_SYS_SUSPEND || event == APM_USER_SUSPEND))

as->suspend_state = SUSPEND_READ;

mutex_unlock(&state_lock);

buf += sizeof(event);

i

-= sizeof(event);

}

if (i <

count)

ret = count - i;

return ret;

}

//这个poll/select的后端实现, 用于查询有没有数据可读

static unsigned int apm_poll(struct file *fp, poll_table *

wait)

{

struct apm_user *as =

fp->private_data;

poll_wait(fp,

&apm_waitqueue, wait);

return

queue_empty(&as->queue) ? 0 : POLLIN

| POLLRDNORM;

}

//这个是这个设备的核心函数, 用于内核与用户空间交互

static int apm_ioctl(struct inode * inode, struct file *filp, u_int

cmd, u_long arg)

{

struct apm_user *as =

filp->private_data;

int err = -EINVAL;

／／只有超级用户才能执行回复

if (!as->suser

|| !as->writer)

return -EPERM;

switch (cmd) {

case APM_IOC_SUSPEND:

mutex_lock(&state_lock);

as->suspend_result = -EINTR;

switch (as->suspend_state) {

／／这个就是当user读取到event时的状态，这是发送这个事件,意味着这是回应ack

case SUSPEND_READ:

as->suspend_state

= SUSPEND_ACKED;

atomic_dec(&suspend_acks_pending);

mutex_unlock(&state_lock);

wake_up(&apm_suspend_waitqueue);

freezer_do_not_count();

wait_event(apm_suspend_waitqueue,

as->suspend_state == SUSPEND_DONE);

freezer_count();

break;

case SUSPEND_ACKTO: