平台demo

 #ifndef __GPIO_BUTTONS_H__
 #define __GPIO_BUTTONS_H__


struct gpio_button
 {
int code;//按键值
char *desc;//描述信息
int gpio;//对应的管脚编号
 };

 #endif

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/plarform_device.h>
 #include <asm/gpio.h>
 #include <plat/gpio-cfg.h>

 #include "gpio_buttons.h"

MODULE_LICENSE("GPL");

 struct resources button_resource[] ={
{
.start = IRQ_EINT0,
.end = IRQ_EINT0,
/*定义资源类型*/
flags = IORESOURCE_IRQ,
},
{
.start = IRQ_EINT0,
.end = IRQ_EINT0,
/*定义资源类型*/
flags = IORESOURCE_IRQ,
},
{
.start = IRQ_EINT0,
.end = IRQ_EINT0,
/*定义资源类型*/
flags = IORESOURCE_IRQ,
},
 };


 struct gpio_button gpio_buttons[] ={
{
.code = KEY_UP,
.desc = "up"
.gpio = s5pv210_gpio(3);
  },
  {
.code = KEY_UP,
.desc = "up"
.gpio = s5pv210_gpio(3);
  },
  {
.code = KEY_UP,
.desc = "up"
.gpio = s5pv210_gpio(3);
  },
 };


 void gpio_button_release(struct device *dev){
printk("enter gpio_btton_release!\n");
 }


 struct platform_device button_dev = {
.name = "mybutton"
.resource = button_resource,
.num_resource = ARRAY_SIZE(button_resource);
.dev =
{
.platform_data = gpio_buttons,
.release = gpio_button_release,
},
 };




 int __init button_dev_init(void)
 {
  platform_device_register(&button_dev);
return 0;
 }


void __exit button_dev_exit(void)
{
platform_device_unregister(&button_dev);
}




module_init(button_dev_init);
module_init(button_dev_exit);






struct input_dev *buttons_dev = NULL;
struct timer_list buttons_timer;


struct gpio_button *irq_button_data = NULL;




irqreturn_t buttons_isr(int irq,void *dev_id)
{
irq_button_data = (volatile struct gpio_button *)dev_id;
mod_timer(&buttons_timer,jiffies+HZ/100);


return IRQ_HANDLED;

}


void buttons_timer_function(unsigned long data)
{
unsigned int pinval;


volatile struct gpio_button *pindesc = irq_button_data;


if(!pindesc)
{
return ;
}


pinval= gpio_get_value(pindesc->gpio);
if(pinval)
{
/*释放*/
input_event(buttons_dev,EV_KEY,pindesc->code,0);
input_event(buttons_dev,EV_SYN,0,0);
}else{
input_event(buttons_dev,EV_KEY,pindesc->code,1);
input_event(button_dev,EV_SYN,0,0);
}




}
int button_probe(struct platform_device *pdev)
{
int i=0;
int ret = 0;
struct resources *res = NULL;


struct gpio_button *data = pdev->dev.platform_data;


buttons_dev = input_allocate_device();


set_bit(EV_KEY,button_dev->evbit);
set_bit(EV_SYN,button_dev->evbit);
set_bit(EV_REP,button_dev->evbit);


for(;i<pdev->num_resources,i++){
set_bit(data[i].code,buttons_dev->keybit);


/*获取一个资源
*dev制定从哪个platform_device获取资源
*type
*/
res = platform_get_resource(pdev,IORESOURCE_IRQ, i);
/*注册中断*/
request_irq(res->start, buttons_isr, 
IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
data[i].desc, &(data[i]))
}


ret = input_reset_device(buttons_dev);
init_timer(&buttons_timer);
buttons_timer.function = buttons_timer_function;
add_timer(&buttons_timer);
 
         


//ffstruct gpio_button *data = 

return 0;
}


int button_remove(struct platform_device *dev)
{
int i = 0;
struct resources *res = NULL;
struct gpio_button *data = pdev->dev.platform_data;


del_timer(&buttons_timer);


input_unregister_device(buttons_dev);
for(;i<pdev->num_resources;i++){
res = platform_get_resource(pdev,IORESOURCE_IRQ, i)
free_irq(res->start,data+i);
}


input_free_device(pdev);
return 0;
}


struct platform_driver button_drv ={
.probe = button_probe,
.remove = button_remove,
.driver = {
.name = "mybutton",
}
};


int __init button_drv_init(void)
{
platform_driver_register(&button_drv);
return 0;
}


void __exit button_drv_exit(void)
{
platform_driver_unregister(&button_drv);
}




module_init(button_drv_exit);
module_init(button_drv_init);