4412 gpio读取pwm

一、可以使用的GPIO管脚

去掉占用调用的GPIO驱动，包括leds，buzzer，camera ov5640，WIFI mt6620 ，Keyboards

• VIDEO_OV5640– Device Drivers
  • – Multimedia support(MEDIA_SUPPORT [=y])
  • – Video capture adapters(VIDEO_CAPTURE_DRIVERS [=y])（去掉）
• MTK_COMBO_CHIP_MT6620– Device Drivers
  • – MediaTek Connectivity Combo Chip Config
  • – MediaTek Connectivity Combo Chip Support (MTK_COMBO [=y])（去掉）
  • – Select Chip (<choice> [=y])
• Enable LEDS config– Device Drivers
  • – Character devices
  • – Enable LEDS config
• Enable BUZZER config
  • – Device Drivers
  • – Character devices
  • – Enable BUZZER config
• Enable Keyboards
  • Device Drivers  --->
  • Input device support  --->
  • Keyboards  --->

static int led_gpios[] = {
    EXYNOS4_GPL2(), EXYNOS4_GPK(),　　　　/* Led IO 2个 */
    EXYNOS4_GPD0(),　　　　　　　　　　　　　 /* BUZZER IO 1个 */

    EXYNOS4_GPX1(), EXYNOS4_GPX1(),EXYNOS4_GPX1(),EXYNOS4_GPX1(),　　　　/* 矩阵健盘8个 */
    EXYNOS4_GPX3(),EXYNOS4_GPX2(),EXYNOS4_GPX2(),EXYNOS4_GPX3(),

    EXYNOS4212_GPJ1(),EXYNOS4_GPL0(),EXYNOS4_GPL0(),EXYNOS4212_GPJ1(),　　　　　　/* 摄像头14个 */
    EXYNOS4212_GPJ1(),EXYNOS4212_GPJ1(),EXYNOS4212_GPJ0(),EXYNOS4212_GPJ0(),
    EXYNOS4212_GPJ0(),EXYNOS4212_GPJ0(),EXYNOS4212_GPJ0(),EXYNOS4212_GPJ0(),
　　 EXYNOS4212_GPJ0(),EXYNOS4212_GPJ0(),

    EXYNOS4_GPK3(),EXYNOS4_GPK3(),EXYNOS4_GPK3(),EXYNOS4_GPK3(),　　　　　　/* WIFI 7个 */
    EXYNOS4_GPK3(),EXYNOS4_GPK3(),EXYNOS4_GPC1(),
};

led_gpios数组

二、设计思路

• 通过外部中断来处理电路上升沿和下降沿的跳变处理
• 通过读取IO管脚，来判断是上升沿触发还是下降沿触发
• 使用do_gettimeofday来获取时间戳，从而计算高电平时间

下面是我的源码：

#include <linux/init.h>
#include <linux/module.h>

/* */
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>

#include <linux/gpio.h>
#include <plat/gpio-cfg.h>
#include <mach/gpio.h>
#include <mach/gpio-exynos4.h>

#include <asm/uaccess.h>
#include <linux/irq.h>
#include <linux/interrupt.h>

#include <linux/time.h>

#define DRIVER_NAME "ReadPwm"
#define DEVICE_NAME "read_pwm"

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("TOPEET");

#define GPIO_CHG_FLT    EXYNOS4_GPX1(0)

static int up_flag = ;
struct platform_device *dev_int;
/* led: KP_COL0, VDD50_EN */
/* BUZZER: MOTOR_PWM */
/* keyboards: CHG_FLT, HOOK_DET, CHG_UOK, XEINT14_BAK, GM_INT1,
    6260_GPIO1, CHG_COK, XEINT29/KP_ROW13/ALV_DBG25 */
/* camera: CAM_MCLK, CAM2M_RST, CAM2M_PWDN, CAM_D5, CAM_D7, CAM_D6,
    CAM_D4, CAM_D3, CAM_D2, CAM_D1, CAM_PCLK, CAM_D0, CAM_VSYNC, CAM_HREF */
/* WIFI: WIFI_D3, WIFI_CMD, WIFI_D1, WIFI_CLK, WIFI_D0, WIFI_D2,GPC1_1 */
struct timeval tv_begin, tv_end;
static int interval = ;
struct semaphore sem;

static irqreturn_t qint8_interrupt(int irq, void *dev_id)
{
    int ret;
    ret = gpio_get_value(GPIO_CHG_FLT);
    if(ret == ) {
        do_gettimeofday(&tv_end);
        if(tv_end.tv_usec - tv_begin.tv_usec > ) {
            down(&sem);
            interval = tv_end.tv_usec - tv_begin.tv_usec;
            up(&sem);
        }
        // if(printk_ratelimit()) {
        //     printk("tv_end.usec:%d - tv_begin.usec:%d =\n%d\n", tv_end.usec,
        //         tv_begin.usec, tv_end.usec - tv_begin.usec);
        // }
    } else if(ret == ) {
        do_gettimeofday(&tv_begin);
    }
    return IRQ_HANDLED;
}

static int read_pwm_open(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "read pwm open\n");
    return ;
}

static int read_pwm_release(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "read pwm release\n");
    return ;
}

static ssize_t read_pwm_read(struct file *filp, char __user *buff, size_t size, loff_t *ppos)
{
    unsigned int key_value = ;
    char temp[];
    int ret;
    // printk(KERN_EMERG "sizeof(key_value) is %d\n", sizeof(key_value));
    if(size != sizeof(temp)) {
        return -;
    }
    down(&sem);
    key_value = interval;
    up(&sem);

    temp[] = ((key_value)&0xff);
    temp[] = ((key_value>>)&0xff);

    ret = copy_to_user(buff, temp, sizeof(temp));

    return ret;
}

static struct file_operations read_pwm_ops = {
    .owner      = THIS_MODULE,
    .open       = read_pwm_open,
    .release    = read_pwm_release,
    .read       = read_pwm_read,
};

static struct miscdevice read_pwm_dev = {
    .minor  = MISC_DYNAMIC_MINOR,
    .name   = DEVICE_NAME,
    .fops   = &read_pwm_ops,
};

static int read_pwm_probe(struct platform_device *pdv)
{
    int ret;
    printk(KERN_EMERG "\tread pwm start initialized\n");
    /* set up gpio */
    // ret = gpio_request(GPIO_CHG_FLT, "GPX1_0");
    // if(ret < 0) {
    //     printk(KERN_EMERG "request GPIO %d for read pwm failed\n", GPIO_CHG_FLT);
    //     return ret;
    // }

    // s3c_gpio_cfgpin(GPIO_CHG_FLT, S3C_GPIO_INPUT);
    // s3c_gpio_setpull(GPIO_CHG_FLT, S3C_GPIO_PULL_NONE);
    ret = request_irq(IRQ_EINT(), qint8_interrupt, IRQ_TYPE_EDGE_BOTH, "my_eint8", pdv);
    if(ret < ) {
        printk(KERN_EMERG "request irq 8 failed.\n");
        return ;
    }
    up_flag = ;
    dev_int = pdv;
    sema_init(&sem, );
    /* register */
    ret = misc_register(&read_pwm_dev);
    if(ret < ) {
        gpio_free(GPIO_CHG_FLT);
        misc_deregister(&read_pwm_dev);
        return -EINVAL;
    }

    return ;
}

static int read_pwm_remove(struct platform_device *pdv)
{
    printk(KERN_EMERG "\tread pwm remove\n");

    // gpio_free(GPIO_CHG_FLT);
    free_irq(IRQ_EINT(), pdv);
    misc_deregister(&read_pwm_dev);
    return ;
}

static void read_pwm_shutdown(struct platform_device *pdv)
{

}

static int read_pwm_suspend(struct platform_device *pdv, pm_message_t pmt)
{
    return ;
}

static int read_pwm_resume(struct platform_device *pdv)
{
    return ;
}

struct platform_driver read_pwm_driver = {
    .probe      = read_pwm_probe,
    .remove     = read_pwm_remove,
    .shutdown   = read_pwm_shutdown,
    .suspend    = read_pwm_suspend,
    .resume     = read_pwm_resume,
    .driver = {
        .name   = DRIVER_NAME,
        .owner  = THIS_MODULE,
    }
};

static int read_pwm_init(void)
{
    int DriverState;

    printk(KERN_EMERG "Read pwm init enter!\n");
    DriverState = platform_driver_register(&read_pwm_driver);

    printk(KERN_EMERG "\tDriverState is %d\n", DriverState);
    return ;
}

static void read_pwm_exit(void)
{
    printk(KERN_EMERG "Read pwm exit!\n");
    platform_driver_unregister(&read_pwm_driver);
}

module_init(read_pwm_init);
module_exit(read_pwm_exit);

read_pwm.c

还有一个问题，卸载模块后再装载就会报错，不知道为什么。

app源码：

#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>

#define READ_PWM "/dev/read_pwm"

int main()
{
    long value = ;
    int fd;
    char buff[];
    int ret;

    fd = open(READ_PWM, O_RDWR|O_NDELAY);
    if(fd < ) {
        perror("open");
    }

    while(ret = read(fd, buff, sizeof(buff)) >= ) {
        printf("value is %d\n", buff[]|buff[]<<);
        usleep();
    }
    printf("sizeof(value) is %d\n", sizeof(buff));
    printf("read return is %d\n", ret);
    return ;
}

read_pwm_app