CHAPTER 9 Communicating with Hardware

Quick Reference
This chapter introduced the following symbols related to hardware management:
#include
void barrier(void)
    This “software” memory barrier requests the compiler to consider all memory
    volatile across this instruction.
#include
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 check-
    point all memory reads, writes, or both across this instruction.
#include
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
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
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
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.