高通平台怎样不用设备树 强制设置一个gpio端口
----------------------------------------------------------------------
#define VIB_CONTROL_GPIO 46
gpio_direction_output(VIB_CONTROL_GPIO, 0);
----------------------------------------------------------------------
马达驱动例子：
#include <linux/gpio.h>
#include <linux/wakelock.h>
#include <linux/mutex.h>
#include <linux/clk.h>
#include <linux/workqueue.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/hrtimer.h>
#include <linux/ktime.h>
#include <linux/of_device.h>
#include <linux/interrupt.h>
#include <linux/err.h>
#include <linux/delay.h>
#include<../staging/android/timed_output.h>
#define VIB_CONTROL_GPIO 46
#define MAX_TIMEOUT 10000 /* open max time 5 seconds */
static void gpvib_enable(struct timed_output_dev *sdev, int value);
static int gpvib_get_time(struct timed_output_dev *sdev);
static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer);
static void gpvib_off(void);
static struct vibrator {
struct wake_lock wklock;
struct hrtimer timer;
//struct mutex lock;
struct work_struct work;
}vibdata;
static void gpvib_off(void)
{
gpio_direction_output(VIB_CONTROL_GPIO, 0);
wake_unlock(&vibdata.wklock);
}
static void vibrator_work(struct work_struct *work)
{
gpvib_off();
}
static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
{
schedule_work(&vibdata.work);
return HRTIMER_NORESTART;
}
static void gpvib_enable(struct timed_output_dev *sdev, int value)
{
//printk(KERN_ERR "liuyu %s,%d\n",__func__,__LINE__);
//mutex_lock(&vibdata.lock);
hrtimer_cancel(&vibdata.timer);
cancel_work_sync(&vibdata.work);
//printk(KERN_ERR "liuyu %s,%d\n",__func__,__LINE__);
//WARN_ON(1);
if (value > 0)
{
wake_lock(&vibdata.wklock);
gpio_direction_output(VIB_CONTROL_GPIO, 1);
value = (value > MAX_TIMEOUT ? MAX_TIMEOUT : value);
hrtimer_start(&vibdata.timer, ktime_set(value / 1000, (value % 1000) * 1000000), HRTIMER_MODE_REL);
//printk(KERN_ERR "liuyu %d\n",gpio_get_value(VIB_CONTROL_GPIO));
//mutex_destroy(&vibdata.lock);
}else{
//printk(KERN_ERR "liuyu value =0\n");
gpvib_off();
//mutex_destroy(&vibdata.lock);
}
}
static int gpvib_get_time(struct timed_output_dev *sdev)
{
if (hrtimer_active(&vibdata.timer))
{
ktime_t r = hrtimer_get_remaining(&vibdata.timer);
return ktime_to_ms(r);
}else
return 0;
}
static struct timed_output_dev gpvib_driver = {
.name = "vibrator",
.enable = gpvib_enable,
.get_time = gpvib_get_time,
};
static int __init gpvib_moudle_init(void)
{
int ret = 0;
hrtimer_init(&vibdata.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
vibdata.timer.function = vibrator_timer_func;
INIT_WORK(&vibdata.work, vibrator_work);
//printk(KERN_ERR "liuyu %s,%d\n",__func__,__LINE__);
ret = gpio_request(VIB_CONTROL_GPIO, "vibrator_en");
if (ret)
{
printk(KERN_ERR "liuyu request gpio failed\n");
return ret;
}
wake_lock_init(&vibdata.wklock, WAKE_LOCK_SUSPEND, "vibrator");
//mutex_init(&vibdata.lock);
ret = timed_output_dev_register(&gpvib_driver);
if (ret < 0)
{
printk(KERN_ERR "liuyu register timed_output_dev vibrator failed\n");
goto free_gpvib_dev;
}
printk(KERN_ERR "probe successfully %s,%d\n",__func__,__LINE__);
return 0;
free_gpvib_dev:
//mutex_destroy(&vibdata.lock);
wake_lock_destroy(&vibdata.wklock);
gpio_free(VIB_CONTROL_GPIO);
return ret;
}
module_init(gpvib_moudle_init);
static void __exit gpvib_moudle_exit(void)
{
wake_lock_destroy(&vibdata.wklock);
//mutex_destroy(&vibdata.lock);
gpio_free(VIB_CONTROL_GPIO);
//printk(KERN_ERR "liuyu %s,%d\n",__func__,__LINE__);
timed_output_dev_unregister(&gpvib_driver);
}
module_exit(gpvib_moudle_exit);
MODULE_AUTHOR(ZLY);
MODULE_DESCRIPTION("gpio vibrator driver");
MODULE_LICENSE("GPL v2");