SEGMAP(9E) Driver Entry Points SEGMAP(9E)

NAME

segmap - map device memory into user space

SYNOPSIS

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/vm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>


int prefixsegmap(dev_t dev, off_t off, struct as *asp, caddr_t *addrp,
off_t len, unsigned int prot, unsigned int maxprot, unsigned int flags,
cred_t *cred_p);

INTERFACE LEVEL

Architecture independent level 2 (DKI only).

ARGUMENTS

dev
Device whose memory is to be mapped.


off
Offset within device memory at which mapping begins.


asp
Pointer to the address space into which the device memory
should be mapped.


addrp
Pointer to the address in the address space to which the
device memory should be mapped.


len
Length (in bytes) of the memory to be mapped.


prot
A bit field that specifies the protections. Possible
settings are:

PROT_READ
Read access is desired.


PROT_WRITE
Write access is desired.


PROT_EXEC
Execute access is desired.


PROT_USER
User-level access is desired (the mapping
is being done as a result of a mmap(2)
system call).


PROT_ALL
All access is desired.


maxprot
Maximum protection flag possible for attempted mapping;
the PROT_WRITE bit may be masked out if the user opened
the special file read-only.


flags
Flags indicating type of mapping. Possible values are
(other bits may be set):

MAP_SHARED
Changes should be shared.


MAP_PRIVATE
Changes are private.


cred_p
Pointer to the user credentials structure.

DESCRIPTION

The segmap() entry point is an optional routine for character
drivers that support memory mapping. The mmap(2) system call, when
applied to a character special file, allows device memory to be
mapped into user space for direct access by the user application.


Typically, a character driver that needs to support the mmap(2)
system call supplies either an devmap(9E) entry point, or both an
devmap(9E) and a segmap() entry point routine (see the devmap(9E)
reference page). If no segmap() entry point is provided for the
driver, devmap_setup(9F) is used as a default.


A driver for a memory-mapped device would provide a segmap() entry
point if it:

o needs to maintain a separate context for each user
mapping. See devmap_setup(9F) for details.

o needs to assign device access attributes to the user
mapping.


The responsibilities of a segmap() entry point are:

o Verify that the range, defined by offset and len, to be
mapped is valid for the device. Typically, this task is
performed by calling the devmap(9E) entry point. Note that
if you are using ddi_devmap_segmap(9F) or devmap_setup(9F)
to set up the mapping, it will call your devmap(9E) entry
point for you to validate the range to be mapped.

o Assign device access attributes to the mapping. See
ddi_devmap_segmap(9F), and ddi_device_acc_attr(9S) for
details.

o Set up device contexts for the user mapping if your device
requires context switching. See devmap_setup(9F) for
details.

o Perform the mapping with ddi_devmap_segmap(9F), or
devmap_setup(9F) and return the status if it fails.

RETURN VALUES

The segmap() routine should return 0 if the driver is successful in
performing the memory map of its device address space into the
specified address space.


The segmap() must return an error number on failure. For example,
valid error numbers would be ENXIO if the offset/length pair
specified exceeds the limits of the device memory, or EINVAL if the
driver detects an invalid type of mapping attempted.


If one of the mapping routines ddi_devmap_segmap() or
devmap_setup()fails, you must return the error number returned by the
respective routine.

SEE ALSO

mmap(2), devmap(9E), ddi_devmap_segmap(9F), devmap_setup(9F),
ddi_device_acc_attr(9S)


Writing Device Drivers

January 14, 1997 SEGMAP(9E)