Linux Device Driver

Today's Lecture

• Q&A
• Device Driver

Linux Device Driver

• Role of device driver in Linux
  • Hides hardware details
  • Provides well-defined interface for kernel/user
  • Manages hardware
• Usually as loadable modules
  • Some critical device drivers often compiled in

Hardware Detail

• CPU side: I/O bus and I/O address
  • Address to communicate with hardware device
  • Can be mapped to physical memory address space
• Device side: hardware controller
  • Control and status registers (CSRs)
• Three ways to interact with hardware device
  • Polling (e.g., floppy driver)
  • Interrupt-driven (e.g, most other devices)
  • DMA (direct memory access)

DMA

• For high throughput I/O
  • RAM region accessible by both CPU and device
  • Mapped into physical address space
  • Devices to transfer data to/from RAM without CPU's intervention
• To use DMA in device driver
  • Set up DMA channel (address, registers, direction)
  • Tell the DMA controller to start
  • Prepare interrupt service routine
• When the transfer completes, the device will interrupt CPU

Types of Device Driver in Linux

• Character device
  • Stream of bytes
  • Read and written directly without buffering
  • Example: serial ports, monitor, keyboard
• Block device
  • Read and written in multiples of block, random access
  • Example: disk, tape, cdrom
• Network device
  • Specially handled in Linux networking stack
  • Example: Ethernet card

Special Device File

• Abstraction and interface for character and block devices (but not for network device)
  • One device file corresponds to one device
  • To drive the device: to access the file
    • Open, close, read, write, etc.
• /dev: directory of all device files
  • The old way: each device has a major and a minor number
  • The new way: each device has a path name in devfs (device file system)

Character Device (the Old Way)

• In file fs/devices.c
• Data type

  struct device_struct {
          const char * name;
          struct file_operations * fops;
  };
  

• Array of all character devices

  static struct device_struct chrdevs[MAX_CHRDEV];
  

• To add to the array, call

  register_chrdev(major, name, fops)
  

Major Number

• One for each type of device driver
  • Example: 3 for harddrive, 4 for tty, etc.
  • Corresponding to the array subscript for chrdevs[]
• Dynamic major number
  • System allocate a free slot in chrdevs[]
  • To be dynamic allocated, use major number 0
  • To use the device, need to check /dev special file to find out the major number allocated

register_chrdev()

int register_chrdev(unsigned int major, const char * name, struct file_operations *fops)
{
        if (major == 0) {
                for (major = MAX_CHRDEV-1; major > 0; major--) {
                        if (chrdevs[major].fops == NULL) {
                                chrdevs[major].name = name;
                                chrdevs[major].fops = fops;
                                return major;
                        }
                }
        }
        ...
        chrdevs[major].name = name;
        chrdevs[major].fops = fops;
        ...
        return 0;
}

Character Device File Operations

• Data structure in file include/linux/fs.h

  struct file_operations {
          loff_t (*llseek) (struct file *, loff_t, int);
          ssize_t (*read) (struct file *, char *, size_t, loff_t *);
          ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
          int (*readdir) (struct file *, void *, filldir_t);
          unsigned int (*poll) (struct file *, struct poll_table_struct *);
          int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
          int (*mmap) (struct file *, struct vm_area_struct *);
          int (*open) (struct inode *, struct file *);
          int (*flush) (struct file *);
          int (*lock) (struct file *, int, struct file_lock *);
          ...
  }
  

Example: Open Operations

• Essentially the following (in fs/devices.c)

  int chrdev_open(struct inode * inode, struct file * filp)
  {
          ...
          filp->f_op = chrdevs[MAJOR(inode->i_rdev)].fops;
          ...
                          ret = filp->f_op->open(inode,filp);
          ...
  }
  

Block Device (The Old Way)

• Array of all block device (in fs/block_dev.c)

  static struct {
          const char *name;
          struct block_device_operations *bdops;
  } blkdevs[MAX_BLKDEV];
  

• Block device operations (in include/linux/fs.h)

  struct block_device_operations {
          int (*open) (struct inode *, struct file *);
          int (*release) (struct inode *, struct file *);
          int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
          int (*check_media_change) (kdev_t);
          int (*revalidate) (kdev_t);
  };
  

Registering a Device (the Old Way)

• To add to the list, use

  int register_chrdev(unsigned int major, const char * name, struct file_operations *fops)
  int register_blkdev(unsigned int major, const char * name, struct block_device_operations *bdops)
  

• To remove from the list, use

  int unregister_chrdev(unsigned int major, const char * name)
  int unregister_blkdev(unsigned int major, const char * name)
  

Device File System: the New Way

• /dev as a special file system (c.f. /proc)
• Benefits
  • Major/minor number is optional
  • Special file appears under /dev only if device driver loaded in kernel
• Data types
  • struct devfs_entry (in fs/devfs/base.c)
  • typedef struct devfs_entry * devfs_handle_t (in include/linux/devfs_fs_kernel.h)

Registering a Device

• To create a device file in a devfs:

  devfs_handle_t devfs_register (
          devfs_handle_t dir,
          const char *name,
          unsigned int flags,
          unsigned int major, unsigned int minor,
          umode_t mode,
          void *ops,
          void *info);
  

  • dir: handle to parent directory (NULL: root)
  • name: name of entry
  • major and minor: optional
• To remove the device file:

  extern void devfs_unregister (devfs_handle_t de);
  

Steps To Write a Device Driver

• Write all the functions for the device operation structure
• The old way:
  • Find a major number (or 0 for dynamic allocation)
  • Call register_chrdev() or register_blkdev()
• The new way (using devfs):
  • Call devfs_register()

Next Lecture

• File Systems
• Week after Spring Break: Networking
  • Review: "Linux Networking-concepts" (URL: http://netfilter.samba.org/documentation/HOWTO/networking-concepts-HOWTO.html)