Difference between revisions of "Embedded-Linux-Device-Driver/C3/File-Operations-on-a-Device/English"

Learning objectives:

• Implement the basic file operations such as open() and close() on a device.

System Requirements:

• VirtualBox version 5.2.
• Ubuntu Linux 18.04 LTS operating system.
• Linux kernel version 5.0.0-31 generic and
• gedit text editor

Prerequisites:

• C programming language and
• Basics of Linux kernel

If not, then go through the C/C++ and Linux spoken tutorials on this website.

Point to the files.

Here I have created a new directory as FileOperations.

In this directory, I have saved a simple_driver dot c driver file, Makefile and user.c.

I’ll use these files for demonstration.

Code files:

• The files used in this tutorial are available in the Code Files link on this tutorial page.
• Please download and extract them
• Make a copy and then use them while practising

About new_device

In this tutorial, we will perform file operations such as open and close on new_device.

We will use a user program called user.c to access this device.

Press Enter key after every command.

I have used the same file simple_driver dot c which we used earlier.

I have implemented the basic file functions such as open and close for the device new_device.

#include<linux/cdev.h>

Highlight cdev.h

Highlight struct cdev.

The cdev dot h header file is used to create the character device structure.

The cdev structure is used to describe character devices in the Linux kernel.

Here, my_cdev represents our device cdev structure in the kernel.

struct file_operations structure

• File operations are defined in the kernel as the instance of struct file_operations.
• This is the most important structure of a driver defined in the fs dot h file.
• Each field of this structure is a function pointer.

Highlight mydevice_open and mydevice_release

We will implement two functions - mydevice_open and mydevice_release in a driver.

We get these functions declarations from the fs dot h header file.

Highlight cdev

Highlight fops

cdev specifies a pointer to the cdev structure to initialize.

fops specifies a pointer to device file operation structure.

Highlight cdev_init(&my_cdev, &fops)

Highlight my_cdev and fops.

After that we have to initialize the cdev structure of a device as shown here.

It will establish a connection between cdev structure and file_operations.

Highlight p Highlight dev Highlight count

It returns a negative error code on failure.

p specifies the cdev structure for the device.

dev specifies a device number.

count specifies a number of consecutive minor numbers corresponding to this device.

Highlight my_cdev

Highlight the device_destroy(cl,device_num),

class_destroy(cl), unregister_chrdev_region(device_num,1);

Highlight printk

If the registration fails then we have to destroy a device and its class.

Also unregister the device from the system as shown here.

This printk message will show the successful execution of the cdev_add() function.

Highlight printk message

Here, I have defined the open function with a printk message.

mydevice_open() function gets executed when the user program opens the device.

printk message will display in the kernel log level.

Highlight printk message

mydevice_release() function gets executed when the user program closes the device.

This printk message will display the success message in the kernel log level.

Highlight cdev

cdev specifies the cdev structure to be removed.

Save and close the file.

Type gedit user dot c.

Here, I have created a simple user program which will open and close the device.

Highlight printf

Highlight close() function

printf function will print the message if the open function fails to open the new_device.

close() system call will internally call the close function of a new_device from its driver.

Save and close the file.

Save the Makefile

Let us create a Makefile to compile a driver.

Type gedit space Makefile.

Type this code in a Makefile or you can use the downloaded Makefile.

Save and close the file.

Type >> make all

Type sudo su and password to be a superuser.

Type make space all.

Clear the screen.

Type insmod space simple_driver dot ko.

Highlight the output

Type dmesg space pipe space grep space simple_driver.

Here, you can see the cdev structure of a new_device registered successfully.

Type >> gcc -o user user.o.

Type >> ./user

Highlight output

Type gcc space hyphen c space user dot c

Then type gcc space hyphen o space user space user dot o

Now to execute the program type dot slash user.

The output shows that the new_device 'open'ed successfully.

Highlight the respective messages

Type >> clear

The output shows that open and close functions of the driver are executed successfully.

It indicates that the new_device is opened and closed by the user program.

Clear the screen.

Type dmesg | grep simple_driver

Highlight the output

Type >> clear

Type rmmod space simple_driver dot ko

To see the unloaded printk messages type this dmesg command.

It indicates that the cdev structure of a new_device removed from the kernel.

Clear the screen.

Type make space clean.

Let us summarize.

Summary:

• Implement the basic file operations such as open and close on a device.

Assignment :

1. Open the simple driver.c file.
2. Write the different printk messages in the open and close functions.
3. Compile and load the driver.
4. Compile and execute the user program.
5. Use dmesg command to check whether the device is opened or not.
6. Unload the driver from the kernel.

About Spoken Tutorial Project:

• The video at the following link summarizes the Spoken Tutorial project.

• Please download and watch it.

Spoken Tutorial workshops:

For more details, please write to us.

Forum questions:

Forum for specific questions:

• Do you have any general or technical questions on Embedded Linux Device Driver?
• Please visit the FOSSEE forum and post your question.

Acknowledgment:

Thank you slide:

This is Usha signing off.

Thanks for watching.