F

fast interrupt handlers, Fast and Slow Handlers

FASYNC flag, File Operations, Asynchronous Notification

fasync method, File Operations

fasync_helper function, The Driver's Point of View, Quick Reference

fasync_struct structure, The Driver's Point of View

faults, Kernel Modules Versus Applications, Debugging System Faults–System Hangs

faulty module (oops messages), Oops Messages

faulty_read function, Oops Messages

faulty_write function, Oops Messages

fcntl system call, The Predefined Commands, Asynchronous Notification

fcntl.h header file, Blocking and Nonblocking Operations

fc_setup function, Interface Information

fdatasync system call, Flushing pending output

FDDI networks, configuring interfaces, Interface Information

fddi_setup function, Interface Information

fiber channel devices, initializing, Interface Information

FIFO (first-in-first-out) devices, The Design of scull, The Design of scull, poll and select

poll method and, poll and select

File System header (fs.h), Quick Reference

files, Initialization and Shutdown, Major and Minor Numbers, File Operations, File Operations–File Operations, The file Structure, The file Structure, The file Structure, The file Structure, The inode Structure, How Messages Get Logged, Implementing files in /proc, Capabilities and Restricted Operations, poll and select, Access Control on a Device File, Quick Reference, Quick Reference, Quick Reference, Quick Reference, The /proc Interface, The /proc Interface, Assigning IP Numbers, Interface Information

/etc/networks[files, Assigning IP Numbers

etc/networks, Assigning IP Numbers

access to, Access Control on a Device File

capability.h header file, Capabilities and Restricted Operations, Quick Reference

devices, Major and Minor Numbers

flags, The file Structure

inode structure, The inode Structure

interrupts, The /proc Interface

ioctl. header file, Quick Reference

kmsg, How Messages Get Logged

ksyms, Initialization and Shutdown

modes, The file Structure

net_int c, Interface Information

open, The file Structure

operations, File Operations–File Operations

poll.h header file, poll and select, Quick Reference

/proc, Implementing files in /proc

stat, The /proc Interface

structure, The file Structure

structures, File Operations

uaccess.h header file, Quick Reference

filesystems, Splitting the Kernel, Splitting the Kernel, Classes of Devices and Modules, Classes of Devices and Modules, Classes of Devices and Modules, Major and Minor Numbers–Dynamic Allocation of Major Numbers, Creating your /proc file–The seq_file interface, The /proc Interface, The /proc Interface and Shared Interrupts, Sysfs Operations

char drivers, Major and Minor Numbers–Dynamic Allocation of Major Numbers

modules, Classes of Devices and Modules, Classes of Devices and Modules

nodes, Splitting the Kernel, Classes of Devices and Modules

/proc, Creating your /proc file–The seq_file interface, The /proc Interface, The /proc Interface and Shared Interrupts

installing interrupt handlers, The /proc Interface

shared interrupts and, The /proc Interface and Shared Interrupts

sysfs, Sysfs Operations

file_operations structure, File Operations, File Operations, The file Structure, The mmap Device Operation

declaring using tagged initialization, File Operations

mmap method and, The mmap Device Operation

filp pointer, The file Structure, read and write, ioctl

in ioctl method, ioctl

in read/write methods, read and write

filp-\>f_op, The file Structure

filter hotplug operation, Hotplug Operations

fine-grained locking, Fine- Versus Coarse-Grained Locking

FIOASYNC command, The Predefined Commands

FIOCLEX command, The Predefined Commands

FIONBIO command, The Predefined Commands

FIONCLEX command, The Predefined Commands

FIOQSIZE command, The Predefined Commands

FireWire, Classes of Devices and Modules, IEEE1394 (FireWire)

drivers, Classes of Devices and Modules

firmware, Boot Time, Dealing with Firmware–How It Works, The Kernel Firmware Interface, How It Works, Firmware

calling, How It Works

functions, Firmware

interfaces, The Kernel Firmware Interface

Linux device model, Dealing with Firmware–How It Works

PCI boot-time configuration, Boot Time

flags, The file Structure, poll and select, poll and select, poll and select, poll and select, poll and select, poll and select, poll and select, poll and select, poll and select, Reading data from the device, Asynchronous Notification, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, The Flags Argument, Lookaside Caches, Lookaside Caches, Lookaside Caches, Lookaside Caches, Lookaside Caches, get_free_page and Friends, get_free_page and Friends, Quick Reference, Installing an Interrupt Handler, Installing an Interrupt Handler, Installing an Interrupt Handler, Installing a Shared Handler, Quick Reference, Interface-Specific Types, Accessing the I/O and Memory Spaces, The Memory Map and Struct Page, The vm_area_struct structure, Supporting Removable Media, Initializing Each Device, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, Interface Information, The Important Fields, struct termios, struct termios, struct termios

argument, The Flags Argument

FASYNC, Asynchronous Notification

file, The file Structure

GFP_ATOMIC, The Flags Argument, get_free_page and Friends

GFP_COLD, The Flags Argument

GFP_DMA, The Flags Argument

GFP_HIGH, The Flags Argument

GFP_HIGHMEM, The Flags Argument

GFP_HIGHUSER, The Flags Argument

GFP_KERNEL, get_free_page and Friends

GFP_NOFAIL, The Flags Argument

GFP_NOFS, The Flags Argument

GFP_NOIO, The Flags Argument

GFP_NORETRY, The Flags Argument

GFP_NOWARN, The Flags Argument

GFP_REPEAT, The Flags Argument

GFP_USER, The Flags Argument

GTP_KERNEL, The Flags Argument

IFF_ALLMULTI, Interface Information

IFF_AUTOMEDIA, Interface Information

IFF_BROADCAST, Interface Information

IFF_DEBUG, Interface Information

IFF_DYNAMIC, Interface Information

IFF_LOOPBACK, Interface Information

IFF_MASTER, Interface Information

IFF_MULTICAST, Interface Information

IFF_NOARP, Initializing Each Device, Interface Information

IFF_NOTRAILERS, Interface Information

IFF_POINTTOPOINT, Interface Information

IFF_PORTSEL, Interface Information

IFF_PROMISC, Interface Information

IFF_RUNNING, Interface Information

IFF_SLAVE, Interface Information

IFF_UP, Interface Information

media_change, Supporting Removable Media

memory allocation, The Flags Argument, Lookaside Caches, Quick Reference

for net_device structure, Interface Information

O_NONBLOCK (f_flags field), Reading data from the device

PACKET_HOST, The Important Fields

PG_locked, The Memory Map and Struct Page

POLLERR, poll and select

POLLHUP, poll and select

POLLIN, poll and select

POLLOUT, poll and select

POLLPRI, poll and select

POLLRDBAND, poll and select

POLLRDNORM, poll and select

POLLWRBAND, poll and select

POLLWRNORM, poll and select

resource (PCI), Accessing the I/O and Memory Spaces

SA_INTERRUPT, Installing an Interrupt Handler, Quick Reference

SA_SAMPLE_RANDOM, Installing an Interrupt Handler

SA_SHIRQ, Installing an Interrupt Handler, Installing a Shared Handler

SLAB_CACHE_DMA, Lookaside Caches

SLAB_CTOR_CONSTRUCTOR, Lookaside Caches

SLAB_HWCACHE_ALIGN, Lookaside Caches

SLAB_NO_REAP, Lookaside Caches

TTY_DRIVER_NO_DEVFS, struct termios

TTY_DRIVER_REAL_RAW, struct termios

TTY_DRIVER_RESET_TERMIOS, struct termios

VM_IO, The vm_area_struct structure

Wall, Interface-Specific Types

flips (tty drivers), No read Function?

flow of data (tty drivers), Flow of Data

flush method, File Operations, The release Method

close system call and, The release Method

flush operation, File Operations

flushing pending output, Flushing pending output, Flushing pending output

fonts (incorrect on console), Device Control Without ioctl

fops pointers, File Operations

forms (BCD), What Devices Does the Driver Support?

fragmentation, Do-it-yourself allocation, Do-it-yourself allocation

free command, Playing with the New Devices

freeing, Allocating and Freeing Device Numbers, The Linux Semaphore Implementation, DMA pools, The gendisk structure, Functions Acting on Socket Buffers

buffers, Functions Acting on Socket Buffers

device numbers, Allocating and Freeing Device Numbers

disks, The gendisk structure

DMA pools, DMA pools

semaphores, The Linux Semaphore Implementation

free_dma function, Registering DMA usage

free_irq function, Installing a Shared Handler

free_netdev functions, Module Unloading

free_pages function, get_free_page and Friends

fs.h header file, Quick Reference, Blocking and Nonblocking Operations, The Driver's Point of View, Quick Reference

asynchronous notification and, The Driver's Point of View

blocking/nonblocking operations, Blocking and Nonblocking Operations

fsync method, File Operations, Flushing pending output

full class interfaces, The Full Class Interface

functions, The Hello World Module, The Hello World Module, Kernel Modules Versus Applications, A Few Other Details, Initialization and Shutdown–Module-Loading Races, Initialization and Shutdown, The Cleanup Function, The open Method–The open Method, The release Method, scull's Memory Usage, printk–Printing Device Numbers, printk, How Messages Get Logged, How Messages Get Logged, Turning the Messages On and Off, Implementing files in /proc, Creating your /proc file, Creating your /proc file, The seq_file interface, The seq_file interface, The seq_file interface, The seq_file interface, The seq_file interface, The seq_file interface, Oops Messages, Oops Messages, System Hangs, System Hangs, System Hangs, Semaphores and Mutexes, The Linux Semaphore Implementation, The Linux Semaphore Implementation, The Spinlock Functions, Ambiguous Rules, Using the ioctl Argument, Using the ioctl Argument, Using the ioctl Argument, Capabilities and Restricted Operations, Simple Sleeping, Manual sleeps, Exclusive waits, Ancient history: sleep_on, poll and select, The Driver's Point of View, The Driver's Point of View, Cloning the Device on open, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Quick Reference, Processor-Specific Registers, Processor-Specific Registers, Knowing the Current Time, Knowing the Current Time, Yielding the processor, Timeouts, Timeouts, Kernel Timers, Kernel Timers, The Timer API, The Timer API, The Implementation of Kernel Timers, Tasklets, Tasklets, Tasklets, Tasklets, Tasklets, Tasklets, Workqueues, The Real Story of kmalloc–The Size Argument, The Flags Argument, Lookaside Caches, Lookaside Caches, Lookaside Caches, Lookaside Caches, get_free_page and Friends, get_free_page and Friends, get_free_page and Friends, get_free_page and Friends, get_free_page and Friends, get_free_page and Friends, vmalloc and Friends–A scull Using Virtual Addresses: scullv, vmalloc and Friends, vmalloc and Friends, vmalloc and Friends, vmalloc and Friends, Quick Reference, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, Manipulating I/O ports, Manipulating I/O ports, Manipulating I/O ports, Manipulating I/O ports, Manipulating I/O ports, Manipulating I/O ports, String Operations, String Operations, String Operations, String Operations, String Operations, String Operations, Pausing I/O, Pausing I/O, Using I/O Memory, I/O Memory Allocation and Mapping, I/O Memory Allocation and Mapping, isa_readb and Friends, Quick Reference, Installing an Interrupt Handler, Installing an Interrupt Handler, Installing an Interrupt Handler, Installing an Interrupt Handler, Installing an Interrupt Handler, Kernel-assisted probing, Kernel-assisted probing, The internals of interrupt handling on the x86, The internals of interrupt handling on the x86, Tasklets, Installing a Shared Handler, Installing a Shared Handler, Installing a Shared Handler, Data Alignment, Data Alignment, Linked Lists, Linked Lists, Linked Lists, Linked Lists, Linked Lists, Linked Lists, Enabling the PCI Device, Accessing the I/O and Memory Spaces, Accessing the I/O and Memory Spaces, Accessing the I/O and Memory Spaces, Accessing the I/O and Memory Spaces, Creating and Destroying Urbs, Interrupt urbs, Bulk urbs, Control urbs, Submitting Urbs, Completing Urbs: The Completion Callback Handler, Completing Urbs: The Completion Callback Handler, Canceling Urbs, Canceling Urbs, Registering a USB Driver, Registering a USB Driver, Registering a USB Driver, Registering a USB Driver, Registering a USB Driver, Registering a USB Driver, probe and disconnect in Detail, probe and disconnect in Detail, probe and disconnect in Detail, probe and disconnect in Detail, usb_bulk_msg, usb_control_msg, Other USB Data Functions, Other USB Data Functions, Release functions and kobject types, Bus registration, Bus methods, Iterating over devices and drivers, Driver structure embedding, Remove a Device, Add a Driver, Remove a Driver, udev, udev, udev, udev, The Kernel Firmware Interface, Sysfs Operations, Buses, Devices, and Drivers, Buses, Devices, and Drivers, Buses, Devices, and Drivers, Classes, Firmware, The Memory Map and Struct Page, The Memory Map and Struct Page, The Memory Map and Struct Page, Using remap_pfn_range, Mapping Memory with nopage, Performing Direct I/O, Setting up coherent DMA mappings, Scatter/gather mappings, Registering DMA usage, Registering DMA usage, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Talking to the DMA controller, Direct Memory Access, Direct Memory Access, Block Driver Registration, Initialization in sbull, A Note on Sector Sizes, Request Processing–Doing without a request queue, A Simple request Method, Queue creation and deletion, Queueing functions, Queueing functions, Queueing functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Queue control functions, Command Pre-Preparation, Quick Reference–Quick Reference, Initializing Each Device, Initializing Each Device, Initializing Each Device, Module Unloading, Module Unloading, Interface Information–The Device Methods, Interface Information, Interface Information, Interface Information, Interface Information, Utility Fields, Opening and Closing, Opening and Closing, Controlling Transmission Concurrency, Controlling Transmission Concurrency, The Interrupt Handler, Changes in Link State, Changes in Link State, Changes in Link State, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, Functions Acting on Socket Buffers, A Typical Implementation, Quick Reference–Quick Reference, A Small TTY Driver, A Small TTY Driver, tty_driver Function Pointers–No read Function?, open and close–open and close, open and close–open and close, open and close, open and close, Flow of Data, Other Buffering Functions, No read Function?, set_termios, set_termios, tiocmget and tiocmset, tiocmget and tiocmset, ioctls, Quick Reference

access_ok, Using the ioctl Argument

alloc_netdev, Initializing Each Device

alloc_skb, Functions Acting on Socket Buffers

alloc_tty_driver, A Small TTY Driver

blkdev_dequeue_request, Queueing functions

blk_cleanup_queue, Queue creation and deletion

blk_queue_hardsect_size, A Note on Sector Sizes

blk_queue_segment_boundary, Queue control functions

block drivers, Quick Reference–Quick Reference

buses, Buses, Devices, and Drivers

bus_add_driver, Add a Driver

bus_for_each_dev, Iterating over devices and drivers

bus_register, Bus registration

calling from modules/applications, Kernel Modules Versus Applications

capable, Capabilities and Restricted Operations, Quick Reference

chars_in_buffer, Other Buffering Functions

claim_dma_lock, Talking to the DMA controller

classes, Classes

class_simple_create, udev

class_simple_device_add, udev

class_simple_device_remove, udev

cleanup, The Cleanup Function

clear_dma_ff, Talking to the DMA controller

close (tty drivers), open and close–open and close

complete (urbs), Completing Urbs: The Completion Callback Handler

const char *dev_name, Installing an Interrupt Handler

const char *name, Registering a USB Driver

const struct usb_device_id*id_table, Registering a USB Driver

constructor (kmem_cache_create), Lookaside Caches

create_proc_read_entry, Creating your /proc file

del_timer_sync, The Timer API

devices, Buses, Devices, and Drivers

dev_alloc_skb, Functions Acting on Socket Buffers

dev_kfree_skb, The Interrupt Handler, Functions Acting on Socket Buffers

disable_dma, Talking to the DMA controller

disable_irq, Installing a Shared Handler

disconnect (USB), Registering a USB Driver, probe and disconnect in Detail

dma_free_coherent, Setting up coherent DMA mappings

double underscore (__), A Few Other Details

down, The Linux Semaphore Implementation

do_close, open and close

do_gettimeofday, Knowing the Current Time

do_IRQ, The internals of interrupt handling on the x86

drivers, Buses, Devices, and Drivers

driver_unregister, Remove a Driver

elv_next_request, A Simple request Method, Queueing functions, Command Pre-Preparation

enable_dma, Talking to the DMA controller

enable_irq, Installing a Shared Handler

ether_setup, Initializing Each Device, Interface Information–The Device Methods

fasync_helper, The Driver's Point of View, Quick Reference

faulty_read, Oops Messages

faulty_write, Oops Messages

fc_setup, Interface Information

fddi_setup, Interface Information

firmware, Firmware

free_dma, Registering DMA usage

free_irq, Installing a Shared Handler

free_netdev, Module Unloading

free_pages, get_free_page and Friends

get_cycles, Processor-Specific Registers

get_dma_residue, Talking to the DMA controller

get_fast_time, Knowing the Current Time

get_free_page, get_free_page and Friends

get_free_pages, The Flags Argument, get_free_page and Friends, vmalloc and Friends

get_page, Mapping Memory with nopage

get_unaligned, Data Alignment

get_user, Using the ioctl Argument, Quick Reference

get_user_pages, Performing Direct I/O

get_zeroed_page, get_free_page and Friends

handle_IRQ_event, The internals of interrupt handling on the x86

hello world module, The Hello World Module

hippi_setup, Interface Information

inb, Manipulating I/O ports

inb_p, Pausing I/O

initialization, Initialization and Shutdown–Module-Loading Races

inl, Manipulating I/O ports

insb, String Operations

inserting schedules, System Hangs

insl, String Operations

insw, String Operations

int (USB), Registering a USB Driver

int pci_enable_device, Enabling the PCI Device

int seq_escape, The seq_file interface

int seq_path, The seq_file interface

int seq_printf, The seq_file interface

int seq_putc, The seq_file interface

int seq_puts, The seq_file interface

inw, Manipulating I/O ports

in_atomic, Kernel Timers

in_interrupt, Kernel Timers

ioctl (tty drivers), ioctls

ioremap, vmalloc and Friends, Using I/O Memory, Quick Reference

ioremap_nocache, I/O Memory Allocation and Mapping

iounmap, vmalloc and Friends, I/O Memory Allocation and Mapping

irqreturn_t, Installing an Interrupt Handler

isa_readb, isa_readb and Friends

kfree_skb, Functions Acting on Socket Buffers

kill_fasync, The Driver's Point of View, Quick Reference

kmalloc, scull's Memory Usage, The Real Story of kmalloc–The Size Argument, get_free_page and Friends

allocation engine, The Real Story of kmalloc–The Size Argument

performance degradation issues, get_free_page and Friends

kmap, The Memory Map and Struct Page

kmap_skb_frag, Functions Acting on Socket Buffers

kmem_cache_alloc, Lookaside Caches

kmem_cache_create, Lookaside Caches

kmem_cache_t type, Lookaside Caches

list_add, Linked Lists

list_add_tail, Linked Lists

list_del, Linked Lists

list_empty, Linked Lists

list_move, Linked Lists

list_splice, Linked Lists

locking, Ambiguous Rules

match (buses), Bus methods

module_init, Initialization and Shutdown

mod_timer, The Timer API, The Implementation of Kernel Timers

netif_carrier_off, Changes in Link State

netif_carrier_ok, Changes in Link State

netif_carrier_on, Changes in Link State

netif_start_queue, Opening and Closing

netif_stop_queue, Opening and Closing, Controlling Transmission Concurrency

netif_wake_queue, Controlling Transmission Concurrency

network drivers, Quick Reference–Quick Reference

open (tty drivers), open and close–open and close

outb, Manipulating I/O ports

outb_p, Pausing I/O

outl, Manipulating I/O ports

outsb, String Operations

outsl, String Operations

outsw, String Operations

outw, Manipulating I/O ports

page-oriented allocation, get_free_page and Friends, Quick Reference

pci_map-sg, Scatter/gather mappings

pci_remove_bus_device, Remove a Device

pci_resource_, Accessing the I/O and Memory Spaces

pfn_to_page, The Memory Map and Struct Page

poll_wait, poll and select, Quick Reference

printk, The Hello World Module, printk–Printing Device Numbers, How Messages Get Logged, How Messages Get Logged, Turning the Messages On and Off, The seq_file interface

circular buffers for, How Messages Get Logged

logging messages from, How Messages Get Logged

seq_file interface (avoiding in), The seq_file interface

turning debug messages on/off, Turning the Messages On and Off

probe (USB), probe and disconnect in Detail

probe_irq_off, Kernel-assisted probing

probe_irq_on, Kernel-assisted probing

put_unaligned, Data Alignment

put_user, Using the ioctl Argument, Quick Reference

queues, Queueing functions

rdtscl, Processor-Specific Registers

read (tty drivers), No read Function?

read_proc, Implementing files in /proc

register_blkdev, Block Driver Registration

register_chrdev, udev

register_netdev, Initializing Each Device

relaease_dma_lock, Talking to the DMA controller

release (kobjects), Release functions and kobject types

remap_pfn_range, Using remap_pfn_range

remove_proc_entry, Creating your /proc file

request (block drivers), Request Processing–Doing without a request queue

request_dma, Registering DMA usage

request_firmware, The Kernel Firmware Interface

SAK, System Hangs

sbull_request, Initialization in sbull

schedule, System Hangs, Quick Reference, Yielding the processor

execution of code (delaying), Yielding the processor

preventing endless loops with, System Hangs

schedule_timeout, Timeouts

scull, The open Method–The open Method, The release Method

open method, The open Method–The open Method

release method, The release Method

scull_cleanup, Cloning the Device on open

scull_getwritespace, Manual sleeps

semaphores, Semaphores and Mutexes (see semaphores)

set_dma_addr, Talking to the DMA controller

set_dma_count, Talking to the DMA controller

set_dma_mode, Talking to the DMA controller

set_mb, I/O Registers and Conventional Memory

set_multicast_list, A Typical Implementation

set_rmb, I/O Registers and Conventional Memory

set_termios, set_termios

set_wmb, I/O Registers and Conventional Memory

sg_dma_address, Direct Memory Access

sg_dma_len, Direct Memory Access

show, Driver structure embedding

skb_headlen, Functions Acting on Socket Buffers

skb_headroom, Functions Acting on Socket Buffers

skb_is_nonlinear, Functions Acting on Socket Buffers

skb_pull, Functions Acting on Socket Buffers

skb_push, Functions Acting on Socket Buffers

skb_put, Functions Acting on Socket Buffers

skb_reserve, Functions Acting on Socket Buffers

skb_tailroom, Functions Acting on Socket Buffers

sleep_on, Ancient history: sleep_on

acting on socket buffers, Functions Acting on Socket Buffers

spinlocks, The Spinlock Functions

struct module *owner, Registering a USB Driver

sysfs filesystem, Sysfs Operations

sys_syslog, printk

tasklet_schedule, Tasklets

tiny_close, open and close

tiocmget, tiocmget and tiocmset

tiomset, tiocmget and tiocmset

tr_configure, Interface Information

tty drivers, Quick Reference

tty_driver (pointers), tty_driver Function Pointers–No read Function?

tty_get_baud_rate, set_termios

tty_register_driver, A Small TTY Driver

unregister_netdev, Module Unloading

unsigned int irq, Installing an Interrupt Handler

unsigned long flags, Installing an Interrupt Handler

unsigned long pci_resource_end, Accessing the I/O and Memory Spaces

unsigned long pci_resource_start, Accessing the I/O and Memory Spaces

unsigned pci_resource_flags, Accessing the I/O and Memory Spaces

up, The Linux Semaphore Implementation

urbs_completion, Completing Urbs: The Completion Callback Handler

usb_alloc_urb, Creating and Destroying Urbs

usb_bulk_msg, usb_bulk_msg

usb_control_msg, usb_control_msg

usb_fill_bulk_urb, Bulk urbs

usb_fill_control_urb, Control urbs

usb_fill_int_urb, Interrupt urbs

usb_get_descriptor, Other USB Data Functions

usb_kill_urb, Canceling Urbs

usb_register_dev, probe and disconnect in Detail

usb_set_intfdata, probe and disconnect in Detail

usb_string, Other USB Data Functions

usb_submit_urb, Submitting Urbs

usb_unlink_urb, Canceling Urbs

vfree, vmalloc and Friends

virt_to_page, The Memory Map and Struct Page

vmalloc allocation, vmalloc and Friends–A scull Using Virtual Addresses: scullv

void, Registering a USB Driver

void barrier, I/O Registers and Conventional Memory

void blk_queue_bounce_limit, Queue control functions

void blk_queue_dma_alignment, Queue control functions

void blk_queue_hardsect_size, Queue control functions

void blk_queue_max_hw_segments, Queue control functions

void blk_queue_max_phys_segments, Queue control functions

void blk_queue_max_sectors, Queue control functions

void blk_queue_max_segment_size, Queue control functions

void blk_start_queue, Queue control functions

void blk_stop_queue, Queue control functions

void mb, I/O Registers and Conventional Memory

void read_barrier_depends, I/O Registers and Conventional Memory

void rmb, I/O Registers and Conventional Memory

void smp_mb, I/O Registers and Conventional Memory

void smp_rmb, I/O Registers and Conventional Memory

void smp_wmb, I/O Registers and Conventional Memory

void tasklet_disable, Tasklets

void tasklet_disable_nosync, Tasklets

void tasklet_enable, Tasklets

void tasklet_hi_schedule, Tasklets

void tasklet_kill, Tasklets

void tasklet_schedule, Tasklets

void wmb, I/O Registers and Conventional Memory

void*dev_id, Installing an Interrupt Handler

wait_event_interruptible_timeout, Timeouts

wake-up, Simple Sleeping, Quick Reference

wake_up, Exclusive waits, Quick Reference

wake_up_interruptible, Quick Reference

wake_up_interruptible_sync, Quick Reference

wake_up_sync, Quick Reference

workqueues, Workqueues

write (tty drivers), Flow of Data

xmit_lock, Utility Fields

f_dentry pointer, The file Structure

f_flags field (file structure), The file Structure, The Predefined Commands, Blocking and Nonblocking Operations

O_NONBLOCK flag, The Predefined Commands, Blocking and Nonblocking Operations

f_mode field (file structure), The file Structure

f_op pointer, The file Structure

f_pos field (file structure), The file Structure, Implementing files in /proc

read_proc function and, Implementing files in /proc

F_SETFL command, The Predefined Commands, Asynchronous Notification

fcntl system call and, Asynchronous Notification

F_SETFL fcntl command, Asynchronous Notification

F_SETOWN command, Asynchronous Notification, Asynchronous Notification

fcntl system call and, Asynchronous Notification