142 lines
3.7 KiB
C
Executable File
142 lines
3.7 KiB
C
Executable File
|
||
#include <linux/module.h> /* Needed by all modules */
|
||
#include <linux/kernel.h> /* Needed for KERN_INFO */
|
||
#include <linux/init.h> /* Needed for the macros */
|
||
#include <linux/fs.h>
|
||
#include <asm/uaccess.h> /* for put_user */
|
||
|
||
|
||
#define DEVICE_NAME "one"
|
||
|
||
|
||
static char outputchar = '1';
|
||
/*
|
||
* module_param(foo, int, 0000)
|
||
* The first param is the parameters name
|
||
* The second param is it's data type
|
||
* The final argument is the permissions bits,
|
||
* for exposing parameters in sysfs (if non−zero).
|
||
* e.g. change outputchar to 'a' with "echo "97" > /sys/module/one/parameter/outputchar"
|
||
*/
|
||
module_param(outputchar, byte, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP );
|
||
MODULE_PARM_DESC(outputchar, "Character that will be output by the device file");
|
||
|
||
static int major; /* Major number assigned to our device driver */
|
||
static int device_opened = 0;
|
||
|
||
/*
|
||
* Prototypes − this would normally go in a .h file
|
||
*/
|
||
static int one_init(void);
|
||
static void one_exit(void);
|
||
static int one_open(struct inode *, struct file *);
|
||
static int one_release(struct inode *, struct file *);
|
||
static ssize_t one_read(struct file *, char *, size_t, loff_t *);
|
||
static ssize_t one_write(struct file *, const char *, size_t, loff_t *);
|
||
|
||
|
||
static struct file_operations fops =
|
||
{
|
||
.owner = THIS_MODULE,
|
||
.read = one_read,
|
||
.write = one_write,
|
||
.open = one_open,
|
||
.release = one_release
|
||
};
|
||
|
||
static int __init one_init(void)
|
||
{
|
||
printk(KERN_INFO "Hello World from module one\n");
|
||
|
||
major = register_chrdev(0, DEVICE_NAME, &fops);
|
||
if (major < 0)
|
||
{
|
||
printk(KERN_ALERT "Error in register_chrdev:%d\n", major);
|
||
return major;
|
||
}
|
||
|
||
printk(KERN_INFO "I was assigned major number %d.\n", major);
|
||
printk(KERN_INFO "Execute \"mknod /dev/one c %d 0\" to create device file.\n", major);
|
||
return 0;
|
||
}
|
||
|
||
|
||
static void __exit one_exit(void)
|
||
{
|
||
// Unregister the device
|
||
unregister_chrdev(major, DEVICE_NAME);
|
||
|
||
printk(KERN_INFO "Goodbye World from module one\n");
|
||
}
|
||
|
||
/*
|
||
* Called when a process tries to open the device file, like
|
||
* "cat /dev/mycharfile"
|
||
*/
|
||
static int one_open(struct inode *inode, struct file *file)
|
||
{
|
||
if (device_opened)
|
||
return -EBUSY;
|
||
device_opened++;
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Called when a process closes the device file.
|
||
*/
|
||
static int one_release(struct inode *inode, struct file *file)
|
||
{
|
||
device_opened--; /* We're now ready for our next caller */
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Called when a process, which already opened the dev file, attempts to read from it.
|
||
*/
|
||
static ssize_t one_read( struct file *filp, /* see include/linux/fs.h */
|
||
char *buffer, /* buffer to fill with data */
|
||
size_t length, /* length of the buffer */
|
||
loff_t * offset)
|
||
{
|
||
/*
|
||
* Number of bytes actually written to the buffer
|
||
*/
|
||
int bytes_read = 0;
|
||
// Copying data to the buffer
|
||
int i;
|
||
for (i = 0; i < length; i++)
|
||
{
|
||
/*
|
||
* The buffer is in the user data segment, not the kernel
|
||
* segment so "*" assignment won't work. We have to use
|
||
* put_user which copies data from the kernel data segment to
|
||
* the user data segment.
|
||
*/
|
||
put_user(outputchar, buffer++);
|
||
bytes_read++;
|
||
}
|
||
/*
|
||
* Most read functions return the number of bytes put into the buffer
|
||
* return 0 would signify end of file
|
||
*/
|
||
return bytes_read;
|
||
}
|
||
|
||
|
||
/*
|
||
* Called when a process writes to dev file: echo "hi" > /dev/hello
|
||
*/
|
||
static ssize_t one_write(struct file *filp, const char *buff, size_t len, loff_t * off)
|
||
{
|
||
printk(KERN_ALERT "Sorry, write isn't supported.\n");
|
||
return -EINVAL;
|
||
}
|
||
|
||
|
||
module_init(one_init);
|
||
module_exit(one_exit);
|
||
|
||
MODULE_LICENSE("Some License");
|
||
MODULE_AUTHOR("Matthias Janetschek"); /* Who wrote this module? */
|
||
MODULE_DESCRIPTION("An example module"); /* What does this module do */
|