嵌入式学习——硬件（Linux内核驱动编程platform、内核定时器、DS18B20）——day61

1. platform驱动框架

1.1 设备device

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

void led_release(struct device *dev)
{
	printk("leds has been released\n");
}

static struct resource led_resources[] = 
{
	[0] = 
	{
		.start = 0x56000010,
		.end = 0x56000010 + 8,
		.name = "led1~4",
		.flags = IORESOURCE_IO
	}
};

struct platform_device led_device = 
{
	.name = "Mini2440_leds",
	.id = -1,
	.dev = 
	{
		.release = led_release
	},
	.resource = led_resources,
	.num_resources = ARRAY_SIZE(led_resources)
};

static int __init led_device_init(void)
{
	return platform_device_register(&led_device);
}

static void __exit led_device_exit(void)
{
	platform_device_unregister(&led_device);
}

module_init(led_device_init);
module_exit(led_device_exit);

MODULE_LICENSE("GPL");

1.2 驱动driver

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <asm/io.h>

unsigned int *regGPBCON;
unsigned int *regGPBDAT;
int led_driver_open(struct inode *p_node, struct file *fp)
{
	printk("open\n");
	return 0;
}

ssize_t led_driver_read(struct file *fp, char __user *user_buffer, size_t n, loff_t * offset)
{
	printk("read\n");
	return 0;
}

void ledOn(unsigned int n)
{
	 *regGPBDAT |= (0x0F << 5);
	if(n < 1 || n > 4)
	{
		return;
	}
	*regGPBDAT &= ~(1 << (n + 4));
}

ssize_t led_driver_write(struct file *fp, const char __user *user_buffer, size_t n, loff_t *offset)
{
	char s[10];
	
	copy_from_user(s, user_buffer, n);
	ledOn(s[0]);

	printk("write\n");
	return n;
}

int led_driver_close(struct inode *p_node, struct file *fp)
{
	printk("close\n");
	return 0;
}

struct file_operations fops =
{
	.owner = THIS_MODULE,
	.release = led_driver_close,
	.open = led_driver_open,
	.read = led_driver_read,
	.write = led_driver_write,
};

static struct miscdevice led_dev = 
{
	.minor = MISC_DYNAMIC_MINOR,
	.fops = &fops,
	.name = "led"
};

static  int led_probe(struct platform_device *dev)
{
	int ret ;
	unsigned int GPBCON;
	printk("led_probe\n");
	ret = misc_register(&led_dev);
	if(ret)
	{
		return ret;
	}

	GPBCON = dev->resource[0].start;
	regGPBCON = ioremap(GPBCON, 8);
	regGPBDAT = regGPBCON + 1;

	*regGPBCON &= ~((3 << 10) | (3 << 12) | (3 << 14) | (3 << 16));
	*regGPBCON |= (1 << 10) | (1 << 12) | (1 << 14) | (1 << 16);

	 *regGPBDAT |= (0x0F << 5);

	return 0;
}

int led_remove(struct platform_device *dev)
{
	printk("led_remove\n");
	misc_deregister(&led_dev);
	return 0;
}

static struct platform_driver led_driver = 
{
	.driver = 
	{
		.name = "Mini2440_leds",
		.owner = THIS_MODULE
	},
	.probe = led_probe,
	.remove = led_remove

};

static int __init led_driver_init(void)
{
	return platform_driver_register(&led_driver);
}

static void __exit led_driver_exit(void)
{
	platform_driver_unregister(&led_driver);
}

module_init(led_driver_init);
module_exit(led_driver_exit);

MODULE_LICENSE("GPL");

2. 内核定时器驱动——（3秒延时）

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

static struct timer_list tl;

void timeout(unsigned long n)
{
	printk("timeout : %lu\n", jiffies);
	tl.data = jiffies;
	mod_timer(&tl, jiffies + 3 * HZ);
}

static int __init timer_driver_init(void)
{
	init_timer(&tl);	
	tl.function = timeout;
	tl.data = jiffies;
	tl.expires = jiffies + 3 * HZ;
	add_timer(&tl);

	return 0;
}

static void __exit timer_driver_exit(void)
{
	del_timer(&tl);
}

module_init(timer_driver_init);
module_exit(timer_driver_exit);

MODULE_LICENSE("GPL");