Linux Device Drivers (3rd Edition) [Electronic resources] نسخه متنی

9.5. Quick Reference

This chapter introduced the following symbols related to hardware
management:

#include <linux/kernel.h>

void barrier(void)

This "software"


memory
barrier requests
the

compiler to consider all memory volatile across this instruction.

#include <asm/system.h>

void rmb(void);

void read_barrier_depends(void);

void wmb(void);

void mb(void);

Hardware memory barriers. They request the CPU (and the compiler) to
checkpoint all memory reads, writes, or both across this instruction.

#include <asm/io.h>

unsigned inb(unsigned port);

void outb(unsigned char byte, unsigned port);

unsigned inw(unsigned port);

void outw(unsigned short word, unsigned port);

unsigned inl(unsigned port);

void outl(unsigned doubleword, unsigned port);

Functions that are used to read and write I/O ports. They can also be
called by user-space programs, provided they have the right
privileges

to
access ports.

unsigned inb_p(unsigned port);

...

If a small delay is needed after
an I/O operation, you can use the six pausing counterparts of the
functions introduced in the previous entry; these pausing functions
have names ending in _p.

void insb(unsigned port, void *addr, unsigned long count);

void outsb(unsigned port, void *addr, unsigned long count);

void insw(unsigned port, void *addr, unsigned long count);

void outsw(unsigned port, void *addr, unsigned long count);

void insl(unsigned port, void *addr, unsigned long count);

void outsl(unsigned port, void *addr, unsigned long count);

The "string functions"
are




optimized to transfer data from an input port to a region of memory,
or the other way around. Such transfers


are performed by reading or writing the same port
count times.

#include <linux/ioport.h>

struct resource *request_region(unsigned long start, unsigned long len, char

*name);

void release_region(unsigned long start, unsigned long len);

int check_region(unsigned long start, unsigned long len);

Resource allocators for I/O ports. The (deprecated)
check function returns 0 for
success and less than 0 in case of error.

struct resource *request_mem_region(unsigned long start, unsigned long len,

char *name);

void release_mem_region(unsigned long start, unsigned long len);

int check_mem_region(unsigned long start, unsigned long len);

Functions that handle resource allocation for memory regions.

#include <asm/io.h>

void *ioremap(unsigned long phys_addr, unsigned long size);

void *ioremap_nocache(unsigned long phys_addr, unsigned long size);

void iounmap(void *virt_addr);

ioremap

remaps a physical address range into the processor's
virtual address space, making it available to the kernel.
iounmap frees the mapping when it is no longer
needed.

#include <asm/io.h>

unsigned int ioread8(void *addr);

unsigned int ioread16(void *addr);

unsigned int ioread32(void *addr);

void iowrite8(u8 value, void *addr);

void iowrite16(u16 value, void *addr);

void iowrite32(u32 value, void *addr);

Accessor functions that are used to work with I/O memory.

void ioread8_rep(void *addr, void *buf, unsigned long count);

void ioread16_rep(void *addr, void *buf, unsigned long count);

void ioread32_rep(void *addr, void *buf, unsigned long count);

void iowrite8_rep(void *addr, const void *buf, unsigned long count);

void iowrite16_rep(void *addr, const void *buf, unsigned long count);

void iowrite32_rep(void *addr, const void *buf, unsigned long count);

"Repeating" versions of the I/O
memory primitives.

unsigned readb(address);

unsigned readw(address);

unsigned readl(address);

void writeb(unsigned value, address);

void writew(unsigned value, address);

void writel(unsigned value, address);

memset_io(address, value, count);

memcpy_fromio(dest, source, nbytes);

memcpy_toio(dest, source, nbytes);

Older, type-unsafe functions for accessing I/O memory.

void *ioport_map(unsigned long port, unsigned int count);

void ioport_unmap(void *addr);

A driver author that wants to treat I/O ports as if they were I/O
memory may pass those ports to ioport_map. The
mapping should be done (with ioport_unmap) when
no longer needed.