drivers/testcode/gpio_wave.c

   1 #include <linux/delay.h>\r
   2 #include <linux/platform_device.h>\r
   3 #include <linux/clk.h>\r
   4 #include <mach/gpio.h>\r
   5 #include <linux/wakelock.h>\r
   6 \r
   7 #include "gpio_wave.h"\r
   8 \r
   9 struct wave_data {\r
  10         struct delayed_work d_work;\r
  11         int Htime;\r
  12         int Ltime;\r
  13         unsigned int gpio;\r
  14         int cur_value;\r
  15         int last_value;\r
  16         struct device *dev;  \r
  17 };\r
  18 \r
  19 static struct wake_lock w_lock;\r
  20 \r
  21 static void gpio_wave_dwork_handle(struct work_struct *work)\r
  22 {\r
  23         struct wave_data *data = (struct wave_data *)container_of(work, struct wave_data, d_work.work);\r
  24         \r
  25         int delay_time = data->cur_value ? data->Ltime : data->Htime;\r
  26         data->cur_value = !data->cur_value;\r
  27         gpio_set_value(data->gpio, data->cur_value);\r
  28         schedule_delayed_work(&(data->d_work), msecs_to_jiffies(delay_time));\r
  29 }\r
  30 \r
  31 \r
  32 static int gpio_wave_probe(struct platform_device *pdev)\r
  33 {\r
  34         int ret;\r
  35         struct wave_data *data;\r
  36         struct gpio_wave_platform_data *pdata = pdev->dev.platform_data;\r
  37 \r
  38         data = kmalloc(sizeof(struct wave_data), GFP_KERNEL);\r
  39         if (!data) {\r
  40                 printk("func %s, line %d, malloc fail\n", __func__, __LINE__);\r
  41                 return -ENOMEM;\r
  42         }\r
  43 \r
  44         data->dev = &pdev->dev;\r
  45         platform_set_drvdata(pdev, data);\r
  46         \r
  47         if (pdata) {\r
  48                 int dtime = pdata->Dvalue ? pdata->Htime : pdata->Ltime;\r
  49                 data->gpio = pdata->gpio;\r
  50                 data->cur_value = pdata->Dvalue;\r
  51                 data->last_value = pdata->Dvalue;\r
  52                 data->Htime = pdata->Htime;\r
  53                 data->Ltime = pdata->Ltime;\r
  54                 \r
  55                 ret = gpio_request(data->gpio, NULL);\r
  56                 if (ret) {\r
  57                         printk("func %s, line %d, gpio request err\n", __func__, __LINE__);\r
  58                         return ret;\r
  59                 }\r
  60                 gpio_direction_output(data->gpio, data->cur_value);\r
  61                 gpio_set_value(data->gpio, data->cur_value);\r
  62                 wake_lock_init(&w_lock, WAKE_LOCK_SUSPEND, "gpio_wave");\r
  63                 INIT_DELAYED_WORK(&(data->d_work), gpio_wave_dwork_handle);\r
  64                 wake_lock(&w_lock);\r
  65                 schedule_delayed_work(&(data->d_work), msecs_to_jiffies(dtime));\r
  66         }\r
  67         else {\r
  68                 kfree(data);\r
  69         }\r
  70         \r
  71         return 0;\r
  72 }\r
  73 \r
  74 static int gpio_wave_remove(struct platform_device *pdev)\r
  75 {\r
  76         struct wave_data *data = platform_get_drvdata(pdev);\r
  77         gpio_free(data->gpio);\r
  78         kfree(data);\r
  79         return 0;\r
  80 }\r
  81 \r
  82 static struct platform_driver gpio_wave_driver = {\r
  83         .probe          = gpio_wave_probe,\r
  84         .remove         = gpio_wave_remove,\r
  85         .driver         = {\r
  86                 .owner  = THIS_MODULE,\r
  87                 .name   = "gpio_wave",\r
  88         },\r
  89 };\r
  90 \r
  91 static int __init gpio_wave_init(void)\r
  92 {\r
  93         return platform_driver_register(&gpio_wave_driver);\r
  94 }\r
  95 \r
  96 static void __exit gpio_wave_exit(void)\r
  97 {\r
  98         platform_driver_unregister(&gpio_wave_driver);\r
  99 }\r
 100 \r
 101 \r
 102 module_init(gpio_wave_init);\r
 103 module_exit(gpio_wave_exit);\r
 104 \r
 105 MODULE_DESCRIPTION("Driver for gpio wave");\r
 106 MODULE_AUTHOR("lyx, lyx@rock-chips.com");\r
 107 MODULE_LICENSE("GPL");\r
 108 \r