Index
Prev |  |

## Index

32-bit address space
  See address space, 32-bit
    Reader Comments

64-bit address format
  64-Bit Address Format

64-bit address space
  See address space, 64-bit
    Reader Comments

64-bit mode
  Allowing for 64-Bit Mode

64-bit physical address format
  Physical Address

address exception
  Address Exceptions

address space
  32-bit
    The 32-Bit Address Space
    embedding in 64-bit
      Compatibility of 32-Bit and 64-Bit Spaces
    kseg0
      Cached Physical Memory—kseg0
      Cached Physical Memory—kseg0
    kseg1
      Uncached Physical Memory—kseg1
    kseg2
      Kernel Virtual Space—kseg2
    kuseg
      User Process Space—kuseg
    segments of
      Segments of the 32-bit Address Space
    virtual mapping
      Virtual Address Mapping
  64-bit
    The 64-Bit Address Space
    address format
      64-Bit Address Format
    cache-controlled
      Cache-Controlled Physical Memory—xkphys
    physical address format
      Physical Address
    segments of
      Segments of the 64-Bit Address Space
    sign extension
      Compatibility of 32-Bit and 64-Bit Spaces
    virtual mapping
      Virtual Address Mapping
    xkseg
      Kernel Virtual Space—xkseg
    xksseg
      Supervisor Mode Space—xksseg
    xkuseg
      User Process Space—xkuseg
  bus virtual
    PIO Addresses and DMA Addresses
  data transfer between
    Transferring Data
  kernel
    Kernel Virtual Space—kseg2
    Kernel Virtual Space—xkseg
    map to user
      Memory Use in User-Level Drivers
  physical
    Converting Virtual Addresses to Physical
  supervisor
    Supervisor Mode Space—xksseg
  user process
    User Process Space—kuseg
    User Process Space—xkuseg
  See also execution model
    Reader Comments

addressing
  Physical and Virtual Memory

address/length list
  Address/Length Lists
  Using Address/Length Lists
  cursor use
    Using Alenlist Cursors

alternate console
  Specifying a Separate System Console

ASSERT macro
  Using ASSERT

audio not covered
  User-Level Access to SCSI Devices

authorized binary interface (ABI)
  Handling 32-Bit and 64-Bit Execution Models

bdevsw table
  Kernel Switch Tables

block device
  Kinds of Kernel-Level Drivers
  combined with character
    Combined Block and Character Drivers
    Use of the Open Type
  versus character
    Block and Character Device Access

buffer (buf_t)
  See data types, buf_t
    Reader Comments

bus adapter
  translates addresses
    PIO Addresses and DMA Addresses

bus virtual address
  PIO Addresses and DMA Addresses

cache
  Cache Use and Cache Coherency
  The IO4 Problem
  64-bit access
    Cache-Controlled Physical Memory—xkphys
  alignment of buffers
    DMA Buffer Alignment
  coherency
    Cache Coherency in Multiprocessors
  control functions
    Managing Memory for Cache Coherency
  device access always uncached
    CPU Access to Device Registers
  primary
    CPU Access to Memory
  secondary
    CPU Access to Memory

cache algorithm
  Cache-Controlled Physical Memory—xkphys

cdevsw table
  Kernel Switch Tables

Challenge/Onyx
  directing interrupts
    Using the IPL Statement
  DMA engine in
    Operation of the DMA Engine
    Operation of the DMA Engine
  IO4 board
    VME Hardware Architecture
    Challenge DMA with Multiple IO4 Boards
  limit on VME DMA space
    Mapping DMA Addresses
    Mapping DMA Addresses
  no uncached memory
    Uncached Memory Access in SGI Origin 2000 and in Challenge and Onyx Series
  VME address windows
    Fixed PIO Maps
    Fixed PIO Maps
  VME bus address mapping in
    PIO Addressing in Challenge and Onyx Systems
  VME bus numbers
    VME Bus Numbering
  VME design constraints
    VME Hardware Features and Restrictions
  VME hardware
    VME Hardware in Challenge and Onyx Systems

character device
  Kinds of Kernel-Level Drivers
  combined with block
    Combined Block and Character Drivers
    Use of the Open Type
  versus block
    Block and Character Device Access

COFF file format not supported
  Compiling and Linking

command
  See IRIX commands
    Reader Comments

compiler options
  Compiler Options
  for loadable driver
    Compile Options for Loadable Drivers
  for network driver
    Compiler Flags for MP TCP/IP

configuration files
  Configuration Files
  /dev/MAKEDEV
    Dynamic Definition of Device Special Files
  /etc/inittab
    Specifying a Separate System Console
  /etc/ioconfig.config
    Configuration Control File
    VME Bus Numbers Assigned by ioconfig
  /etc/ioperms
    Permissions Control File
  /etc/rc2.d
    The Script MAKEDEV
  /etc/rc2/S23autoconfig
    Registration
  /usr/cpu/sysgen/IPnnboot
    Placing the Object File in /var/sysgen/boot
  /usr/lib/X11/input/config
    X Display Manager Configuration
  /var/sysgen/boot
    Master Configuration Database
    Configuring a Nonloadable Driver
    How Names Are Used in Configuration
  /var/sysgen/irix.sm
    Directing VME Interrupts
    Defining VME Devices with the VECTOR Statement
  /var/sysgen/Makefile.kernio
    Using /var/sysgen/Makefile.kernio
  /var/sysgen/master.d
    Master Configuration Database
    Selecting a Major Number
    Configuring a Nonloadable Driver
    How Names Are Used in Configuration
    Describing the Driver in /var/sysgen/master.d
    dependencies
      Listing Dependencies
    example
      Example Driver Source Files
    format
      Descriptive Line
      Master File for Loadable Drivers
    stubs
      Stubs Section
    variables
      Variables Section
  /var/sysgen/master.d/mem
    Access Using mmap()
  /var/sysgen/mtune/*
    System Tuning Parameters
  /var/sysgen/system
    Kernel Configuration Files
    Configuring a Nonloadable Driver
    How Names Are Used in Configuration
    example
      Example Driver Source Files
  /var/sysgen/system/irix.sm
    Learning EISA Device Addresses
    for debugging
      Enabling Debugging in irix.sm
  /var/sysgen/system/irix.sm VME devices
    Configuring the System Files

configuration flags
  Descriptive Line

configuring a driver
  loadable
    Configuring a Loadable Driver
  nonloadable
    Configuring a Nonloadable Driver

Controller number, assigned in hwgraph
  Using ioconfig for Global Controller Numbers

CPU
  CPU Modules
  device access
    CPU Access to Device Registers
  IP26
    Uncached Memory Access in the IP26 and IP28
  memory access by
    CPU Access to Memory
  model number from inventory
    Testing the Inventory In Software
  processors in
    CPU Modules
  type numbers
    CPU Modules
  watchpoint registers
    Commands to Control Execution Flow

D_MP flag
  Flag D_MP

D_MT flag
  Flag D_MT

D_OLD flag
  Flag D_OLD Not Supported
  Entry Point open()

D_PCI_HOT_PLUG_ATTACH flag
  Flag D_PCI_HOT_PLUG_ATTACH

D_PCI_HOT_PLUG_DETACH flag
  Flag D_PCI_HOT_PLUG_DETACH

D_WBACK flag
  Flag D_WBACK

Data Link Provider Interface (DLPI)
  Application Interfaces

data transfer
  Transferring Data

data types
  summary table
    Kernel Data Structures and Declarations
  alenlist_t
    Address/Length Lists
    Using Address/Length Lists
  buf_t
    Structure buf_t
    Entry Point strategy()
    BP_ISMAPPED
      Buffer Location and b_flags
    displaying
      Commands to Display buf_t Objects
    for syncronization
      Coordinating Through the buf_t
    functions
      Managing Buffer Virtual Addresses
    interrupt handling
      Completing Block I/O
    management
      Strategies of the strategy() Entry Point
  caddr_t
    Address Types
  cred_t
    Use of the cred_t Object
    User Process Administration
  dev_t
    Minor Device Number
    Use of the Device Handle
    Device Number Types
    same as vertex_hdl_t
      Vertex Handle and dev_t
  device_desc_t
    Preparing a device_desc_t
    Preparing a device_desc_t
    Preparing a device_desc_t
  struct dsconf
    Testing the Driver Configuration
  struct dsreq
    ds_flags
      Values for ds_flags
    ds_msg
      Return Codes and Status Values
    ds_ret
      Return Codes and Status Values
    ds_status
      Return Codes and Status Values
  edt_t
    Entry Point edtinit()
  graph_error_t
    Graph Error Numbers
  iopaddr_t
    Address Types
  iovec_t
    Data Location and the iovec_t
  lock_t
    Lock and Semaphore Types
    Basic Locks
  mrlock_t
    Lock and Semaphore Types
    Reader/Writer Locks
  mutex_t
    Lock and Semaphore Types
    Using Mutex Locks
  paddr_t
    Address Types
  struct pollhead
    Use and Operation of poll(2)
  proc_t (not available)
    Sending a Process Signal
  scsi_request
    Using scsi_command()
  struct scsi_target_info
    Using scsi_info()
  sema_t
    Lock and Semaphore Types
  sleep_t
    Using Sleep Locks
  struct dsreq
    The dsreq Structure
  sv_t
    Lock and Semaphore Types
    Using Synchronization Variables
  uio_t
    Structure uio_t
    Entry Points read() and write()
    Transferring Data Through a uio_t Object
  __userabi_t
    Handling 32-Bit and 64-Bit Execution Models
  vertex_hdl_t
    Vertex Handle Type
  vhandl_t
    Entry Point map()
    Managing Mapped Memory

debugging kernel
  Preparing the System for Debugging

device access
  CPU Access to Device Registers

device number
  See major device number, minor device number
    Reader Comments

device special file
  Device Special Files
  as normal file
    Devices as Files
  defining
    Static Definition of Device Special Files
  /dev/dsk
    IRIX Conventional Device Names
  /dev/ei
    External Interrupts in Challenge and Onyx Systems
    External Interrupts In Origin 2000 and Origin 200
  /dev/kmem
    Access Using a Device Model
  /dev/mem
    Access Using a Device Model
    Access Using mmap()
  /dev/mmem
    Access Using mmap()
  /dev/scsi/*
    Generic SCSI Device Special Files
  EISA mapping
    Opening a Device Special File
  /hw/external_interrupt
    External Interrupts In Origin 2000 and Origin 200
  multiple names for
    Multiple Device Names
  name format
    IRIX Conventional Device Names
    Form of Filenames in /dev/scsi
  PCI mapping
    PCI Device Special Files
  VME mapping
    Opening a Device Special File

device special file/dev/kmem
  Access Using mmap()

digital media not covered
  User-Level Access to SCSI Devices

Direct Memory Access (DMA)
  Direct Memory Access
  Overview of Block I/O
  buffer alignment for
    DMA Buffer Alignment
  cache control
    Managing Memory for Cache Coherency
    The IO4 Problem
  DMA engine for VME bus
    Operation of the DMA Engine
    Operation of the DMA Engine
  EISA bus slave
    Programming Slave DMA
  EISA bus-master
    Programming Bus-Master DMA
  GIO bus
    Using DMA
  IO4 hardware problem
    The IO4 Problem
  mapping
    Creating and Using DMA Maps
    Using DMA Maps
  maximum size
    Maximum DMA Transfer Size
  setting up
    Setting Up a DMA Transfer
  user-level
    VME User-Level DMA
  user-level SCSI
    Data Transfer Options
  VME bus
    VME DMA Operations
    PIO Addressing and DMA Addressing
    VME DMA Operations
    PIO Addressing and DMA Addressing

disk volume header
  Placing symmon in the Volume Header

driver
  compiling
    Compiler Flags for MP TCP/IP
  configuring
    Configuring a Nonloadable Driver
  debugging
    Preparing the System for Debugging
  examples
    EISA
      Initialization Sketch
    GIO bus
      Example GIO Driver
    network
      Example ifnet Driver
    SCSI bus
      Creating Device Aliases
    VME
      Sample VME Device Driver
      Sample VME Device Driver
  flag constant
    Driver Flag Constant
    Public Global Variables
    Driver Flag Constant
  initialization
    Initialization Entry Points
  lower half
    Upper and Lower Halves
    Driver Lower Half
  prefix
    Driver Name Prefix
    How Names Are Used in Configuration
    in master.d
      Master Configuration Database
  process context
    User Process Administration
  types
    GIO bus
      GIO Device Drivers
  types of
    About This Guide
    User-Level Device Control
    block
      Kinds of Kernel-Level Drivers
    character
      Kinds of Kernel-Level Drivers
    EISA bus
      EISA Device Drivers
    kernel-level
      About This Guide
      Memory Use in Kernel-Level Drivers
      Kernel-Level Device Control
    layered
      Layered Drivers
    loadable
      Loadable Drivers
    network
      Network Device Drivers
    process-level
      About This Guide
    pseudo-device
      Overview of Memory Mapping
    SCSI bus
      Accessing a SCSI Device
    STREAMS
      About This Guide
      Kinds of Kernel-Level Drivers
  updating
    Updating Device Drivers from Previous Releases to IRIX 6.5
  upper half
    Upper and Lower Halves
    in multiprocessor
      Uniprocessor Assumptions
      Synchronizing Within Upper-Half Functions
  user-level
    Memory Use in User-Level Drivers
    User-Level Device Control
  See also entry points
    Reader Comments
    Reader Comments

driver debugging
  alternate console
    Specifying a Separate System Console
  breakpoints
    Commands to Control Execution Flow
  circular buffer output
    Displaying to the Circular Message Buffer
  lock metering
    Including Lock Metering in the Kernel Image
  memory display
    Commands to Display Memory
  multiprocessor
    Using symmon in a Multiprocessor Workstation
  setsym use
    Generating a Debugging Kernel
  stopping during bootstrap
    Entering symmon at Boot Time
  symbol lookup
    Commands for Symbol Conversion and Lookup
  symbols
    Enabling Debugging in irix.sm
  symmon use
    Using symmon
  system log output
    Displaying to the System Log

driver operations
  Typical Driver Operations
  DMA
    Overview of Block I/O
  ioctl
    Overview of Device Control
  mmap
    Overview of Memory Mapping
  open
    Overview of Device Open
  read
    Overview of Character Device I/O
  write
    Overview of Character Device I/O

dslib library
  Using dslib Functions
  function summary
    dslib Functions
  data transfer options
    Data Transfer Options
  doscsireq()
    Issuing a Request With doscsireq()
  ds_ctostr ()
    Using ds_vtostr() and ds_ctostr()
  ds_vtostr()
    Using ds_vtostr() and ds_ctostr()
  dsclose()
    Using dsopen() and dsclose()
  dsopen()
    Using dsopen() and dsclose()
  filldsreq()
    Using filldsreq()
  fillg0cmd()
    Using fillg0cmd() and fillg1cmd()
  fillg1cmd()
    Using fillg0cmd() and fillg1cmd()
  inquiry12()
    inquiry12()—Issue an Inquiry Command
  modeselect15()
    modeselect15()—Issue a Group 0 Mode Select Command
  modesense1a()
    modesense1a()—Send a Group 0 Mode Sense Command
  read08()
    read08() and readextended28()—Issue a Read Command
  readcapacity25()
    readcapacity25()—Issue a Read Capacity Command
  readextended28()
    read08() and readextended28()—Issue a Read Command
  releaseunit17()
    reserveunit16() and releaseunit17()—Control Logical Units
  requestsense03()
    requestsense03()—Issue a Request Sense Command
  reserveunit16()
    reserveunit16() and releaseunit17()—Control Logical Units
  senddiagnostic1d()
    senddiagnostic1d()—Issue a Send Diagnostic Command
  testunitready00()
    testunitready00—Issue a Test Unit Ready Command
  write0a()
    write0a() and writeextended2a()—Issue a Write Command
  writeextended2a()
    write0a() and writeextended2a()—Issue a Write Command

dsreq driver
  Overview of the dsreq Driver
  data transfer options
    Data Transfer Options
  DS_ABORT
    Using DS_ABORT
  DS_CONF
    Testing the Driver Configuration
  DS_RESET
    Using DS_RESET
  exclusive open
    Relationship to Other Device Special Files
  flags
    Values for ds_flags
  return codes
    Return Codes and Status Values
  scatter/gather
    Data Transfer Options
  struct dsconf
    Testing the Driver Configuration
  struct dsreq
    The dsreq Structure
    ds_flags
      Values for ds_flags
    ds_msg
      Return Codes and Status Values
    ds_ret
      Return Codes and Status Values
    ds_status
      Return Codes and Status Values

EISA bus
  EISA Device Drivers
  address mapping
    EISA Address Mapping
  address spaces
    EISA Address Spaces
  allocate DMA channel
    Allocating a DMA Channel
  allocate IRQ
    Allocating IRQs and Channels
  byte order
    EISA Byte Ordering
  card slots
    Available Card Slots
  configuring
    EISA Configuration
  DMA to bus master
    Programming Bus-Master DMA
  example driver
    Initialization Sketch
  interrupts
    EISA Interrupts
    Interrupt Priority Scheduling
  kernel services
    Kernel Functions for EISA Support
  locked cycles
    EISA Locked Cycles
  mapping into user process
    EISA Mapping Support
  overview
    EISA Bus Overview
  PIO bandwidth
    EISA PIO Bandwidth
  PIO mapping
    Mapping PIO Addresses
  product identifier
    EISA Product Identifier
  request arbitration
    EISA Request Arbitration
  user-level PIO
    EISA Programmed I/O

ELF object format
  Compiling and Linking

entry points
  summary table
    Entry Point Summary
    Driver Exported Names
  attach
    Entry Point attach()
    About Attaching a Device
    About Attaching a Device
    PCI Hot Plug insert operation
      PCI Hot Plug Insert Operation
  close
    Entry Point close()
    Persistent Mappings
    Entry Point close()
  detach
    Entry Point detach()
    PCI Hot Plug detach operation
      PCI Hot Plug Detach Operation
  devflag
    Driver Flag Constant
    Public Global Variables
  edtinit
    Entry Point edtinit()
    Loading
    Initializing a VME Device
    GIO Driver edtinit() Entry Point
  halt
    Entry Point halt()
  info
    Streamtab Structure
  init
    Entry Point init()
    Loading
    Initialization Entry Points
  interrupt
    Interrupt Entry Point and Handler
    GIO Driver Interrupt Handler
  ioctl
    Control Entry Point
    Handling 32-Bit and 64-Bit Execution Models
  map
    Entry Point map()
  mmap
    Entry Point mmap()
  mversion
    Configuring a Loadable Driver
    Public Global Variables
  open
    Entry Point open()
    Entry Point open()
    mode flag
      Use of the Open Flag
    type flag
      Use of the Open Type
  poll
    Poll Entry Point
    and interrupts
      Calling pollwakeup()
  print
    Entry Point print()
  read
    Entry Points read() and write()
  reg
    Entry Point reg()
    Loading
    Designing a SCSI Driver
    About PCI Drivers
  size
    Saving the Size of a Block Device
    Entry Point size()
  start
    Entry Point start()
    Loading
    Initialization Entry Points
  strategy
    Entry Point strategy()
    called from read or write
      Calling Entry Point strategy() From Entry Point read() or write()
    design models
      Waiting for Block I/O to Complete
  unload
    Persistent Mappings
    Entry Point unload()
    Unloading
    About Unloading a SCSI Driver
    About Unloading
  unmap
    Entry Point unmap()
  unreg
    Entry Point unreg()
  when called
    Entry Point Calling Sequence
  write
    Entry Points read() and write()

example driver
  Example ifnet Driver
  Driver Example
  Sample VME Device Driver
  Sample VME Device Driver
  Creating Device Aliases
  Initialization Sketch
  Example GIO Driver

execution model
  Handling 32-Bit and 64-Bit Execution Models

external interrupt
  Managing External Interrupts
  Control of External Interrupts
  Challenge architecture
    External Interrupts in Challenge and Onyx Systems
  generate
    Generating Outgoing Signals
    Generating Outgoing Signals
  input is level-triggered
    Responding to Incoming External Interrupts
    Responding to Incoming External Interrupts
  Origin2000 architecture
    External Interrupts In Origin 2000 and Origin 200
  pulse widths
    Detecting Invalid External Interrupts
  set pulse widths
    Setting the Expected Pulse Width

FibreChannel
  A Note on FibreChannel Drivers

fixed PIO map
  Fixed PIO Maps
  Fixed PIO Maps

Flag D_PCI_HOT_PLUG_ATTACH
  Flag D_PCI_HOT_PLUG_ATTACH

Flag D_PCI_HOT_PLUG_DETACH
  Flag D_PCI_HOT_PLUG_DETACH

fmodsw table
  Kernel Switch Tables

function
  See IRIX functions, kernel functions
    Reader Comments

GIO bus
  GIO Device Drivers
  address space mapping
    GIO Bus Address Spaces
  configuring
    Configuring a GIO Device
  edtinit entry point
    GIO Driver edtinit() Entry Point
  example driver
    Example GIO Driver
  interrupt handler
    GIO Driver Interrupt Handler
  kernel services
    GIO-Specific Kernel Functions
  memory parity checking with
    Memory Parity Workarounds

hardware graph
  See hwgraph
    Reader Comments

hardware inventory
  Hardware Inventory
  adding entries to
    Creating an Inventory Entry
  contents
    Contents of the Inventory
  hinv displays
    Displaying the Inventory with hinv
  network driver use
    Network Inventory Entries
  software interface to
    Testing the Inventory In Software

header files
  summary table
    Important Header Files
  dslib.h
    dslib Functions
  for network drivers
    Principal ifnet Header Files
  sgidefs.h
    Allowing for 64-Bit Mode
  sys/cmnerr.h
    Using cmn_err
  sys/debug.h
    Using ASSERT
  sys/file.h
    Use of the Open Flag
  sys/immu.h
    Working With Page and Sector Units
  sys/invent.h
    Testing the Inventory In Software
    Creating an Inventory Entry
  sys/open.h
    Use of the Open Type
  sys/param.h
    Structure buf_t
  sys/PCI/pciio.h
    About Registration
    About PCI Drivers
  sys/poll.h
    Use and Operation of poll(2)
  sys/region.h
    Entry Point map()
  sys/sema.h
    Lock and Semaphore Types
  sys/sysmacros.h
    Working With Page and Sector Units
  sys/types.h
    Allowing for 64-Bit Mode
  sys/uio.h
    Structure uio_t
  sys/var.h
    System Tuning Parameters

/hw filesystem
  See hwgraph
    Reader Comments

hwgraph
  Hardware Graph
  and attach entry point
    Completing the hwgraph
    About Attaching a Device
  and top-half entry point
    Use of the Device Handle
  and VME
    VME Bus and Interrupt Naming
  controller numbers assigned
    Using ioconfig for Global Controller Numbers
  data types in
    Hardware Graph Types
  definition
    Hardware Graph Features
  display by symmon
    Commands to Display the hwgraph
  edge
    Hwgraph Nomenclature
    implicit
      Implicit Edges
  hardware inventory in
    Creating an Inventory Entry
  /hw filesystem reflects
    /hw Filesystem
  implicit edge
    Implicit Edges
  justification for
    UNIX Hardware Assumptions, Old and New
  nomenclature
    Hwgraph Nomenclature
  relation to driver
    Definition and Use of /hw Entries
  use by SCSI driver
    SCSI Devices in the hwgraph
  vertex
    Hwgraph Nomenclature
    properties
      Properties of Edges and Vertexes

idbg debugger
  Enabling Debugging in irix.sm
  Using idbg
  command line use
    Invoking idbg for a Single Command
  command syntax
    Commands of idbg
  configuring in kernel
    Including idbg in the Kernel Image
  display I/O status
    Commands to Display I/O Status
  display process data
    Commands to Display Process Information
  interactive mode
    Invoking idbg for Interactive Use
  invoking
    Loading and Invoking idbg
  loading
    Loading and Invoking idbg
  lock meter display
    Commands to Display Locks and Semaphores
  log file output
    Invoking idbg with a Log File
  memory display
    Commands to Display Memory and Symbols

ide PROM monitor
  Placing symmon in the Volume Header

include file
  See header files
    Reader Comments

INCLUDE statement
  Entry Point edtinit()
  Configuring a Kernel
  Loading

initialization
  Initialization Entry Points

inode
  Overview of Device Open

interrupt
  Driver Lower Half
  and strategy entry point
    Completing Block I/O
  associating to a driver
    Associating Interrupt to Driver
  concurrent with processing
    Uniprocessor Assumptions
  enabled during initialization
    When Initialization Is Performed
  handler runs as thread
    Interrupts as Threads
  latency
    Interrupt Performance and Latency
  mutual exclusion with
    Mutual Exclusion
  on multiprocessor
    Mutual Exclusion
  preemption of
    Hardware Exclusion Is Ineffective

inventory
  See hardware inventory
    Reader Comments

IO4 board
  VME Hardware Architecture
  multiple DMA problem
    Challenge DMA with Multiple IO4 Boards

IP26 CPU
  Uncached Memory Access in the IP26 and IP28

IPL statement
  Using the IPL Statement

IRIX 6.5 and PCI drivers
  IRIX 6.5 PCI Drivers

IRIX 6.5 device drivers
  Updating Device Drivers from Previous Releases to IRIX 6.5

IRIX commands
  autoconfig
    Configuring a Nonloadable Driver
    Configuring a Kernel
    Generating a Debugging Kernel
  dvhtool
    Placing symmon in the Volume Header
  hinv
    Displaying the Inventory with hinv
    and MAKEDEV
      The Script MAKEDEV
    for CPU type
      Interrogating the CPU Type
  install
    Making Conventional Device Files
    Static Definition of Device Special Files
  ioconfig
    Using ioconfig for Global Controller Numbers
    with VME
      VME Bus Numbers Assigned by ioconfig
  lboot
    Kernel Configuration Files
    builds switch tables
      Kernel Switch Tables
    driver prefix with
      Entry Point Naming and lboot
  mknod
    Making Conventional Device Files
    Static Definition of Device Special Files
  ml
    Loadable Drivers
  mount
    Overview of Device Open
    Entry Point open()
  nvram
    Specifying a Separate System Console
  setsym
    Generating a Debugging Kernel
  systune
    System Tuning Parameters
    Unloading
    max DMA size
      Maximum DMA Transfer Size
    switch table size
      Kernel Switch Tables
  umount
    Entry Point close()
  uname
    Interrogating the CPU Type
  versions
    Placing symmon in the Volume Header

IRIX functions
  close()
    Entry Point close()
  endinvent()
    Testing the Inventory In Software
  getinvent()
    Testing the Inventory In Software
  getpagesize()
    Virtual Address Mapping
  ioctl()
    User-Level Control of SCSI Devices
    Managing External Interrupts
    Overview of Device Control
  kmem_alloc()
    Driver Upper Half
  mmap ()
    EISA PIO
      Using the mmap() Function
    PCI PIO
      Using mmap() With PCI Devices
    VME PIO
      Using the mmap() Function
  mmap()
    Access Using mmap()
    Overview of Memory Mapping
    Concepts and Use of mmap()
  munmap()
    Entry Point unmap()
  open ()
    with dsreq driver
      Relationship to Other Device Special Files
  open()
    Overview of Device Open
    Entry Point open()
  pio_badaddr ()
    Testing the PIO Map
    Testing the PIO Map
  poll()
    Use and Operation of poll(2)
  read()
    Overview of Character Device I/O
    Overview of Block I/O
  setinvent()
    Testing the Inventory In Software
  syslog()
    Displaying to the System Log
  write()
    Overview of Character Device I/O
    Overview of Block I/O

jag (SCSI-toVME) adapter
  Names of SCSI Devices on the Jag (VME Bus) Controller

kernel address space
  driver runs in
    Memory Use in Kernel-Level Drivers
  mapping to user space
    Memory Use in User-Level Drivers

kernel execution model
  Handling 32-Bit and 64-Bit Execution Models

kernel functions
  summary table
    Kernel Functions
  add_to_inventory()
    Creating an Inventory Entry
  alenlist_create()
    Creating Alenlists
  alenlist_cursor_offset()
    Using Alenlist Cursors
  alenlist_destroy()
    Creating Alenlists
  alenlist_get()
    Using Alenlist Cursors
  badaddr()
    Testing Device Physical Addresses
  bcopy()
    Block Copy Functions
  biodone()
    Completing Block I/O
    Strategies of the strategy() Entry Point
  bioerror()
    Completing Block I/O
  biowait()
    Strategies of the strategy() Entry Point
  bp_mapin()
    Managing Buffer Virtual Addresses
  brelse()
    Allocating buf_t Objects and Buffers
  buf_to_alenlist()
    Loading Alenlists
  bzero()
    Block Copy Functions
  cmn_err()
    Producing Diagnostic Displays
    buffer output
      Displaying to the Circular Message Buffer
    system log output
      Displaying to the System Log
  copyin()
    Control Entry Point
    Block Copy Functions
  copyout()
    Control Entry Point
    Block Copy Functions
  device_admin_info_get()
    Retrieving Administrator Attributes
  device_controller_number_get()
    Attaching Inventory Information
  device_controller_number_set()
    Attaching Inventory Information
  device_driver_admin_info_get()
    Retrieving Administrator Attributes
  device_info_get()
    Interrogating the hwgraph
  device_info_set()
    Extending the Graph With a Single Vertex
    Setting Up the Hardware Graph
  device_inventory_add()
    Extending the Graph With a Single Vertex
    Attaching Inventory Information
  device_inventory_get_next()
    Interrogating the hwgraph
  dki_dcache_inval()
    Managing Memory for Cache Coherency
  dki_dcache_wb()
    Managing Memory for Cache Coherency
  dma_map ()
    Using a DMA Map
    Using a DMA Map
    Programming Bus-Master DMA
  dma_mapaddr ()
    Using a DMA Map
    Using a DMA Map
    Programming Bus-Master DMA
  dma_mapalloc ()
    Mapping DMA Addresses
    Mapping DMA Addresses
    Programming Bus-Master DMA
  drv_getparm()
    User Process Administration
  drv_priv()
    Use of the cred_t Object
    User Process Administration
  drvhztousec()
    Time Units
  drvusectohz()
    Time Units
  eisa_dmachan_alloc ()
    Allocating a DMA Channel
  eisa_ivec_alloc ()
    Allocating and Programming an IRQ
  fasthzto()
    Time Units
  flushbus()
    Managing Memory for Cache Coherency
  fubyte()
    Byte and Word Functions
  get_current_abi()
    Handling 32-Bit and 64-Bit Execution Models
  geteblk()
    Allocating buf_t Objects and Buffers
  getemajor()
    Historical Use of the Device Numbers
  geteminor()
    Historical Use of the Device Numbers
  getinvent()
    Interrogating the CPU Type
  getrbuf()
    Allocating buf_t Objects and Buffers
  hwgraph_block_device_add()
    Extending the Graph With Multiple Vertexes
  hwgraph_char_device_add()
    Extending the Graph With a Single Vertex
    Extending the Graph With Multiple Vertexes
    Vertexes for Modes of Use
    Setting Up the Hardware Graph
  hwgraph_edge_add()
    Extending the Graph With Multiple Vertexes
    Vertexes for Modes of Use
  hwgraph_edge_remove()
    Vertexes for Modes of Use
  hwgraph_info_add_LBL()
    Attaching Attributes
  hwgraph_info_export_LBL()
    Attaching Attributes
  hwgraph_info_get_LBL()
    Attaching Attributes
    Retrieving Administrator Attributes
  hwgraph_info_remove_LBL()
    Attaching Attributes
  hwgraph_info_replace_LBL()
    Attaching Attributes
  hwgraph_info_unexport_LBL()
    Attaching Attributes
  hwgraph_inventory_get_next()
    Attaching Inventory Information
  hwgraph_vertex_create()
    Extending the Graph With Multiple Vertexes
    Vertexes for Modes of Use
  hwgraph_vertex_destroy()
    Vertexes for Modes of Use
  initnsema()
    Converting a Uniprocessor Driver
  initnsema_mutex() (not supported)
    Semaphores
  ip26_enable_ucmem()
    Program Access to Uncached Memory
  ip26_return_ucmem()
    Program Access to Uncached Memory
  itimeout()
    Use of pollwakeup() Without Interrupts
    Timer Support
  kmem_alloc()
    Kernel Virtual Space—kseg2
    General-Purpose Allocation
  kmem_free()
    Extending the Graph With a Single Vertex
    Vertexes for Modes of Use
    Setting Up the Hardware Graph
  kmem_zalloc()
    General-Purpose Allocation
    Extending the Graph With a Single Vertex
    Vertexes for Modes of Use
    Setting Up the Hardware Graph
  kvaddr_to_alenlist()
    Loading Alenlists
  kvtophys()
    Converting Virtual Addresses to Physical
  makedevice()
    Historical Use of the Device Numbers
  pciio_dmamap_addr()
    Mapping a Specific Buffer
  pciio_dmamap_alloc()
    Allocating DMA Maps
  pciio_dmamap_done()
    Deactivating Addresses and Maps
  pciio_dmamap_list()
    Mapping an Address/Length List
  pciio_dmatrans_addr()
    Using One-Step DMA Translation
  pciio_dmatrans_list()
    Using One-Step DMA Translation
  pciio_driver_register()
    About Registration
    About Registration
  pciio_error_register()
    Registering an Error Handler
  pciio_intr_alloc()
    Creating an Interrupt Object
  pciio_intr_connect()
    Connecting the Handler
  pciio_intr_disconnect()
    Disconnecting the Handler
  pciio_piomap_addr()
    Performing PIO With a PIO Map
  pciio_piomap_alloc()
    Allocating PIO Maps
    Interrogating PIO Maps
  pciio_piomap_done()
    Deactivating an Address and Map
  pciio_piotrans_addr()
    Using One-Step PIO Translation
  phalloc()
    Use and Operation of poll(2)
    Allocating pollhead Objects
  phfree()
    Allocating pollhead Objects
  physiock()
    Flag D_WBACK
    Calling Entry Point strategy() From Entry Point read() or write()
  pio_baddr ()
    Testing the PIO Map
  pio_bcopyin ()
    Using the PIO Map in Functions
    Using the PIO Map in Functions
    Using the PIO Map in Functions
  pio_bcopyout ()
    Using the PIO Map in Functions
    Using the PIO Map in Functions
    Using the PIO Map in Functions
  pio_map_alloc ()
    Initialization Sketch
  pio_mapaddr ()
    Using the Mapped Address
    Using the Mapped Address
  pio_mapalloc ()
    PIO Addressing in Challenge and Onyx Systems
    Mapping PIO Addresses
    Mapping PIO Addresses
  pio_wbadaddr ()
    Testing the PIO Map
    Testing the PIO Map
  pollwakeup()
    Use of pollwakeup()
    Calling pollwakeup()
  printf()
    Using printf()
  psema()
    Converting a Uniprocessor Driver
    Using a Semaphore for Mutual Exclusion
  ptob()
    Virtual Address Mapping
  setgioconfig ()
    Configuring a Slot
  setgiovector ()
    Registering an Interrupt Handler
  sleep()
    Using sleep() and wakeup()
  splhi()
    denigrated
      Priority Level Functions
    meaningless
      Uniprocessor Assumptions
  splnet()
    ineffective
      Ineffective spl*() Functions
  splvme()
    useless
      Converting a Uniprocessor Driver
  subyte()
    Byte and Word Functions
  timeout()
    Timer Support
  uiomove()
    Transferring Data Through a uio_t Object
  uiophysio()
    Calling Entry Point strategy() From Entry Point read() or write()
  untimeout()
    Timer Support
  userabi()
    Handling 32-Bit and 64-Bit Execution Models
  uvaddr_to_alenlist()
    Loading Alenlists
  v_getaddr()
    Managing Mapped Memory
  v_gethandle()
    Managing Mapped Memory
  v_mapphys()
    Entry Point map()
    Managing Mapped Memory
  vme_ivec_alloc ()
    Allocating a Vector
    Allocating a Vector
  vme_ivec_free ()
    Releasing a Vector
    Releasing a Vector
  vme_ivec_set ()
    Allocating a Vector
    Allocating a Vector
  vsema()
    Converting a Uniprocessor Driver
    Using a Semaphore for Mutual Exclusion
  vt_gethandle()
    Entry Point map()
    Entry Point unmap()
  wakeup()
    Using sleep() and wakeup()

kernel mode of processor
  Processor Operating Modes

kernel panic
  address exception
    Address Exceptions
  moving data
    Transferring Data

kernel switch tables
  Kernel Switch Tables

kernel-level driver
  About This Guide
  Kernel-Level Device Control
  Structure of a Kernel-Level Driver
  structure of
    Summary of Driver Structure

layered driver
  Layered Drivers

lboot
  See IRIX commands
    Reader Comments

loadable driver
  Loadable Drivers
  and switch table
    Kernel Switch Tables
  autoregister
    Initialization of Loadable Drivers
  compiler options
    Compile Options for Loadable Drivers
  configuring
    Configuring a Loadable Driver
  initialization
    Initialization of Loadable Drivers
  loading
    Loading
  master.d
    Master File for Loadable Drivers
  mversion entry
    Public Global Variables
  not in miniroot
    Loadable Drivers
  registration
    Registration
  unloading
    Unloading

loadable driver attach() entry point
  Return Value from Attach

loadable driver reg() entry point
  Return Value from Attach

loading a driver
  Loading

lock metering support
  Including Lock Metering in the Kernel Image
  Commands to Display Locks and Semaphores

locking
  See mutual exclusion
    Reader Comments

lower half of driver
  Driver Lower Half

major device number
  Major Device Number
  Device Number Types
  for STREAMS clone
    Using the CLONE Driver
    Recognizing a Clone Request Independently
  in /dev/scsi
    Major and Minor Device Numbers in /dev/scsi
  in inode
    Devices as Files
  in master.d
    Master Configuration Database
    Descriptive Line
  in variables in master.d
    Variables Section
  input to open
    Overview of Device Open
  selecting
    Selecting a Major Number

/dev/MAKEDEV
  Creating Conventional Device Names
  Generic SCSI Device Special Files
  Device Number Types
  Dynamic Definition of Device Special Files
  adding to /dev/scsi
    Creating Additional Names in /dev/scsi

master.d configuration files
  See configuration files, /var/sysgen/master.d
    Reader Comments

memory
  Physical and Virtual Memory

memory address
  cached
    Cached Physical Memory—kseg0
  physical
    EISA Address Mapping
    Commands to Control Execution Flow
  uncached
    Uncached Physical Memory—kseg1

memory allocation
  Kernel Memory Allocation

memory display
  Commands to Display Memory

memory mapping
  Memory Use in User-Level Drivers
  Memory Map Entry Points

migrating drivers from previous releases
  Updating Device Drivers from Previous Releases to IRIX 6.5

miniroot
  no loadable drivers
    Loadable Drivers

minor device number
  Minor Device Number
  Device Number Types
  encoding
    Historical Use of Minor Number
  for STREAMS clone driver
    Using the CLONE Driver
    Recognizing a Clone Request Independently
  in /dev/scsi
    Major and Minor Device Numbers in /dev/scsi
  in inode
    Devices as Files
  input to open
    Overview of Device Open
    Use of the Device Handle
  selecting
    Selecting Minor Numbers

multiprocessor
  converting to
    Converting a Uniprocessor Driver
  driver design for
    Designing for Multiprocessor Use
    Special Considerations for Multiprocessing
  driver flag D_MP
    Flag D_MP
  drivers for
    Drivers for Multiprocessors
  interrupt handling on
    Mutual Exclusion
  network drivers in
    Multiprocessor Considerations
  splhi() useless in
    Uniprocessor Assumptions
  synchronizing upper-half code
    Synchronizing Within Upper-Half Functions
  uniprocessor assumptions invalid
    Uniprocessor Assumptions
  uniprocessor drivers use CPU 0
    Drivers for Multiprocessors
  using symmon in
    Using symmon in a Multiprocessor Workstation

mutex locks
  Using Mutex Locks

mutual exclusion
  Mutual Exclusion Compared to Waiting
  Basic Locks
  basic locks
    Basic Locks
  in multiprocessor drivers
    Protecting Common Data
  in network driver
    Mutual Exclusion Macros
  mutex locks
    Using Mutex Locks
  priority inheritance
    Using Mutex Locks
  reader/writer locks
    Reader/Writer Locks
  semaphore
    Using a Semaphore for Mutual Exclusion
  sleep locks
    Using Sleep Locks

names of devices
  IRIX Conventional Device Names
  Form of Filenames in /dev/scsi

network
  Network Device Drivers
  based on 4.3BSD
    Network Driver Interfaces
  driver interfaces
    Network Driver Interfaces
  example driver
    Example ifnet Driver
  header files
    Principal ifnet Header Files
  multiprocessor considerations
    Multiprocessor Considerations
  overview
    Overview of Network Drivers
  STREAMS protocol stack
    Application Interfaces

network driver
  debugging
    Commands to Display Network-Related Structures

Network File System (NFS)
  Application Interfaces

O2 PCI driver
  PCI Drivers for the O2 (IP32) Platform

page size
  I/O
    Working With Page and Sector Units
  macros
    Working With Page and Sector Units
  memory
    Virtual Address Mapping
    Working With Page and Sector Units

parity check with GIO
  Memory Parity Workarounds

PCI bus
  arbitration
    Slot Priority and Bus Arbitration
    Bus Arbitration
  base address register
    Configuration Register Initialization
    Configuration Register Initialization
  byte order
    Byte Order Considerations
  cache line size
    Configuration Register Initialization
    Configuration Register Initialization
  configuration
    initialized
      Configuration Register Initialization
      Configuration Register Initialization
  configuration space
    Byte Order for PIO
    Accessing the Device Configuration
  device ID
    About Registration
    About Attaching a Device
  driver structure
    Designing a SCSI Driver
    About PCI Drivers
  endianness
    Byte Order Considerations
  error handler
    Registering an Error Handler
  implementation
    PCI Device Attachment
  interrupt handler
    Registering an Interrupt Handler
  interrupt lines
    Interrupt Signal Distribution
    Interrupt Signal Distribution
  kernel services
    Services for PCI Drivers
  latency of
    Architectural Implications
  latency timer
    Configuration Register Initialization
    Configuration Register Initialization
  register driver
    About Registration
  slot versus device
    Buses, Slots, Cards, and Devices
  user-level PIO
    PCI Programmed I/O
  vendor ID
    About Registration
    About Registration
    About Attaching a Device
  versus system bus
    PCI Bus and System Bus

PCI card
  Interrupt Signal Distribution
  interrupts
    Interrupt Signal Distribution
    overloaded
      Interrupt Signal Distribution

PCI drivers and IRIX 6.5
  IRIX 6.5 PCI Drivers

PCI drivers for O2
  PCI Drivers for the O2 (IP32) Platform

PCI Hot Plug insert operation
  PCI Hot Plug Insert Operation
  PCI Hot Plug Insert Operation

PCI Hot Plug removal operation
  PCI Hot Plug Detach Operation

pciba, usrpci
  PCI Programmed I/O

pcibr_get_dmatrans_node() function
  Using One-Step DMA Translation

pciio_driver_register()
  Return Value from Attach

pciio_pio_* routines
  PCI Drivers for the O2 (IP32) Platform

physical address format
  64-bit
    Physical Address

pipe semantics
  Support for Pipes

prefix
  Master Configuration Database
  Driver Name Prefix
  How Names Are Used in Configuration

primary cache
  CPU Access to Memory

priority inheritance
  Using Mutex Locks

priority level functions
  Priority Level Functions

privilege checking
  User Process Administration

process
  User Process Administration
  display data about
    Commands to Display Process Information
  handle of
    Sending a Process Signal
  sending signal to
    Sending a Process Signal
  table of in kernel
    Commands to Display Process Information

process-level driver
  About This Guide

processor
  kernel mode
    Processor Operating Modes
  types
    CPU Modules
  user mode
    Processor Operating Modes

Programmed I/O (PIO)
  CPU Access to Device Registers
  User-Level Access to Devices
  VME PIO Operations
  address maps for
    Creating and Using PIO Maps
    PIO Addressing in Challenge and Onyx Systems
    Mapping PIO Addresses
    Using PIO Maps
  EISA bus
    EISA Programmed I/O
    Mapping PIO Addresses
  GIO bus
    Using PIO
  PCI bus
    PCI Programmed I/O
  VME bus
    VME Programmed I/O
    VME PIO Operations
    PIO Addressing and DMA Addressing
    VME PIO Operations
    VME PIO Operations
    PIO Addressing and DMA Addressing

pseudo-device driver
  Overview of Memory Mapping

putbuf circular buffer
  Displaying to the Circular Message Buffer
  Commands to Display Memory and Symbols

raw device
  See character device
    Reader Comments

reader/writer locks
  Reader/Writer Locks

register a driver
  loadable driver for callback
    Registration
  PCI driver
    About Registration
    About Registration
  reg entry point
    Entry Point reg()

sash standalone shell
  Placing symmon in the Volume Header

SCSI bus
  SCSI Device Drivers
  adapter error codes
    Adapter Error Codes (Table scsi_adaperrs_tab)
  adapter number
    Names of SCSI Devices on a SCSI Bus
  command
    Inquiry
      inquiry12()—Issue an Inquiry Command
      Using scsi_info()
    Mode Select
      modeselect15()—Issue a Group 0 Mode Select Command
    Mode Sense
      modesense1a()—Send a Group 0 Mode Sense Command
    Read
      read08() and readextended28()—Issue a Read Command
    Read Capacity
      readcapacity25()—Issue a Read Capacity Command
    Request Sense
      requestsense03()—Issue a Request Sense Command
    Reserve Unit
      reserveunit16() and releaseunit17()—Control Logical Units
    Send Diagnostic
      senddiagnostic1d()—Issue a Send Diagnostic Command
    Test Unit Ready
      testunitready00—Issue a Test Unit Ready Command
    Write
      write0a() and writeextended2a()—Issue a Write Command
  display request structure
    Commands to Display I/O Status
  driver
    Accessing a SCSI Device
  error messages
    SCSI Error Messages
  example driver
    Creating Device Aliases
  hardware support overview
    SCSI Hardware Support
  host adapter
    Host Adapter Drivers
    functions of
      Overview of Host Adapter Functions
    purpose
      Purpose of the Host Adapter Driver
    scsi_abort ()
      Using scsi_abort()
    scsi_alloc ()
      Using scsi_alloc()
    scsi_command ()
      Using scsi_command()
    scsi_free ()
      Using scsi_free()
    scsi_info ()
      Using scsi_info()
    vectors to
      How the Host Adapter Functions Are Found
  kernel overview
    IRIX Kernel SCSI Support
  LUN
    Names of SCSI Devices on a SCSI Bus
    Logical Unit Numbers (LUNs)
  message string tables
    SCSI Error Message Tables
  sense codes
    SCSI Sense Codes (Table scsi_key_msgtab)
  target ID
    Names of SCSI Devices on a SCSI Bus
  target number
    Target Numbers
  user-level access
    User-Level Control of SCSI Devices
    User-Level Access to SCSI Devices
  See also dsreq driver
    User-Level Access to SCSI Devices

secondary cache
  CPU Access to Memory

sector unit macros
  Working With Page and Sector Units

semaphore
  Semaphores
  for mutual exclusion
    Using a Semaphore for Mutual Exclusion
  for waiting
    Using a Semaphore for Waiting

sign extension of 32-bit addresses
  Compatibility of 32-Bit and 64-Bit Spaces

signal
  Sending a Process Signal

SIGSEGV
  Address Exceptions

Silicon Graphics
  developer program
    Developer Program
  FTP server
    Internet Resources
  VME bus hardware
    About VME Bus Attachment
    VME Bus in Challenge and Onyx Systems
  WWW server
    Internet Resources

64-bit address space
  See address space, 64-bit
    Reader Comments
  See Numbers
    Reader Comments

sleep locks
  Using Sleep Locks

socket interface
  Application Interfaces

stray VME interrupt
  Vector Errors
  Vector Errors

STREAMS
  STREAMS Drivers
  function summary
    Summary of Standard STREAMS Functions
  clone driver
    Support for CLONE Drivers
  close entry point
    Entry Point close()
  debugging
    Commands to Display STREAMS Structures
  display data structures
    Commands to Display STREAMS Structures
  driver
    About This Guide
  extended poll support
    Extension of Poll and Select
  module_info structure
    Streamtab Structure
  multiprocessor design
    Special Considerations for Multiprocessing
  multithreaded monitor
    Special Considerations for Multiprocessing
  open entry point
    Entry Point open()
  put functions
    Put Functions wput() and rput()
  service scheduling
    Service Scheduling
  srv functions
    Service Functions rsrv() and wsrv()
  streamtab structure
    Streamtab Structure
  supplied drivers
    Supplied STREAMS Modules

STREAMS protocol stack
  Application Interfaces

structure of driver
  Summary of Driver Structure

switch table
  Kernel Switch Tables

symmon debugger
  Placing symmon in the Volume Header
  Using symmon
  breakpoints
    Commands to Control Execution Flow
  command syntax
    Commands of symmon
  how invoked
    How symmon Is Entered
  hwgraph display
    Commands to Display the hwgraph
  in multiprocessor
    Using symmon in a Multiprocessor Workstation
  in uniprocessor
    Using symmon in a Uniprocessor Workstation
  invoking at bootstrap
    Entering symmon at Boot Time
  memory display
    Commands to Display Memory
  prompt
    How symmon Is Entered
  symbol lookup
    Commands for Symbol Conversion and Lookup
  virtual memory commands
    Commands to Manage Virtual Memory
  watchpoint register use
    Commands to Control Execution Flow

synchronization variable
  Using Synchronization Variables

SysAD bus parity checks
  Memory Parity Workarounds

sysgen files
  See configuration files
    Reader Comments

system console
  alternate
    Specifying a Separate System Console

system log display
  Displaying to the System Log

systune
  See IRIX commands
    Reader Comments

terminal as console
  Specifying a Separate System Console

32-bit entries see Numbers
  Reader Comments

thread
  interrupt runs on
    Interrupts as Threads

tick
  Time Units

time unit functions
  Time Units

TLI interface
  Application Interfaces

Translate Lookaside Buffer (TLB)
  CPU Access to Memory

Translation Lookaside Buffer (TLB)
  Virtual Address Mapping
  maps kernel space
    Kernel Virtual Space—xkseg
  maps kuseg
    User Process Space—kuseg
  number of entries in
    TLB Misses and TLB Sizes

udmalib
  VME User-Level DMA

uncached memory access
  32-bit
    Uncached Physical Memory—kseg1
  64-bit
    Cache-Controlled Physical Memory—xkphys
  do not map
    Entry Point map()
  IP26
    Uncached Memory Access in the IP26 and IP28
  none in Challenge
    Uncached Memory Access in SGI Origin 2000 and in Challenge and Onyx Series

uniprocessor
  converting driver
    Converting a Uniprocessor Driver
  using symmon
    Using symmon in a Uniprocessor Workstation

unloading a driver
  Unloading

updating drivers
  Updating Device Drivers from Previous Releases to IRIX 6.5

upper half of driver
  Upper and Lower Halves

upper half of of driver
  Uniprocessor Assumptions
  Synchronizing Within Upper-Half Functions

USE statement
  Entry Point edtinit()
  Configuring a Kernel

user mode of processor
  Processor Operating Modes

user-level DMA
  VME User-Level DMA

user-level driver
  User-Level Device Control

user-level process
  User-Level Device Control

usrpci, pciba
  PCI Programmed I/O

variables in master.d
  Variables Section

VECTOR statement
  Associating Interrupt to Driver
  Configuring a Kernel
  Loading
  edtinit entry point
    Entry Point edtinit()
  EISA kernel driver
    Configuring IRIX
  EISA PIO
    Learning EISA Device Addresses
  GIO bus
    GIO VECTOR Line
  use of probe=
    Using the probe and exprobe Parameters
  VME devices
    Configuring the System Files

vfssw table
  Kernel Switch Tables

virtual memory
  CPU Access to Memory
  Virtual Address Mapping
  32-bit mapping
    Virtual Address Mapping
  64-bit mapping
    Virtual Address Mapping
  debug display of
    Commands to Manage Virtual Memory
  page size
    Virtual Address Mapping

virtual page number (VPN)
  32-bit
    Virtual Address Mapping

VME bus
  VME Device Attachment on Origin 2000/Onyx2
  VME Device Attachment on Challenge/Onyx
  adapter number
    Names of SCSI Devices on the Jag (VME Bus) Controller
  address modifier
    VME Address Spaces
  bus address spaces
    VME Address Spaces
    About VME Bus Addresses and System Addresses
    VME Address Spaces
    VME Bus Addresses and System Addresses
    mapping
      User-Level and Kernel-Level Addressing
      User-Level and Kernel-Level Addressing
  bus cycles
    VME Transactions
    VME Transactions
  configuring
    Configuring VME Devices
  DMA engine
    Operation of the DMA Engine
    Operation of the DMA Engine
  DMA to
    address maps
      Creating and Using DMA Maps
      Mapping DMA Addresses
      Mapping DMA Addresses
    addresses
      DMA Addressing
  example driver
    Sample VME Device Driver
    Sample VME Device Driver
  hardware
    Challenge
      VME Hardware in Challenge and Onyx Systems
    design constraints
      VME Hardware Features and Restrictions
    DMA cycle
      VME DMA Operations
      VME DMA Operations
    interrupt priority
      VME Interrupt Priority
    overview
      About VME Bus Attachment
      VME Bus in Challenge and Onyx Systems
    PIO cycle
      VME PIO Operations
      VME PIO Operations
    relation to system bus
      The VME Bus Controller
      The VME Bus Controller
  history
    VME History
    VME History
  hwgraph use
    VME Bus and Interrupt Naming
  interrupt levels
    VME Transactions
    VME Transactions
  interrupt vector
    Handling VME Interrupts
    Allocating an Interrupt Vector Dynamically
    Allocating an Interrupt Vector Dynamically
  jag adapter
    Names of SCSI Devices on the Jag (VME Bus) Controller
  kernel services
    Services for VME Drivers on Origin 2000/Onyx2
    Kernel Services for VME
  mapping into user process
    VME Mapping Support
  master device
    Master and Slave Devices
    Master and Slave Devices
  overview
    Overview of the VME Bus
  PIO to
    address maps
      Creating and Using PIO Maps
      PIO Addressing in Challenge and Onyx Systems
      Mapping PIO Addresses
    addresses
      PIO Addressing and DMA Addressing
      PIO Addressing and DMA Addressing
    addressing in
      PIO Addressing and DMA Addressing
    addressing in Challenge
      PIO Addressing in Challenge and Onyx Systems
    bandwidth
      VME PIO Bandwidth
    fixed, unfixed maps
      Fixed PIO Maps
      Fixed PIO Maps
  slave device
    Master and Slave Devices
    Master and Slave Devices
  stray interrupt cause
    Vector Errors
    Vector Errors
  user-level DMA
    User-Level DMA From the VME Bus
    VME User-Level DMA
  user-level DMA bandwidth
    DMA Engine Bandwidth
  user-level PIO
    VME Programmed I/O
    VME PIO Operations

VME bus, configuration
  Configuring VME Devices

VME bus, hardware
  VME Device Attachment on Origin 2000/Onyx2

VME Cache Controller (VMECC)
  VMECC

VMEbus Channel Adapter Module (VCAM) board
  VME Hardware Architecture
  VMEbus Channel Adapter Module (VCAM) Board

volume header
  Placing symmon in the Volume Header

waiting
  Mutual Exclusion Compared to Waiting
  Waiting for Time to Pass
  for a general event
    Waiting for a General Event
  for an interrupt
    Waiting for Block I/O to Complete
  for memory
    Waiting for Memory to Become Available
  semaphore
    Using a Semaphore for Waiting
  synchronization variables
    Using Synchronization Variables
  time units
    Time Units
  timed events
    Time Units

Prev | Table of Contents |
Glossary |  |