android timed output vibrator driver

#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/device.h>

#include <linux/workqueue.h>

#include "timed_output.h"

#include <linux/hrtimer.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/spinlock.h>

#include <linux/jiffies.h>

#include <linux/timer.h>

#include <linux/mutex.h>

#include <mach/mt_typedefs.h>

#define VIB_DEVICE "vibrator"

static struct workqueue_struct *vibrator_queue;

static struct work_struct work_vibrator;

static int vibe_state;

static struct hrtimer vibe_timer;

static DEFINE_MUTEX(vibe_mtx);

static spinlock_t vibe_lock;

extern void motor_enable(bool enable);

static int vibr_Enable(void)

{

motor_enable(1);

return 0;

}

static int vibr_Disable(void)

{

motor_enable(0);

return 0;

}

static void update_vibrator(struct work_struct *work)

{

set_vibrator(vibe_state);

}

static void vibrator_enable(struct timed_output_dev *dev, int value)

{

unsigned long flags;

spin_lock_irqsave(&vibe_lock, flags);

hrtimer_cancel(&vibe_timer);

if (value == 0)

vibe_state = 0;

else {

value = (value > 15000 ? 15000 : value);

vibe_state = 1;

hrtimer_start(&vibe_timer,

ktime_set(value / 1000, (value % 1000) * 1000000),

HRTIMER_MODE_REL);

}

spin_unlock_irqrestore(&vibe_lock, flags);

queue_work(vibrator_queue,&work_vibrator);

}

static int vibrator_get_time(struct timed_output_dev *dev)

{

if (hrtimer_active(&vibe_timer)) {

ktime_t r = hrtimer_get_remaining(&vibe_timer);

return r.tv.sec * 1000 + r.tv.nsec / 1000000;

} else

return 0;

}

static void set_vibrator(int on)

{

if(mutex_lock_interruptible(&vibe_mtx))

return;

if (on)

vibr_Enable();

else

vibr_Disable();

mutex_unlock(&vibe_mtx);

}

static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)

{

vibe_state = 0;

queue_work(vibrator_queue,&work_vibrator);

return HRTIMER_NORESTART;

}

static struct timed_output_dev timed_vibrator = {

.name = "vibrator",

.get_time = vibrator_get_time,

.enable = vibrator_enable,

};

static int vib_probe(struct platform_device *pdev)

{

return 0;

}

static int vib_remove(struct platform_device *pdev)

{

return 0;

}

static void vib_shutdown(struct platform_device *pdev)

{

unsigned long flags;

printk("[vibrator]vib_shutdown: enter!\n");

spin_lock_irqsave(&vibe_lock, flags);

if(vibe_state) {

printk("[vibrator]vib_shutdown: vibrator will disable \n");

vibe_state = 0;

spin_unlock_irqrestore(&vibe_lock, flags);

vibr_Disable();

goto vibr_end; /*don't spinunlock twice*/

}

spin_unlock_irqrestore(&vibe_lock, flags);

vibr_end:

return;

}

/******************************************************************************

Device driver structure

*****************************************************************************/

static struct platform_driver vibrator_driver =

{

.probe = vib_probe,

.remove
= vib_remove,

.shutdown = vib_shutdown,

.driver = {

.name = VIB_DEVICE,

.owner = THIS_MODULE,

},

};

static struct platform_device vibrator_device =

{

.name = "vibrator",

.id = -1,

};

static ssize_t store_vibr_on(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)

{

if(buf != NULL && size != 0)

{

printk("[vibrator]buf is %s and size is %d \n",buf,size);

if(buf[0]== '0')

{

vibr_Disable();

}else

{

vibr_Enable();

}

}

return size;

}

static DEVICE_ATTR(vibr_on, 0220, NULL, store_vibr_on);

static void __init init_vibrator(void)

{

int ret;

INIT_WORK(&work_vibrator, update_vibrator);

spin_lock_init(&vibe_lock);

vibe_state = 0;

hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

vibe_timer.function = vibrator_timer_func;

timed_output_dev_register(&timed_vibrator);

ret = platform_device_register(&vibrator_device);

if (ret != 0){

printk("[vibrator]Unable to register vibrator device (%d)\n", ret);

return ret;

}

vibrator_queue = create_singlethread_workqueue(VIB_DEVICE);

if(!vibrator_queue) {

printk("[vibrator]Unable to create workqueue\n");

return -ENODATA;

}

if(ret)

{

printk("[vibrator]Unable to register vibrator driver (%d)\n", ret);

return ret;

}

ret = device_create_file(timed_vibrator.dev,&dev_attr_vibr_on);

if(ret)

{

printk("[vibrator]device_create_file vibr_on fail! \n");

}

}

static void __exit exit_vibrator(void)

{

if(vibrator_queue) {

destroy_workqueue(vibrator_queue);

}

printk("[vibrator]vib_mod_exit Done \n");

}

module_init(init_vibrator);

module_exit(exit_vibrator);

MODULE_AUTHOR("bsp meizu");

MODULE_DESCRIPTION("timed output vibrator device");

MODULE_LICENSE("GPL");

写enable文件时调用vibrator_enable;

读enable文件时调用vibrator_get_time。

init_vibrator是模块入口， vibrator_enable是写enable文件的入口。

vibrator_enable中的处理非常有意思，这个函数“正常”的步骤应该是：设置voltage以开震动----->延迟需要震动的时间----->把volt设为0以关闭震动，

然而上面的步骤却没有这样处理，而是启动了高精度定时器并在退出前通过schedule_work(&work_vibrator)调度work，

调度work即是执行set_pmic_vibrator，这里通过RPC通信操作VIB_DRV_N pin，控制输出电压。

即写enable文件时并没有对motor 电压的任何直接操作，而是延后进行的。

为何采取这种策略，一种解释是：enable的调用将形成一种持续时间的效果，但是调用本身不宜阻塞，

因此实现就让vibrator_enable函数退出后通过定时器实现效果。我反正不太理解上面这个解释:-(

白话一些，我的理解：

那种“正常”的步骤，最关键的是有个延时，而在函数中这种长时间的延时（震动可能很长时间如闹钟或来电）是不好的而且是很不好，

于是策略改变，采用Timer +work，具体步骤如下

引入关键的全局变量 vibe_state，只有在向enable文件写入不为0时才将 vibe_state 置为1，同时启动定时器，并调度work；

定时器超时的callback函数中又将 vibe_state 置0并调度work。而调度work时的执行函数set_pmic_vibrator(int on)其传入参数即是vibe_state,

会根据这一值来设置motor的pin电压为需要的值（开震动）或者0（关震动）。如此通过迂回的方式就避开了“在函数中延长很长时间”的问题，不会造成阻塞。

通过这个例子可以理解work将“工作推后延迟执行”的特点，TouchPanel中的work是将读点的工作延后到中断服务退出，

不同的是TouchPanel中还要创建独立的工作队列（create_singlethread_workqueue），而不是像这个使用内核缺省的队列。

没有搞清楚 msm_rpc_call 这个函数如何使用的？！

2.hardware/libhardware_legacy/vibrator.c 这是硬件抽象层，其实就是对/sys/class/timed_output/vibrator/enable文件的写操作，

提供给上层JNI的两个接口： int vibrator_on(int timeout_ms); // 开始振动

int vibrator_off(); // 关闭振动