Christopher Hallinan - Embedded Linux Primer - A Practical, Real-World Approach

}

static ssize_t hello_write(struct file *file, const char *buf, size_t count, loff_t * ppos) {

printk("hello_read: accepting zero bytes\n");

return 0;

}

static int hello_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) {

printk("hello_ioctl: cmd=%ld, arg=%ld\n", cmd, arg);

return 0;

}

static int __init hello_init(void) {

int ret;

printk("Hello Example Init - debug mode is %s\n", debug_enable ? "enabled" : "disabled");

ret = register_chrdev(HELLO_MAJOR, "hello1", &hello_fops);

if (ret < 0) {

printk("Error registering hello device\n");

goto hello_fail1;

}

printk("Hello: registered module successfully!\n");

/* Init processing here... */

return 0;

hello_fail1:

return ret;

}

static void __exit hello_exit(void) {

printk("Hello Example Exit\n");

}

struct file_operations hello_fops = {

owner: THIS_MODULE,

read: hello_read,

write: hello_write,

ioctl: hello_ioctl,

open: hello_open,

release: hello_release,

};

module_init(hello_init);

module_exit(hello_exit);

MODULE_AUTHOR("Chris Hallinan");

MODULE_DESCRIPTION("Hello World Example");

MODULE_LICENSE("GPL");

This expanded device driver example includes many new lines. From the top, we've had to add a new kernel header file to get the definitions for the file system operations. We've also defined a major number for our device driver. ( Note to device driver authors: This is not the proper way to allocate a device driver major number. Refer to the Linux kernel documentation (.../Documentation/devices.txt) or one of the excellent texts on device drivers for guidance on the allocation of major device numbers. For this simple example, we simply choose one that we know isn't in use on our system.)

Next we see definitions for four new functions, our open, close, read, and write methods. In keeping with good coding practices, we've adopted a consistent naming scheme that will not collide with any other subsystems in the kernel. Our new methods are called hello_open(), hello_release(), hello_read(), and hello_write(), respectively. For purposes of this simple exercise, they are do-nothing functions that simply print a message to the kernel log subsystem.

Notice that we've also added a new function call to our hello_init() routine. This line registers our device driver with the kernel. With that registration call, we pass a structure containing pointers to the required methods. The kernel uses this structure, of type struct file_operations, to bind our specific device functions with the appropriate requests from the file system. When an application opens a device represented by our device driver and requests a read() operation, the file system associates that generic read() request with our module's hello_read() function. The following sections examine this process in detail.

To understand how an application binds its requests to a specific device represented by our device driver, we must understand the concept of a device node. A device node is a special file type in Linux that represents a device. Virtually all Linux distributions keep device nodes in a common location (specified by the Filesystem Hierarchy Standard [66] Reference to this standard is found in the " Suggestions for Additional Reading," at the end of this chapter. ), in a directory called /dev. A dedicated utility is used to create a device node on a file system. This utility is called mknod.

An example of node creation is the best way to illustrate its functionality and the information it conveys. In keeping with our simple device driver example, let's create the proper device node to exercise it:

$ mknod /dev/hello1 c 234 0

After executing this command on our target embedded system, we end up with a new file called /dev/hello1 that represents our device driver module. If we list this file to the console, it looks like this:

$ ls -l /dev/hello1

crw-r--r-- 1 root root 234, 0 Jul 14 2005 /dev/hello1

The parameters we passed to mknod include the name, type, and major and minor numbers for our device driver. The name we chose, of course, was hello1. Because we are demonstrating the use of a character driver, we use c to indicate that. The major number is 234, the number we chose for this example, and the minor number is 0.

By itself, the device node is just another file on our file system. However, because of its special status as a device node, we use it to bind to an installed device driver. If an application process issues an open() system call with our device node as the path parameter, the kernel searches for a valid device driver registered with a major number that matches the device nodein our case, 234. This is the mechanism by which the kernel associates our particular device to the device node.

As most C programmers know, the open() system call, or any of its variants, returns a reference (file descriptor) that our applications use to issue subsequent file system operations, such as read, write, and close. This reference is then passed to the various file system operations, such as read, write, or their variants.

For those curious about the purpose of the minor number, it is a mechanism for handling multiple devices or subdevices with a single device driver. It is not used by the operating system; it is simply passed to the device driver. The device driver can use the minor number in any way it sees fit. As an example, with a multiport serial card, the major number would specify the driver. The minor number might specify one of the multiple ports handled by the same driver on the multiport card. Interested readers are encouraged to consult one of the excellent texts on device drivers for further details.

Now that we have a skeletal device driver, we can load it and exercise it. Listing 8-11 is a simple user space application that exercises our device driver. We've already seen how to load the driver. Simply compile it and issue the make modules_install command to place it on your file system, as previously described.

Listing 8-11. Exercising Our Device Driver

#include

#include

#include

#include

#include

#include

int main(int argc, char **argv) {

/* Our file descriptor */

int fd;

int rc = 0;

char *rd_buf[16];

printf("%s: entered\n", argv[0]);

/* Open the device */

fd = open("/dev/hello1", O_RDWR);

if (fd == -1) {

perror("open failed");

rc = fd;

exit(-1);

}

printf("%s: open: successful\n", argv[0]);

/* Issue a read */

rc = read(fd, rd_buf, 0);

if (rc == -1) {

perror("read failed");

close(fd);

exit(-1);