Linux驱动-platform设备

一、beep_device.c
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/ioport.h>

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("cherrying");
MODULE_DESCRIPTION("A simple led module");
MODULE_ALIAS("A simple module");

static void beep_release(struct device *dev);
static int beep_device_init(void);
static void beep_device_exit(void);

static struct resource beep_resource[] = {
    [0] = {
    .start = 0xE02000A0,
    .end = 0xE02000A0 + 0x4,
    .flags = IORESOURCE_MEM,}
};
static struct platform_device beep_device = {
    .name = "beep",
    .id = -1,
    .dev.release = beep_release,
    .num_resources = ARRAY_SIZE(beep_resource),
    .resource = beep_resource,
};

static void beep_release(struct device *dev)
{
    printk("beep_release\n");
}

static int beep_device_init(void)
{
    printk("beep_device_init\n");
    return platform_device_register(&beep_device);
}

static void beep_device_exit(void)
{
    printk("beep_device_exit\n");
    platform_device_unregister(&beep_device);
}

module_init(beep_device_init);
module_exit(beep_device_exit);

二、beep_driver.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/uaccess.h>

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("cherrying");
MODULE_DESCRIPTION("A simple beep module");
MODULE_ALIAS("A simple module");

static int beep_register_chrdev(void);
static void beep_unregister_chrdev(void);
static int beep_gpio_request(void);
static void beep_gpio_free(void);
static long beep_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
static ssize_t beep_write(struct file *filp, const char __user *buf, size_t count, loff_t *poffset);
static int beep_driver_init(void);
static void beep_driver_exit(void);
static int beep_probe(struct platform_device *pdev);
static int beep_remove(struct platform_device *pdev);

static struct cdev beep_cdev;
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .unlocked_ioctl = beep_unlocked_ioctl,
    .write = beep_write};
static dev_t beep_devno;
static struct class *p_beep_class;
static struct device *p_beep_device;
static int beep_status = 1;
static struct platform_driver beep_driver = {
    .driver.name = "beep",
    .probe = beep_probe,
    .remove = beep_remove,
};

static int beep_probe(struct platform_device *pdev)
{
    beep_register_chrdev();
    beep_gpio_request();
    return 0;
}

static int beep_remove(struct platform_device *pdev)
{
    beep_unregister_chrdev();
    beep_gpio_free();
    return 0;
}

static int beep_register_chrdev(void)
{
    //register_chrdev()
    cdev_init(&beep_cdev, &beep_fops);
    if(alloc_chrdev_region(&beep_devno, 0, 1, "beep") < 0){
        printk(KERN_WARNING "allow_chrdev_region() faild!\n");
        return -1;
    }
    beep_cdev.dev = beep_devno;
    if(cdev_add(&beep_cdev, beep_devno, 1) < 0){
        printk(KERN_WARNING "cdev_add() faild!\n");
        unregister_chrdev_region(beep_devno, 1);
        return -1;
    }
    p_beep_class = class_create(THIS_MODULE, "beep");
    if(IS_ERR(p_beep_class)){
        printk(KERN_WARNING "class_create() faild!\n");
        cdev_del(&beep_cdev);
        unregister_chrdev_region(beep_devno, 1);
        return -EBUSY;
    }
    p_beep_device = device_create(p_beep_class, NULL, beep_devno, NULL, "beep");
    if(IS_ERR(p_beep_device)){
        printk(KERN_WARNING "device_create() faild!\n");
        class_destroy(p_beep_class);
        cdev_del(&beep_cdev);
        unregister_chrdev_region(beep_devno, 1);
        return -EBUSY;
    }
    printk(KERN_ALERT "beep_register_chrdev() successful!\n");
    return 0;
}

static void beep_unregister_chrdev(void)
{
    device_destroy(p_beep_class, beep_devno);
    class_destroy(p_beep_class);
    cdev_del(&beep_cdev);
    unregister_chrdev_region(beep_devno, 1);
    printk(KERN_ALERT "beep_unregister_chrdev() successful!\n");
    //unregister_chrdev();
}

static int beep_gpio_request(void)
{
    if(gpio_request(S5PV210_GPD0(0), "beep")){
        printk(KERN_ERR "gpio_request() faild!\n");
        return -1;
    }
    gpio_direction_output(S5PV210_GPD0(0), 1);
    gpio_set_value(S5PV210_GPD0(0), beep_status);
    return 0;
}

static void beep_gpio_free(void)
{
    gpio_free(S5PV210_GPD0(0));
}

static long beep_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    if(cmd > 0){
        return -EINVAL;
    }
    if(arg == 0 || arg == 1){
        gpio_set_value(S5PV210_GPD0(cmd), arg);
    }
    return 0;
}

static ssize_t beep_write(struct file *filp, const char __user *buf, size_t count, loff_t *poffset)
{
    size_t buf_len = count;
    unsigned char kern_mem = 0;
    if(count > 1){
        buf_len = 1;
    }
    if(copy_from_user(&kern_mem, buf, 1)){
        printk(KERN_WARNING "copy_from_user() faild!\n");
        return -EFAULT;
    }
    if(kern_mem == '1'){
        gpio_set_value(S5PV210_GPD0(0), 1);
    }    
    else{
        gpio_set_value(S5PV210_GPD0(0), 0);
    }
    return 0;
}

static int beep_driver_init(void)
{
    printk("beep_driver_init\n");
    return platform_driver_register(&beep_driver);
}

static void beep_driver_exit(void)
{
    printk("beep_driver_exit\n");
    platform_driver_unregister(&beep_driver);
}

module_init(beep_driver_init);
module_exit(beep_driver_exit);