Skip to main content.

11. Device Drivers

The kernel already includes device drivers for the on-chip serial and ethernet ports.

11.1. Examples

For helpful MPC8xx-specific device driver examples, see

11.2. Flash memory

11.2.1. Flash Device Driver

A flash driver will give you access to devices, which are useful during development and for field upgrades and are ideal for storing fixed size persistent configuration data like your board's Ethernet MAC address. This is true for drivers supporting a number of vendors' devices.

The flash driver does auto-erase when the length of data written per write() is exactly the corresponding erase block size. So usually you just need to do:

open (/dev/flash???)
lseek(specific erase region)
write(data, region size)

11.2.2. QSLinux Flash Driver

QSLinux contains a fully functioning FLASH driver, and an interface to the Ext2FS filesystem, with compression.

11.2.3. Memory Technology Device (MTD) Subsystem

The MTD subsystem offers a more general solution which allows you to treat the flash as a regular block device on which you can mount a filesystem. It's ideal for large amounts of variable sized data or applications requiring a traditional writable filesystem, provided by the JournalingFlashFilesystem.

However, some work is required to get the MTD to run on PowerPC, as it does not yet support big endian.

11.2.4. M-Systems Disk-On-Chip

This is supported via the MemoryTechnologyDevice Subsystem.

11.3. PCMCIA Cards

For a PCMCIA driver, see

There are also some fairly detailed notes available at and

For generic Linux PCMCIA info, see

11.4. IDE/ATA Disk Drives

There are lots of options for connecting IDE drives. You need to at least configure CONFIG_BLK_DEV_IDE and CONFIG_BLK_DEV_IDEDISK. Search for IDE.

Also, see

11.5. PCI Bridge

11.6. Watchdog

Using the on-chip watchdog to provide the basic "write kicked" /dev/watchdog interface described in Documentation/watchdog.txt is problematic, because the SYPCR register controlling it can only be written once after reset to both set the timeout and enable the watchdog. Once enabled, the boot loader and kernel must keep it from expiring up until the point where the user application opens /dev/watchdog. Littering the generic kernel decompress and startup codes with watchdog kicks to do this isn't acceptable to other Linux users. Hence, hardware watchdog support hasn't been implemented yet.

The general plan to solve this problem is described in

You can probably use Linux's software watchdog in the meantime.

11.7. USB for MPC850/823

These devices can be made to operate as a USB host or slave. Search for USB.

Also see the Programming Guide for Linux USB Device Drivers at

11.8. A/D and D/A

Use something that "frames" the data and the SI/TDM interface works really sweet. Take a look at the CS4218 audio codec driver for the Embedded Planet boards. It's floating around in the 2.2.13 kernels on the MontaVista? site.

11.9. VME

Numerous VME boardvendors offer Linux support through software partners such as DENX.

Some older patches and tarballs to use Linux on VME boards and simplify the access to the VME bus are available at

11.10. HDLC/PPP

Provides support for the HDLC protocol, running the PPP layer in order to transport IP packets across a synchronous serial link.

11.11. SPI

This driver is an interface for the SPI controller in MPC8xx. The driver is written to work with the microcode patches to correct the parameter RAM problems. The driver supports basic init, open, close, read, and write functions.

11.12. Linux STREAMS (LiS?)

LiS? is a software package that comprises an implementation of SVR4-compatible STREAMS for Linux in the form of a loadable kernel module.

A patch to port it to MPC8xx based Embedded PowerPC systems is available at

11.13. Accessing peripherals from user space

This code snippet is for accessing hardware registers from user space. The program needs CAP_SYS_RAWIO and /dev/mem permissions. Don't forget -O compile optimisation for asm inline's.

 * Usage:
 *   volatile void *p = ioremap(MY_HARD_REG_ADDR, 4096);
 *   ...
 *   out_8(p, state ^= 0x1);
 *  Copyright (C) 2003 Stephane Fillod

#include <stdio.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#ifdef __PPC__
extern inline void out_8(volatile unsigned char *addr, unsigned val)
        __asm__ __volatile__("stb%U0%X0 %1,%0; eieio" : "=m" (*addr) : "r" (val));
/* etc., cf asm/io.h */
extern inline void out_8(volatile unsigned char *addr, unsigned val)
        *addr = val & 0xff;

volatile void * ioremap(unsigned long physaddr, unsigned size)
    static int axs_mem_fd = -1;
    unsigned long page_addr, ofs_addr, reg, pgmask;
    void* reg_mem = NULL;

     * looks like mmap wants aligned addresses?
    pgmask = getpagesize()-1;
    page_addr = physaddr & ~pgmask;
    ofs_addr  = physaddr & pgmask;

     * Don't forget O_SYNC, esp. if address is in RAM region.
     * Note: if you do know you'll access in Read Only mode,
     *    pass O_RDONLY to open, and PROT_READ only to mmap
    if (axs_mem_fd == -1) {
        axs_mem_fd = open("/dev/mem", O_RDWR|O_SYNC);
        if (axs_mem_fd < 0) {
                perror("AXS: can't open /dev/mem");
                return NULL;

    /* memory map */
    reg_mem = mmap(
    if (reg_mem == MAP_FAILED) {
        perror("AXS: mmap error");
        return NULL;

    reg = (unsigned long )reg_mem + ofs_addr;
    return (volatile void *)reg;

int iounmap(volatile void *start, size_t length)
    unsigned long ofs_addr;
    ofs_addr = (unsigned long)start & (getpagesize()-1);

    /* do some cleanup when you're done with it */
    return munmap((void*)start-ofs_addr, length+ofs_addr);
10. Kernel 1. Introduction 12. Runtime Library
Prev Home Next