一： 振动器系统结构和移植内容

振动器负责控制引动电话的振动功能，Android中的振动器系统是一个专供这方面功能的小系统，提供根据时间振动的功能。

振动器系统包含了驱动程序、硬件抽象层、JNI部分、Java框架类等几个部分，也向Java应用程序层提供了简单的API作为平台接口。

Android振动器系统的基本层次结构如图23-1所示。

转载加原创Android振动器调试_第1张图片

图23-1 Android振动器系统的基本层次结构

1 振动器部分的结构

Android振动器系统自下而上包含了驱动程序、振动器系统硬件抽象层、振动器系统Java框架类、Java框架中振动器系统使用等几个部分，其结构如图23-2所示。

转载加原创Android振动器调试_第2张图片

图23-2 Android振动器系统的结构

自下而上，Android的振动器系统分成了以下部分。

（1）驱动程序：特定硬件平台振动器的驱动程序，通常基于Android的Timed Output驱动框架实现

（2）硬件抽象层

光系统硬件抽象层接口路径为：hardware/libhardware_legacy/include/hardware_legacy/ vibrator.h

振动器系统的硬件抽象层在Android中已经具有默认实现，代码路径：

hardware/libhardware_legacy/vibrator/vibrator.c

振动器的硬件抽象层通常并不需要重新实现，是libhardware_legacy.so的一部分。

（3）JNI部分

代码路径：frameworks/base/services/jni/com_android_server_VibratorService.cpp

这个类是振动器的JNI部分，通过调用硬件抽象层向上层提供接口。

（4）Java部分

代码路径：

frameworks/base/services/java/com/android/server/VibratorService.java

frameworks/base/core/java/android/os/Vibrator.java

VibratorService.java通过调用，VibratorService JNI来实现com.android.server包中的VibratorService类。这个类不是平台的API，被Android系统Java框架中的一小部分调用。

Vibrator.java文件实现了android.os包中的Vibrator类，这是向Java层提供的API。

2 移植内容

针对特定的硬件平台，振动器系统的移植有两种方法。

第一种方法（通常情况）：由于已经具有硬件抽象层，振动器系统的移植只需要实现驱动程序即可。这个驱动程序需要基于Android内核中的Timed Output驱动框架。

第二种方法：根据自己实现的驱动程序，重新实现振动器的硬件抽象层定义接口（需要在libhardware_legacy.so库中），由于振动器硬件抽象层的接口非常简单，因此这种实现方式也不会很复杂。

二： 移植与调试的要点

1 驱动程序

vibrator驱动提供上层接口有很多种，这里介绍两种方式：一种是timeout方式，一种是属性节点。

一、timeout方式

Vibrator的驱动程序只需要实现振动的接口即可，这是一个输出设备，需要接受振动时间作为参数。由于比较简单，因此Vibrator的驱动程序可以使用多种方式来实现。

在Android中，推荐基于Android内核定义Timed Output驱动程序框架来实现Vibrator的驱动程序。

Timed Output的含义为定时输出，用于定时发出某个输出。实际上，这种驱动程序依然是基于sys文件系统来完成的。

drivers/staging/android/目录timed_output.h中定义timed_output_dev结构体，其中包含enable和get_time这两个函数指针，实现结构体后，使用timed_output_dev_register()和timed_output_dev_unregister()函数注册和注销即可。

Timed Output驱动程序框架将为每个设备在/sys/class/timed_output/目录中建立一个子目录，设备子目录中的enable文件就是设备的控制文件。读enable文件表示获得剩余时间，写这个文件表示根据时间振动。

Timed Output驱动的设备调试，通过sys文件系统即可。

对于Vibrator设备，其实现的Timed Output驱动程序的名称应该为“vibrator”。因此Vibrator设备在sys文件系统中的方法如下所示：

# echo "10000" > /sys/class/timed_output/vibrator/enable

# cat /sys/class/timed_output/vibrator/enable

3290

# echo "0" > /sys/class/timed_output/vibrator/enable

对于enable文件，“写”表示使能指定的时间，“读”表示获取剩余时间。

二 文件属性节点

这种方法就是直接用kernel sys系统创建文件节点，提供上层接口，直接操作底层gpio口或者PWM等控制器。

2 硬件抽象层的内容

2.1 硬件抽象层的接口

Vibrator硬件抽象层的接口在hardware/libhardware_legacy/include/hardware_legacy/目录的vibrator.h文件中定义：

int vibrator_on(int timeout_ms); // 开始振动

int vibrator_off(); // 关闭振动

vibrator.h文件中定义两个接口，分别表示振动和关闭，振动开始以毫秒（ms）作为时间单位。

提示：Timed Output类型驱动本身有获得剩余时间的能力（读enable文件），但是在Android Vibrator硬件抽象层以上的各层接口都没有使用这个功能。

2.2 标准硬件抽象层的实现

Vibrator硬件抽象层具有标准的实现，在hardware/libhardware_legacy/vibrator/目录的vibrator.c中。

其中实现的核心内容为sendit()函数，这个函数的内容如下所示：

[html] view plain copy print ?
  1. <PREclass=cppname="code">#defineTHE_DEVICE"/sys/class/timed_output/vibrator/enable"
  3. staticintsendit(inttimeout_ms)
  5. {
  7. intnwr,ret,fd;
  9. charvalue[20];
  11. #ifdefQEMU_HARDWARE//使用QEMU的情况
  13. if(qemu_check()){
  15. returnqemu_control_command("vibrator:%d",timeout_ms);
  17. }
  19. #endif
  21. fd=open(THE_DEVICE,O_RDWR);//读取sys文件系统中的内容
  23. if(fd<0)returnerrno;
  25. nwr=sprintf(value,"%d\n",timeout_ms);
  27. ret=write(fd,value,nwr);
  29. close(fd);
  31. return(ret==nwr)?0:-1;
  33. }
  35. </PRE><BR>
  36. <PRE></PRE>
  37. <P></P>
  38. <P>sendit()函数负责根据时间“振动”：在真实的硬件中，通过sys文件系统的文件进行控制；如果是模拟器环境则通过QEMU发送命令。</P>
  39. <P>vibrator_on()调用sendit()以时间作为参数，vibrator_on()调用sendit()以0作为参数。</P>
  40. <P></P>
  41. <P><STRONG>上层的情况和注意事项</STRONG></P>
  42. <P>　　frameworks/base/services/jni/目录中的com_android_server_VibratorService.cpp文件是Vibrator硬件抽象层的调用者，它同时也向Java提供JNI支持。</P>
  43. <P>　　其中，为JNI定义的方法列表如下所示：</P>
  44. <P>　　</P>
  45. <PREclass=cppname="code">　staticJNINativeMethodmethod_table[]={
  47. 　　{"vibratorOn","(J)V",(void*)vibratorOn},//振动器开
  49. 　　{"vibratorOff","()V",(void*)vibratorOff}//振动器关
  51. 　　};
  53. 　　intregister_android_server_VibratorService(JNIEnv*env){
  55. 　　returnjniRegisterNativeMethods(env,"com/android/server/VibratorService",
  57. 　　method_table,NELEM(method_table));
  59. 　　}
  60. 　　//vibratorOn()和vibratorOff()这两个函数的实现分别如下所示：
  62. 　　
  64. 　　staticvoidvibratorOn(JNIEnv*env,jobjectclazz,jlongtimeout_ms){
  66. 　　vibrator_on(timeout_ms);
  68. 　　}
  70. 　　staticvoidvibratorOff(JNIEnv*env,jobjectclazz){
  72. 　　vibrator_off();
  74. 　　}
  76. </PRE>
  77. <P><BR>
  78. </P>
  79. <P>frameworks/base/services/java/com/android/server/目录中的VibratorService.java通过调用VibratorServiceJNI来实现com.android.server包中的VibratorService类。</P>
  80. <P>　　frameworks/base/core/java/android/os/目录中的Vibrator.java文件实现了android.os包中的Vibrator类。它通过调用vibrator的Java服务来实现(获得名称为vibrator的服务)，配合同目录中的IVibratorService.aidl文件向应用程序层提供Vibrator的相关API。</P>
  81. <P>-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</P>
  82. <P><STRONG>Timeout方式的驱动程序</STRONG></P>
  83. <STRONG></STRONG><PREclass=cppname="code">#include<linux/init.h>
  84. #include<linux/module.h>
  85. #include<linux/kernel.h>
  86. #include<linux/types.h>
  87. #include<linux/device.h>
  88. #include<linux/workqueue.h>
  90. #include"timed_output.h"
  91. #include<linux/hrtimer.h>
  92. #include<linux/err.h>
  93. #include<linux/platform_device.h>
  94. #include<linux/spinlock.h>
  96. #include<linux/jiffies.h>
  97. #include<linux/timer.h>
  99. #include<mach/mt_typedefs.h>
  100. #include<mach/mt_pll.h>
  101. #include<mach/mt_gpt.h>
  103. #defineVERSION"v0.1"
  104. #defineVIB_DEVICE"mt_vibrator"
  106. #defineCOUNT_DOWN_TIME50
  108. #defineVIBR_HRTIMER
  110. #ifndefVIBR_HRTIMER
  111. XGPT_NUMVibrator_XGPT=XGPT7;
  112. #endif
  114. /******************************************************************************
  115. ErrorCodeNo.
  116. ******************************************************************************/
  117. #defineRSUCCESS0
  119. /******************************************************************************
  120. DebugMessageSettings
  121. ******************************************************************************/
  123. /*Debugmessageevent*/
  124. #defineDBG_EVT_NONE0x00000000/*Noevent*/
  125. #defineDBG_EVT_INT0x00000001/*Interruptrelatedevent*/
  126. #defineDBG_EVT_TASKLET0x00000002/*Taskletrelatedevent*/
  128. #defineDBG_EVT_ALL0xffffffff
  130. #defineDBG_EVT_MASK(DBG_EVT_TASKLET)
  132. #if1
  133. #defineMSG(evt,fmt,args...)\
  134. do{\
  135. if((DBG_EVT_##evt)&DBG_EVT_MASK){\
  136. printk(fmt,##args);\
  137. }\
  138. }while(0)
  140. #defineMSG_FUNC_ENTRY(f)MSG(FUC,"<FUN_ENT>:%s\n",__FUNCTION__)
  141. #else
  142. #defineMSG(evt,fmt,args...)do{}while(0)
  143. #defineMSG_FUNC_ENTRY(f)do{}while(0)
  144. #endif
  146. #defineVIBR_CON0((volatileunsignedlong*)(0xF702F7B0))
  148. staticintvibr_Enable(void)
  149. {
  150. printk("[vibrator]vibr_Enable\n");
  151. hwPowerOn(MT_POWER_LDO_VIBR,VOL_2800,"VIBR");
  152. return0;
  153. }
  155. staticintvibr_Disable(void)
  156. {
  157. while((INREG32(VIBR_CON0)&1))
  158. {
  159. printk("[vibrator]vibr_Disable\n");
  160. hwPowerDown(MT_POWER_LDO_VIBR,"VIBR");
  161. //printk("[vibrator]vibr_Disable:VIBR_CON0=0x%x\r\n",INREG32(VIBR_CON0));
  162. }
  164. return0;
  165. }
  168. /******************************************************************************
  169. GlobalDefinations
  170. ******************************************************************************/
  171. //staticstructwork_structvibrator_work;
  172. staticstructhrtimervibe_timer;
  173. staticspinlock_tvibe_lock;
  176. staticintvibrator_get_time(structtimed_output_dev*dev)
  177. {
  178. if(hrtimer_active(&vibe_timer))
  179. {
  180. ktime_tr=hrtimer_get_remaining(&vibe_timer);
  181. returnr.tv.sec*1000+r.tv.nsec/1000000;
  182. }
  183. else
  184. return0;
  185. }
  187. staticvoidvibrator_enable(structtimed_output_dev*dev,intvalue)
  188. {
  189. unsignedlongflags;
  191. spin_lock_irqsave(&vibe_lock,flags);
  193. #ifdefVIBR_HRTIMER
  194. while(hrtimer_cancel(&vibe_timer))
  195. {
  196. printk("[vibrator]vibrator_enable:trytocancelhrtimer\n");
  197. }
  198. #else
  199. XGPT_Reset(Vibrator_XGPT);
  200. #endif
  202. if(value==0)
  203. {
  204. printk("[vibrator]vibrator_enable:disable\n");
  205. vibr_Disable();
  207. }
  208. else
  209. {
  210. value=((value>15000)?15000:value);
  211. printk("[vibrator]vibrator_enable:vibratorstart:%d\n",value);
  213. #ifdefVIBR_HRTIMER
  214. hrtimer_start(&vibe_timer,
  215. ktime_set(value/1000,(value%1000)*1000000),
  216. HRTIMER_MODE_REL);
  218. #else
  219. XGPT_CONFIGconfig;
  220. config.num=Vibrator_XGPT;
  221. config.clkDiv=0;
  222. config.mode=XGPT_ONE_SHOT;
  223. config.bIrqEnable=TRUE;
  224. config.u4Compare=value*32768/1000;
  226. if(!XGPT_Config(config))
  227. {
  228. printk("[vibrator]vibrator_enable:configXGPT:%dfail!\n",value);
  229. }
  231. XGPT_Start(Vibrator_XGPT);
  232. #endif
  234. vibr_Enable();
  236. }
  237. spin_unlock_irqrestore(&vibe_lock,flags);
  239. }
  242. #ifdefVIBR_HRTIMER
  243. staticenumhrtimer_restartvibrator_timer_func(structhrtimer*timer)
  244. {
  245. printk("[vibrator]vibrator_timer_func:vibratorwilldisable\n");
  247. vibr_Disable();
  249. returnHRTIMER_NORESTART;
  250. }
  252. #else
  253. voidvibrator_timer_func(UINT16temp)
  254. {
  255. printk("[vibrator]vibrator_timer_func:vibratorwilldisable\n");
  257. vibr_Disable();
  258. }
  259. #endif
  262. staticstructtimed_output_devmt_vibrator=
  263. {
  264. .name="vibrator",
  265. .get_time=vibrator_get_time,
  266. .enable=vibrator_enable,
  267. };
  269. staticintvib_probe(structplatform_device*pdev)
  270. {
  271. return0;
  272. }
  274. staticintvib_remove(structplatform_device*pdev)
  275. {
  276. return0;
  277. }
  279. staticvoidvib_shutdown(structplatform_device*pdev)
  280. {
  281. vibr_Disable();
  283. }
  284. /******************************************************************************
  285. Devicedriverstructure
  286. *****************************************************************************/
  287. staticstructplatform_drivervibrator_driver=
  288. {
  289. .probe=vib_probe,
  290. .remove=vib_remove,
  291. .shutdown=vib_shutdown,
  292. .driver={
  293. .name=VIB_DEVICE,
  294. },
  295. };
  297. staticssize_tstore_vibr_on(structdevice*dev,structdevice_attribute*attr,constchar*buf,size_tsize)
  298. {
  299. if(buf!=NULL&&size!=0)
  300. {
  301. printk("[vibrator]bufis%sandsizeis%d\n",buf,size);
  302. if(buf[0]=='0')
  303. {
  304. vibr_Disable();
  305. }else
  306. {
  307. vibr_Enable();
  308. }
  309. }
  310. returnsize;
  311. }
  313. staticDEVICE_ATTR(vibr_on,0664,NULL,store_vibr_on);
  315. /******************************************************************************
  316. *vib_mod_init
  317. *
  318. *DESCRIPTION:
  319. *Registerthevibratordevicedriver!
  320. *
  321. *PARAMETERS:
  322. *None
  323. *
  324. *RETURNS:
  325. *None
  326. *
  327. *NOTES:
  328. *RSUCCESS:Success
  329. *
  330. ******************************************************************************/
  332. statics32__devinitvib_mod_init(void)
  333. {
  334. s32ret;
  336. printk("MkMTvibratordriverregister,version%s\n",VERSION);
  338. spin_lock_init(&vibe_lock);
  340. #ifdefVIBR_HRTIMER
  341. hrtimer_init(&vibe_timer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
  342. vibe_timer.function=vibrator_timer_func;
  344. #else
  345. XGPT_Init(Vibrator_XGPT,vibrator_timer_func);
  346. #endif
  348. timed_output_dev_register(&mt_vibrator);
  350. ret=platform_driver_register(&vibrator_driver);
  352. if(ret)
  353. {
  354. printk("[vibrator]Unabletoregistervibratordriver(%d)\n",ret);
  355. returnret;
  356. }
  358. ret=device_create_file(mt_vibrator.dev,&dev_attr_vibr_on);
  359. if(ret)
  360. {
  361. printk("[vibrator]device_create_filevibr_onfail!\n");
  362. }
  364. printk("[vibrator]vib_mod_initDone\n");
  366. returnRSUCCESS;
  367. }
  369. /******************************************************************************
  370. *vib_mod_exit
  371. *
  372. *DESCRIPTION:
  373. *Freethedevicedriver!
  374. *
  375. *PARAMETERS:
  376. *None
  377. *
  378. *RETURNS:
  379. *None
  380. *
  381. *NOTES:
  382. *None
  383. *
  384. ******************************************************************************/
  386. staticvoid__exitvib_mod_exit(void)
  387. {
  388. printk("MkMTvibratordriverunregister,version%s\n",VERSION);
  389. printk("[vibrator]vib_mod_exitDone\n");
  390. }
  392. module_init(vib_mod_init);
  393. module_exit(vib_mod_exit);
  394. MODULE_AUTHOR("MkInc.");
  395. MODULE_DESCRIPTION("MTVibratorDriver(VIB)");
  396. MODULE_LICENSE("GPL");</PRE>
  397. <P><BR>
  398. </P>
  399. <P><STRONG></STRONG></P>
  400. <P></P>
  401. <P></P>
  402. <PRE></PRE>
  403. <PRE></PRE>
                         [cpp]      view plain     copy     print     ?                    
                
  1. #defineTHE_DEVICE"/sys/class/timed_output/vibrator/enable" 
    2.             
    3.             
  3. staticintsendit(inttimeout_ms)
    4.             
    5.             
  5. {
    6.             
    7.             
  7. intnwr,ret,fd;
    8.             
    9.             
  9. charvalue[20];
    10.             
    11.             
  11. #ifdefQEMU_HARDWARE//使用QEMU的情况 
    12.             
    13.             
  13. if(qemu_check()){
    14.             
    15.             
  15. returnqemu_control_command("vibrator:%d",timeout_ms);
    16.             
    17.             
  17. }
    18.             
    19.             
  19. #endif 
    20.             
    21.             
  21. fd=open(THE_DEVICE,O_RDWR);//读取sys文件系统中的内容 
    22.             
    23.             
  23. if(fd<0)returnerrno;
    24.             
    25.             
  25. nwr=sprintf(value,"%d\n",timeout_ms);
    26.             
    27.             
  27. ret=write(fd,value,nwr);
    28.             
    29.             
  29. close(fd);
    30.             
    31.             
  31. return(ret==nwr)?0:-1;
    32.             
    33.             
  33. }
    34.         
sendit()函数负责根据时间“振动”：在真实的硬件中，通过sys文件系统的文件进行控制；如果是模拟器环境则通过QEMU发送命令。
vibrator_on()调用sendit()以时间作为参数，vibrator_on()调用sendit()以0作为参数。
上层的情况和注意事项
　　frameworks/base/services/jni/目录中的com_android_server_VibratorService.cpp文件是Vibrator硬件抽象层的调用者，它同时也向Java提供JNI支持。
　　其中，为JNI定义的方法列表如下所示：
　　
                         [cpp]      view plain     copy     print     ?                    
                
  1. 　staticJNINativeMethodmethod_table[]={
    2.             
    3.             
  3. 　　{"vibratorOn","(J)V",(void*)vibratorOn},//振动器开 
    4.             
    5.             
  5. 　　{"vibratorOff","()V",(void*)vibratorOff}//振动器关 
    6.             
    7.             
  7. 　　};
    8.             
    9.             
  9. 　　intregister_android_server_VibratorService(JNIEnv*env){
    10.             
    11.             
  11. 　　returnjniRegisterNativeMethods(env,"com/android/server/VibratorService",
    12.             
    13.             
  13. 　　method_table,NELEM(method_table));
    14.             
    15.             
  15. 　　}
    16.             
  16. 　　//vibratorOn()和vibratorOff()这两个函数的实现分别如下所示： 
    17.             
    18.             
  18. 　　
    19.             
    20.             
  20. 　　staticvoidvibratorOn(JNIEnv*env,jobjectclazz,jlongtimeout_ms){
    21.             
    22.             
  22. 　　vibrator_on(timeout_ms);
    23.             
    24.             
  24. 　　}
    25.             
    26.             
  26. 　　staticvoidvibratorOff(JNIEnv*env,jobjectclazz){
    27.             
    28.             
  28. 　　vibrator_off();
    29.             
    30.             
  30. 　　}
    31.         
 frameworks/base/services/java/com/android/server/目录中的VibratorService.java通过调用VibratorService JNI来实现com.android.server包中的VibratorService类。
　　frameworks/base/core/java/android/os/目录中的Vibrator.java文件实现了android.os包中的Vibrator类。它通过调用vibrator的Java服务来实现(获得名称为vibrator的服务)，配合同目录中的IVibratorService.aidl文件向应用程序层提供Vibrator的相关API。
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
我具体的驱动程序
                         [cpp]      view plain     copy     print     ?                    
                
  1. #include<linux/init.h> 
    2.             
  2. #include<linux/module.h> 
    3.             
  3. #include<linux/kernel.h> 
    4.             
  4. #include<linux/types.h> 
    5.             
  5. #include<linux/device.h> 
    6.             
  6. #include<linux/workqueue.h> 
    7.             
    8.             
  8. #include"timed_output.h" 
    9.             
  9. #include<linux/hrtimer.h> 
    10.             
  10. #include<linux/err.h> 
    11.             
  11. #include<linux/platform_device.h> 
    12.             
  12. #include<linux/spinlock.h> 
    13.             
    14.             
  14. #include<linux/jiffies.h> 
    15.             
  15. #include<linux/timer.h> 
    16.             
    17.             
  17. #include<mach/mt_typedefs.h> 
    18.             
  18. #include<mach/mt_pll.h> 
    19.             
  19. #include<mach/mt_gpt.h> 
    20.             
    21.             
  21. #defineVERSION"v0.1" 
    22.             
  22. #defineVIB_DEVICE"mt_vibrator" 
    23.             
    24.             
  24. #defineCOUNT_DOWN_TIME50 
    25.             
    26.             
  26. #defineVIBR_HRTIMER 
    27.             
    28.             
  28. #ifndefVIBR_HRTIMER 
    29.             
  29. XGPT_NUMVibrator_XGPT=XGPT7;
    30.             
  30. #endif 
    31.             
    32.             
  32. /******************************************************************************
    33.             
  33. ErrorCodeNo.
    34.             
  34. ******************************************************************************/
    35.             
  35. #defineRSUCCESS0 
    36.             
    37.             
  37. /******************************************************************************
    38.             
  38. DebugMessageSettings
    39.             
  39. ******************************************************************************/
    40.             
    41.             
  41. /*Debugmessageevent*/
    42.             
  42. #defineDBG_EVT_NONE0x00000000/*Noevent*/ 
    43.             
  43. #defineDBG_EVT_INT0x00000001/*Interruptrelatedevent*/ 
    44.             
  44. #defineDBG_EVT_TASKLET0x00000002/*Taskletrelatedevent*/ 
    45.             
    46.             
  46. #defineDBG_EVT_ALL0xffffffff 
    47.             
    48.             
  48. #defineDBG_EVT_MASK(DBG_EVT_TASKLET) 
    49.             
    50.             
  50. #if1 
    51.             
  51. #defineMSG(evt,fmt,args...)\ 
    52.             
  52. do{\
    53.             
  53. if((DBG_EVT_##evt)&DBG_EVT_MASK){\
    54.             
  54. printk(fmt,##args);\
    55.             
  55. }\
    56.             
  56. }while(0)
    57.             
    58.             
  58. #defineMSG_FUNC_ENTRY(f)MSG(FUC,"<FUN_ENT>:%s\n",__FUNCTION__) 
    59.             
  59. #else 
    60.             
  60. #defineMSG(evt,fmt,args...)do{}while(0) 
    61.             
  61. #defineMSG_FUNC_ENTRY(f)do{}while(0) 
    62.             
  62. #endif 
    63.             
    64.             
  64. #defineVIBR_CON0((volatileunsignedlong*)(0xF702F7B0)) 
    65.             
    66.             
  66. staticintvibr_Enable(void)
    67.             
  67. {
    68.             
  68. printk("[vibrator]vibr_Enable\n");
    69.             
  69. hwPowerOn(MT_POWER_LDO_VIBR,VOL_2800,"VIBR");
    70.             
  70. return0;
    71.             
  71. }
    72.             
    73.             
  73. staticintvibr_Disable(void)
    74.             
  74. {
    75.             
  75. while((INREG32(VIBR_CON0)&1))
    76.             
  76. {
    77.             
  77. printk("[vibrator]vibr_Disable\n");
    78.             
  78. hwPowerDown(MT_POWER_LDO_VIBR,"VIBR");
    79.             
  79. //printk("[vibrator]vibr_Disable:VIBR_CON0=0x%x\r\n",INREG32(VIBR_CON0)); 
    80.             
  80. }
    81.             
    82.             
  82. return0;
    83.             
  83. }
    84.             
    85.             
    86.             
  86. /******************************************************************************
    87.             
  87. GlobalDefinations
    88.             
  88. ******************************************************************************/
    89.             
  89. //staticstructwork_structvibrator_work; 
    90.             
  90. staticstructhrtimervibe_timer;
    91.             
  91. staticspinlock_tvibe_lock;
    92.             
    93.             
    94.             
  94. staticintvibrator_get_time(structtimed_output_dev*dev)
    95.             
  95. {
    96.             
  96. if(hrtimer_active(&vibe_timer))
    97.             
  97. {
    98.             
  98. ktime_tr=hrtimer_get_remaining(&vibe_timer);
    99.             
  99. returnr.tv.sec*1000+r.tv.nsec/1000000;
    100.             
  100. }
    101.             
  101. else
    102.             
  102. return0;
    103.             
  103. }
    104.             
    105.             
  105. staticvoidvibrator_enable(structtimed_output_dev*dev,intvalue)
    106.             
  106. {
    107.             
  107. unsignedlongflags;
    108.             
    109.             
  109. spin_lock_irqsave(&vibe_lock,flags);
    110.             
    111.             
  111. #ifdefVIBR_HRTIMER 
    112.             
  112. while(hrtimer_cancel(&vibe_timer))
    113.             
  113. {
    114.             
  114. printk("[vibrator]vibrator_enable:trytocancelhrtimer\n");
    115.             
  115. }
    116.             
  116. #else 
    117.             
  117. XGPT_Reset(Vibrator_XGPT);
    118.             
  118. #endif 
    119.             
    120.             
  120. if(value==0)
    121.             
  121. {
    122.             
  122. printk("[vibrator]vibrator_enable:disable\n");
    123.             
  123. vibr_Disable();
    124.             
    125.             
  125. }
    126.             
  126. else
    127.             
  127. {
    128.             
  128. value=((value>15000)?15000:value);
    129.             
  129. printk("[vibrator]vibrator_enable:vibratorstart:%d\n",value);
    130.             
    131.             
  131. #ifdefVIBR_HRTIMER 
    132.             
  132. hrtimer_start(&vibe_timer,
    133.             
  133. ktime_set(value/1000,(value%1000)*1000000),
    134.             
  134. HRTIMER_MODE_REL);
    135.             
    136.             
  136. #else 
    137.             
  137. XGPT_CONFIGconfig;
    138.             
  138. config.num=Vibrator_XGPT;
    139.             
  139. config.clkDiv=0;
    140.             
  140. config.mode=XGPT_ONE_SHOT;
    141.             
  141. config.bIrqEnable=TRUE;
    142.             
  142. config.u4Compare=value*32768/1000;
    143.             
    144.             
  144. if(!XGPT_Config(config))
    145.             
  145. {
    146.             
  146. printk("[vibrator]vibrator_enable:configXGPT:%dfail!\n",value);
    147.             
  147. }
    148.             
    149.             
  149. XGPT_Start(Vibrator_XGPT);
    150.             
  150. #endif 
    151.             
    152.             
  152. vibr_Enable();
    153.             
    154.             
  154. }
    155.             
  155. spin_unlock_irqrestore(&vibe_lock,flags);
    156.             
    157.             
  157. }
    158.             
    159.             
    160.             
  160. #ifdefVIBR_HRTIMER 
    161.             
  161. staticenumhrtimer_restartvibrator_timer_func(structhrtimer*timer)
    162.             
  162. {
    163.             
  163. printk("[vibrator]vibrator_timer_func:vibratorwilldisable\n");
    164.             
    165.             
  165. vibr_Disable();
    166.             
    167.             
  167. returnHRTIMER_NORESTART;
    168.             
  168. }
    169.             
    170.             
  170. #else 
    171.             
  171. voidvibrator_timer_func(UINT16temp)
    172.             
  172. {
    173.             
  173. printk("[vibrator]vibrator_timer_func:vibratorwilldisable\n");
    174.             
    175.             
  175. vibr_Disable();
    176.             
  176. }
    177.             
  177. #endif 
    178.             
    179.             
    180.             
  180. staticstructtimed_output_devmt_vibrator=
    181.             
  181. {
    182.             
  182. .name="vibrator",
    183.             
  183. .get_time=vibrator_get_time,
    184.             
  184. .enable=vibrator_enable,
    185.             
  185. };
    186.             
    187.             
  187. staticintvib_probe(structplatform_device*pdev)
    188.             
  188. {
    189.             
  189. return0;
    190.             
  190. }
    191.             
    192.             
  192. staticintvib_remove(structplatform_device*pdev)
    193.             
  193. {
    194.             
  194. return0;
    195.             
  195. }
    196.             
    197.             
  197. staticvoidvib_shutdown(structplatform_device*pdev)
    198.             
  198. {
    199.             
  199. vibr_Disable();
    200.             
    201.             
  201. }
    202.             
  202. /******************************************************************************
    203.             
  203. Devicedriverstructure
    204.             
  204. *****************************************************************************/
    205.             
  205. staticstructplatform_drivervibrator_driver=
    206.             
  206. {
    207.             
  207. .probe=vib_probe,
    208.             
  208. .remove=vib_remove,
    209.             
  209. .shutdown=vib_shutdown,
    210.             
  210. .driver={
    211.             
  211. .name=VIB_DEVICE,
    212.             
  212. },
    213.             
  213. };
    214.             
    215.             
  215. staticssize_tstore_vibr_on(structdevice*dev,structdevice_attribute*attr,constchar*buf,size_tsize)
    216.             
  216. {
    217.             
  217. if(buf!=NULL&&size!=0)
    218.             
  218. {
    219.             
  219. printk("[vibrator]bufis%sandsizeis%d\n",buf,size);
    220.             
  220. if(buf[0]=='0')
    221.             
  221. {
    222.             
  222. vibr_Disable();
    223.             
  223. }else
    224.             
  224. {
    225.             
  225. vibr_Enable();
    226.             
  226. }
    227.             
  227. }
    228.             
  228. returnsize;
    229.             
  229. }
    230.             
    231.             
  231. staticDEVICE_ATTR(vibr_on,0664,NULL,store_vibr_on);
    232.             
    233.             
  233. /******************************************************************************
    234.             
  234. *vib_mod_init
    235.             
  235. *
    236.             
  236. *DESCRIPTION:
    237.             
  237. *Registerthevibratordevicedriver!
    238.             
  238. *
    239.             
  239. *PARAMETERS:
    240.             
  240. *None
    241.             
  241. *
    242.             
  242. *RETURNS:
    243.             
  243. *None
    244.             
  244. *
    245.             
  245. *NOTES:
    246.             
  246. *RSUCCESS:Success
    247.             
  247. *
    248.             
  248. ******************************************************************************/
    249.             
    250.             
  250. statics32__devinitvib_mod_init(void)
    251.             
  251. {
    252.             
  252. s32ret;
    253.             
    254.             
  254. printk("MkMTvibratordriverregister,version%s\n",VERSION);
    255.             
    256.             
  256. spin_lock_init(&vibe_lock);
    257.             
    258.             
  258. #ifdefVIBR_HRTIMER 
    259.             
  259. hrtimer_init(&vibe_timer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
    260.             
  260. vibe_timer.function=vibrator_timer_func;
    261.             
    262.             
  262. #else 
    263.             
  263. XGPT_Init(Vibrator_XGPT,vibrator_timer_func);
    264.             
  264. #endif 
    265.             
    266.             
  266. timed_output_dev_register(&mt_vibrator);
    267.             
    268.             
  268. ret=platform_driver_register(&vibrator_driver);
    269.             
    270.             
  270. if(ret)
    271.             
  271. {
    272.             
  272. printk("[vibrator]Unabletoregistervibratordriver(%d)\n",ret);
    273.             
  273. returnret;
    274.             
  274. }
    275.             
    276.             
  276. ret=device_create_file(mt_vibrator.dev,&dev_attr_vibr_on);
    277.             
  277. if(ret)
    278.             
  278. {
    279.             
  279. printk("[vibrator]device_create_filevibr_onfail!\n");
    280.             
  280. }
    281.             
    282.             
  282. printk("[vibrator]vib_mod_initDone\n");
    283.             
    284.             
  284. returnRSUCCESS;
    285.             
  285. }
    286.             
    287.             
  287. /******************************************************************************
    288.             
  288. *vib_mod_exit
    289.             
  289. *
    290.             
  290. *DESCRIPTION:
    291.             
  291. *Freethedevicedriver!
    292.             
  292. *
    293.             
  293. *PARAMETERS:
    294.             
  294. *None
    295.             
  295. *
    296.             
  296. *RETURNS:
    297.             
  297. *None
    298.             
  298. *
    299.             
  299. *NOTES:
    300.             
  300. *None
    301.             
  301. *
    302.             
  302. ******************************************************************************/
    303.             
    304.             
  304. staticvoid__exitvib_mod_exit(void)
    305.             
  305. {
    306.             
  306. printk("MkMTvibratordriverunregister,version%s\n",VERSION);
    307.             
  307. printk("[vibrator]vib_mod_exitDone\n");
    308.             
  308. }
    309.             
    310.             
  310. module_init(vib_mod_init);
    311.             
  311. module_exit(vib_mod_exit);
    312.             
  312. MODULE_AUTHOR("MkInc.");
    313.             
  313. MODULE_DESCRIPTION("MTVibratorDriver(VIB)");
    314.             
  314. MODULE_LICENSE("GPL");
    315.         
  
  
<P><STRONG>SYS文件系统方式的驱动程序</STRONG></P>
  
#include <linux/module.h>#include <linux/jiffies.h>#include <linux/platform_device.h>#include <linux/workqueue.h>#include <linux/delay.h>#include <linux/gpio.h>#include <linux/i2c.h>#include <linux/lnw_gpio.h>#include <asm/intel-mid.h>
#define VIBRA_ENABLE_GPIO 91
struct vibra_info {int enabled;struct mutexlock;struct device*dev;const char*name;int gpio_en;};
/* Enable's vibra driver */static void vibra_enable(struct vibra_info *info){mutex_lock(&info->lock);gpio_set_value(info->gpio_en, 1);info->enabled = true;mutex_unlock(&info->lock);}
static void vibra_disable(struct vibra_info *info){mutex_lock(&info->lock);gpio_set_value(info->gpio_en, 0);info->enabled = false;mutex_unlock(&info->lock);}
/******************************************************************************* SYSFS  *******************************************************************************/
static ssize_t vibra_show_vibrator(struct device *dev,struct device_attribute *attr, const char *buf, size_t size){struct vibra_info *info = dev_get_drvdata(dev);
return sprintf(buf, "%d\n", info->enabled);
}
static ssize_t vibra_set_vibrator(struct device *dev, struct device_attribute *attr, const char *buf, size_t size){long vibrator_enable;struct vibra_info *info = dev_get_drvdata(dev);
if (kstrtol(buf, 10, &vibrator_enable))return -EINVAL;else if (vibrator_enable == 0)vibra_disable(info);else if (vibrator_enable == 1)vibra_enable(info);elsereturn -EINVAL;return size;}
static DEVICE_ATTR(vibrator, S_IWUSR | S_IRUGO, vibra_show_vibrator,vibra_set_vibrator);
static struct attribute *gpio_vibra_attrs[] = {&dev_attr_vibrator.attr,NULL,};
static struct attribute_group gpio_vibra_attr_group = {.attrs = gpio_vibra_attrs,};
#if CONFIG_PMstatic int vibra_runtime_suspend(struct device *dev){printk("In %s\n", __func__);return 0;}
static int vibra_runtime_resume(struct device *dev){printk("In %s\n", __func__);return 0;}
static const struct dev_pm_ops intel_mid_vibra_pm_ops = {.suspend = vibra_runtime_suspend,.resume = vibra_runtime_resume,};
#endif
static int __devinit gpio_vibra_probe(struct platform_device *pdev){struct vibra_info *info;struct mid_vibra_probe *data;int ret = 0;info = kzalloc(sizeof(*info), GFP_KERNEL);if (!info)return -ENOMEM;
info->gpio_en = VIBRA_ENABLE_GPIO;printk("using gpios en: %d", info->gpio_en);ret = gpio_request_one(info->gpio_en, GPIOF_DIR_OUT, "VIBRA ENABLE");if (ret != 0) {pr_err("gpio_request(%d) fails:%d\n", info->gpio_en, ret);goto out;}
info->name = "intel_mid:vibrator";mutex_init(&info->lock);
ret = sysfs_create_group(&pdev->dev.kobj, &gpio_vibra_attr_group);if (ret) {pr_err("Unable to export keys/switches, error: %d\n",ret);goto do_freegpio_vibra_enable;}
platform_set_drvdata(pdev, info);
return ret;do_freegpio_vibra_enable:sysfs_remove_group(&pdev->dev.kobj, &gpio_vibra_attr_group);gpio_free(info->gpio_en);out:return ret;}
static void __devexit gpio_vibra_remove(struct platform_device *pdev){struct vibra_info *info = platform_get_drvdata(pdev);gpio_free(info->gpio_en);sysfs_remove_group(&pdev->dev.kobj, &gpio_vibra_attr_group);}
static struct of_device_id gpio_vibra_of_match[] = {{ .compatible = "gpio-vibra", },{ },};MODULE_DEVICE_TABLE(of, gpio_vibra_of_match);
static struct platform_driver gpio_vibra_device_driver = {.probe= gpio_vibra_probe,.remove= __devexit_p(gpio_vibra_remove),.driver= {.name= "gpio-vibra",.owner= THIS_MODULE,#ifdef CONFIG_PM_SLEEP.pm= &intel_mid_vibra_pm_ops,#endif.of_match_table = gpio_vibra_of_match,
}};
static int __init gpio_vibra_init(void){int ret = 0;
ret = platform_driver_register(&gpio_vibra_device_driver);if (ret)pr_err("vib driver register failed\n");return ret;}static void __exit gpio_vibra_exit(void){platform_driver_unregister(&gpio_vibra_device_driver);printk("intel_mid_vibra driver exited\n");return;}
static struct platform_device vb_device = {.name= "gpio-vibra",.id= -1,.dev= {.platform_data= NULL,//&gpio_keys,},};
static int __init vibra_platform_init(void){return platform_device_register(&vb_device);}
late_initcall(vibra_platform_init);
module_init(gpio_vibra_init);module_exit(gpio_vibra_exit);
MODULE_ALIAS("gpio:intel_mid_vibra");MODULE_DESCRIPTION("gpio control Vibra driver");MODULE_LICENSE("GPL v2");
  
  
  
  
         更多    1                                                                                               







更多相关文章
	

    

  1. 开发可统计单词个数的Android驱动程序（2）
  2. Android开发平台振动器系统详解
  3. android 振动器系统
  4. Android平台中振动器系统详解



随机推荐
	

    

  1. 
Android设置对话框去除黑边
    2. 

  2. 
Android网络检测
    3. 

  3. 
Android(安卓)使用PdfDocument生成PDF文
    4. 

  4. 
Android(安卓)禁止Edittext弹出系统软键
    5. 

  5. 
Android(安卓)imageView图片按比例缩放
    6. 

  6. 
ImageView的属性android:scaleType
    7. 

  7. 
CMD命令创建、编译Android应用程序
    8. 

  8. 
ViewPager实现一个页面多个Item的显示
    9. 

  9. 
Android(安卓)VideoPlayer
    10. 

  10. 
Android(安卓)开源优秀项目
    11.