[ новости /+++ | форум | теги | ]

NAME

bus_space

 
bus_space_barrier

 
bus_space_copy_region_1

 
bus_space_copy_region_2

 
bus_space_copy_region_4

 
bus_space_copy_region_8

 
bus_space_copy_region_stream_1

 
bus_space_copy_region_stream_2

 
bus_space_copy_region_stream_4

 
bus_space_copy_region_stream_8

 
bus_space_free

 
bus_space_map

 
bus_space_read_1

 
bus_space_read_2

 
bus_space_read_4

 
bus_space_read_8

 
bus_space_read_multi_1

 
bus_space_read_multi_2

 
bus_space_read_multi_4

 
bus_space_read_multi_8

 
bus_space_read_multi_stream_1

 
bus_space_read_multi_stream_2

 
bus_space_read_multi_stream_4

 
bus_space_read_multi_stream_8

 
bus_space_read_region_1

 
bus_space_read_region_2

 
bus_space_read_region_4

 
bus_space_read_region_8

 
bus_space_read_region_stream_1

 
bus_space_read_region_stream_2

 
bus_space_read_region_stream_4

 
bus_space_read_region_stream_8

 
bus_space_read_stream_1

 
bus_space_read_stream_2

 
bus_space_read_stream_4

 
bus_space_read_stream_8

 
bus_space_set_multi_1

 
bus_space_set_multi_2

 
bus_space_set_multi_4

 
bus_space_set_multi_8

 
bus_space_set_multi_stream_1

 
bus_space_set_multi_stream_2

 
bus_space_set_multi_stream_4

 
bus_space_set_multi_stream_8

 
bus_space_set_region_1

 
bus_space_set_region_2

 
bus_space_set_region_4

 
bus_space_set_region_8

 
bus_space_set_region_stream_1

 
bus_space_set_region_stream_2

 
bus_space_set_region_stream_4

 
bus_space_set_region_stream_8

 
bus_space_subregion

 
bus_space_unmap

 
bus_space_write_1

 
bus_space_write_2

 
bus_space_write_4

 
bus_space_write_8

 
bus_space_write_multi_1

 
bus_space_write_multi_2

 
bus_space_write_multi_4

 
bus_space_write_multi_8

 
bus_space_write_multi_stream_1

 
bus_space_write_multi_stream_2

 
bus_space_write_multi_stream_4

 
bus_space_write_multi_stream_8

 
bus_space_write_region_1

 
bus_space_write_region_2

 
bus_space_write_region_4

 
bus_space_write_region_8

 
bus_space_write_region_stream_1

 
bus_space_write_region_stream_2

 
bus_space_write_region_stream_4

 
bus_space_write_region_stream_8

 
bus_space_write_stream_1

 
bus_space_write_stream_2

 
bus_space_write_stream_4

 
bus_space_write_stream_8

 - bus space manipulation functions

 

SYNOPSIS

DESCRIPTION

Many common devices are used on multiple architectures, but are accessed differently on each because of architectural constraints. For instance, a device which is mapped in one system's I/O space may be mapped in memory space on a second system. On a third system, architectural limitations might change the way registers need to be accessed (e.g. creating a non-linear register space). In some cases, a single driver may need to access the same type of device in multiple ways in a single system or architecture. The goal of the functions is to allow a single driver source file to manipulate a set of devices on different system architectures, and to allow a single driver object file to manipulate a set of devices on multiple bus types on a single architecture.

Not all busses have to implement all functions described in this document, though that is encouraged if the operations are logically supported by the bus. Unimplemented functions should cause compile-time errors if possible.

All of the interface definitions described in this document are shown as function prototypes and discussed as if they were required to be functions. Implementations are encouraged to implement prototyped (type-checked) versions of these interfaces, but may implement them as macros if appropriate. Machine-dependent types, variables, and functions should be marked clearly in    #include <machine/bus.h>
to avoid confusion with the machine-independent types and functions, and, if possible, should be given names which make the machine-dependence clear.  

CONCEPTS AND GUIDELINES

A range in bus space is described by a bus address and a bus size. The bus address describes the start of the range in bus space. The bus size describes the size of the range in bytes. Busses which are not byte addressable may require use of bus space ranges with appropriately aligned addresses and properly rounded sizes.

Access to regions of bus space is facilitated by use of bus space handles, which are usually created by mapping a specific range of a bus space. Handles may also be created by allocating and mapping a range of bus space, the actual location of which is picked by the implementation within bounds specified by the caller of the allocation function.

All of the bus space access functions require one bus space tag argument, at least one handle argument, and at least one offset argument (a bus size). The bus space tag specifies the space, each handle specifies a region in the space, and each offset specifies the offset into the region of the actual location(s) to be accessed. Offsets are given in bytes, though busses may impose alignment constraints. The offset used to access data relative to a given handle must be such that all of the data being accessed is in the mapped region that the handle describes. Trying to access data outside that region is an error.

Because some architectures' memory systems use buffering to improve memory and device access performance, there is a mechanism which can be used to create ``barriers'' in the bus space read and write stream. There are three types of barriers: read, write, and read/write. All reads started to the region before a read barrier must complete before any reads after the read barrier are started. (The analogous requirement is true for write barriers.) Read/write barriers force all reads and writes started before the barrier to complete before any reads or writes after the barrier are started. Correctly-written drivers will include all appropriate barriers, and assume only the read/write ordering imposed by the barrier operations.

People trying to write portable drivers with the functions should try to make minimal assumptions about what the system allows. In particular, they should expect that the system requires bus space addresses being accessed to be naturally aligned (i.e., base address of handle added to offset is a multiple of the access size), and that the system does alignment checking on pointers (i.e., pointer to objects being read and written must point to properly-aligned data).

The descriptions of the functions given below all assume that they are called with proper arguments. If called with invalid arguments or arguments that are out of range (e.g. trying to access data outside of the region mapped when a given handle was created), undefined behaviour results. In that case, they may cause the system to halt, either intentionally (via panic) or unintentionally (by causing a fatal trap of by some other means) or may cause improper operation which is not immediately fatal. Functions which return void or which return data read from bus space (i.e., functions which do not obviously return an error code) do not fail. They could only fail if given invalid arguments, and in that case their behaviour is undefined.  

TYPES

Vt bus_addr_t

Vt bus_size_t

Vt bus_space_tag_t

Vt bus_space_handle_t

MAPPING AND UNMAPPING BUS SPACE

Bus space must be mapped before it can be used, and should be unmapped when it is no longer needed. The bus_space_map ();
and bus_space_unmap ();
functions provide these capabilities.

Some drivers need to be able to pass a subregion of already-mapped bus space to another driver or module within a driver. The bus_space_subregion ();
function allows such subregions to be created.  

Fn bus_space_map space address size flags handlep

The Fa flags argument controls how the space is to be mapped. Supported flags include:

BUS_SPACE_MAP_CACHEABLE

Try to map the space so that accesses can be cached and/or prefetched by the system. If this flag is not specified, the implementation should map the space so that it will not be cached or prefetched.

This flag must have a value of 1 on all implementations for backward compatibility.

BUS_SPACE_MAP_LINEAR

Try to map the space so that its contents can be accessed linearly via normal memory access methods (e.g. pointer dereferencing and structure accesses). This is useful when software wants to do direct access to a memory device, e.g. a frame buffer. If this flag is specified and linear mapping is not possible, the bus_space_map ();
call should fail. If this flag is not specified, the system may map the space in whatever way is most convenient.

Not all combinations of flags make sense or are supported with all spaces. For instance, BUS_SPACE_MAP_CACHEABLE may be meaningless when used on many systems' I/O port spaces, and on some systems BUS_SPACE_MAP_LINEAR without BUS_SPACE_MAP_CACHEABLE may never work. When the system hardware or firmware provides hints as to how spaces should be mapped (e.g. the PCI memory mapping registers' ``prefetchable'' bit), those hints should be followed for maximum compatibility. On some systems, requesting a mapping that cannot be satisfied (e.g. requesting a non-cacheable mapping when the system can only provide a cacheable one) will cause the request to fail.

Some implementations may keep track of use of bus space for some or all bus spaces and refuse to allow duplicate allocations. This is encouraged for bus spaces which have no notion of slot-specific space addressing, such as ISA and VME, and for spaces which coexist with those spaces (e.g. EISA and PCI memory and I/O spaces co-existing with ISA memory and I/O spaces).

Mapped regions may contain areas for which there is no device on the bus. If space in those areas is accessed, the results are bus-dependent.  

Fn bus_space_unmap space handle size

After bus_space_unmap ();
is called on a handle, that handle is no longer valid. (If copies were made of the handle they are no longer valid, either.)

This function will never fail. If it would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, bus_space_unmap ();
will never return.  

Fn bus_space_subregion space handle offset size nhandlep

If successful, bus_space_subregion ();
returns zero and fills in the bus space handle pointed to by Fa nhandlep . If unsuccessful, it returns non-zero and leaves the bus space handle pointed to by Fa nhandlep in an undefined state. In either case, the handle described by Fa handle remains valid and is unmodified.

When done with a handle created by bus_space_subregion (,);
the handle should be thrown away. Under no circumstances should bus_space_unmap ();
be used on the handle. Doing so may confuse any resource management being done on the space, and will result in undefined behaviour. When bus_space_unmap ();
or bus_space_free ();
is called on a handle, all subregions of that handle become invalid.  

ALLOCATING AND FREEING BUS SPACE

Some devices require or allow bus space to be allocated by the operating system for device use. When the devices no longer need the space, the operating system should free it for use by other devices. The bus_space_alloc ();
and bus_space_free ();
functions provide these capabilities.  

Fn bus_space_alloc space reg_start reg_end size alignment boundary

Constraints on the allocation are given by the Fa reg_start , reg_end , alignment , and Fa boundary parameters. The allocated region will start at or after Fa reg_start and end before or at Fa reg_end . The Fa alignment constraint must be a power of two, and the allocated region will start at an address that is an even multiple of that power of two. The Fa boundary constraint, if non-zero, ensures that the region is allocated so that Fa first address in region / Fa boundary has the same value as Fa last address in region / Fa boundary . If the constraints cannot be met, bus_space_alloc ();
will fail. It is an error to specify a set of constraints that can never be met (for example, Fa size greater than Fa boundary ) .

The Fa flags parameter is the same as the like-named parameter to bus_space_map (,);
the same flag values should be used, and they have the same meanings.

Handles created by bus_space_alloc ();
should only be freed with bus_space_free (.);
Trying to use bus_space_unmap ();
on them causes undefined behaviour. The bus_space_subregion ();
function can be used on handles created by bus_space_alloc (.);
 

Fn bus_space_free space handle size

After bus_space_free ();
is called on a handle, that handle is no longer valid. (If copies were made of the handle, they are no longer valid, either.)

This function will never fail. If it would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, bus_space_free ();
will never return.  

READING AND WRITING SINGLE DATA ITEMS

Fn bus_space_read_1 space handle offset

Fn bus_space_read_2 space handle offset

Fn bus_space_read_4 space handle offset

Fn bus_space_read_8 space handle offset

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data item being read. On some systems, not obeying this requirement may cause incorrect data to be read, on others it may cause a system crash.

Read operations done by the bus_space_read_N ();
functions may be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_write_1 space handle offset value

Fn bus_space_write_2 space handle offset value

Fn bus_space_write_4 space handle offset value

Fn bus_space_write_8 space handle offset value

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data item being written. On some systems, not obeying this requirement may cause incorrect data to be written, on others it may cause a system crash.

Write operations done by the bus_space_write_N ();
functions may be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

BARRIERS

Fn bus_space_barrier space handle offset length flags

The Fa flags argument controls what types of operations are to be ordered. Supported flags are:

BUS_SPACE_BARRIER_READ

Synchronize read operations.

BUS_SPACE_BARRIER_WRITE

Synchronize write operations.

Those flags can be combined (or-ed together) to enforce ordering on both read and write operations.

All of the specified type(s) of operation which are done to the region before the barrier operation are guaranteed to complete before any of the specified type(s) of operation done after the barrier.

Example: Consider a hypothetical device with two single-byte ports, one write-only input port (at offset 0) and a read-only output port (at offset 1). Operation of the device is as follows: data bytes are written to the input port, and are placed by the device on a stack, the top of which is read by reading from the output port. The sequence to correctly write two data bytes to the device then read those two data bytes back would be:

/*
 * t and h are the tag and handle for the mapped device's
 * space.
 */
bus_space_write_1(t, h, 0, data0);
bus_space_barrier(t, h, 0, 1, BUS_SPACE_BARRIER_WRITE);  /* 1 */
bus_space_write_1(t, h, 0, data1);
bus_space_barrier(t, h, 0, 2,
    BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE);     /* 2 */
ndata1 = bus_space_read_1(t, h, 1);
bus_space_barrier(t, h, 1, 1, BUS_SPACE_BARRIER_READ);   /* 3 */
ndata0 = bus_space_read_1(t, h, 1);
/* data0 == ndata0, data1 == ndata1 */

The first barrier makes sure that the first write finishes before the second write is issued, so that two writes to the input port are done in order and are not collapsed into a single write. This ensures that the data bytes are written to the device correctly and in order.

The second barrier makes sure that the writes to the output port finish before any of the reads to the input port are issued, thereby making sure that all of the writes are finished before data is read. This ensures that the first byte read from the device really is the last one that was written.

The third barrier makes sure that the first read finishes before the second read is issued, ensuring that data is read correctly and in order.

The barriers in the example above are specified to cover the absolute minimum number of bus space locations. It is correct (and often easier) to make barrier operations cover the device's whole range of bus space, that is, to specify an offset of zero and the size of the whole region.  

REGION OPERATIONS

Drivers occasionally need to copy one region of a bus space to another, or to set all locations in a region of bus space to contain a single value. The bus_space_copy_region_N ();
family of functions and the bus_space_set_region_N ();
family of functions allow drivers to perform these operations.  

Fn bus_space_read_region_1 space handle offset datap count

Fn bus_space_read_region_2 space handle offset datap count

Fn bus_space_read_region_4 space handle offset datap count

Fn bus_space_read_region_8 space handle offset datap count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being read and the data array pointer should be properly aligned. On some systems, not obeying these requirements may cause incorrect data to be read, on others it may cause a system crash.

Read operations done by the bus_space_read_region_N ();
functions may be executed in any order. They may also be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. There is no way to insert barriers between reads of individual bus space locations executed by the bus_space_read_region_N ();
functions.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_write_region_1 space handle offset datap count

Fn bus_space_write_region_2 space handle offset datap count

Fn bus_space_write_region_4 space handle offset datap count

Fn bus_space_write_region_8 space handle offset datap count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being written and the data array pointer should be properly aligned. On some systems, not obeying these requirements may cause incorrect data to be written, on others it may cause a system crash.

Write operations done by the bus_space_write_region_N ();
functions may be executed in any order. They may also be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. There is no way to insert barriers between writes of individual bus space locations executed by the bus_space_write_region_N ();
functions.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_copy_region_1 space srchandle srcoffset dsthandle

Fn bus_space_copy_region_2 space srchandle srcoffset dsthandle

Fn bus_space_copy_region_4 space srchandle srcoffset dsthandle

Fn bus_space_copy_region_8 space srchandle srcoffset dsthandle

For portability, the starting addresses of the regions specified by the each handle plus its respective offset should be a multiple of the size of data items being copied. On some systems, not obeying this requirement may cause incorrect data to be copied, on others it may cause a system crash.

Read and write operations done by the bus_space_copy_region_N ();
functions may be executed in any order. They may also be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier (function .);
There is no way to insert barriers between reads or writes of individual bus space locations executed by the bus_space_copy_region_N ();
functions.

Overlapping copies between different subregions of a single region of bus space are handled correctly by the bus_space_copy_region_N ();
functions.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_set_region_1 space handle offset value count

Fn bus_space_set_region_2 space handle offset value count

Fn bus_space_set_region_4 space handle offset value count

Fn bus_space_set_region_8 space handle offset value count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being written. On some systems, not obeying this requirement may cause incorrect data to be written, on others it may cause a system crash.

Write operations done by the bus_space_set_region_N ();
functions may be executed in any order. They may also be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. There is no way to insert barriers between writes of individual bus space locations executed by the bus_space_set_region_N ();
functions.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

READING AND WRITING A SINGLE LOCATION MULTIPLE TIMES

Fn bus_space_read_multi_1 space handle offset datap count

Fn bus_space_read_multi_2 space handle offset datap count

Fn bus_space_read_multi_4 space handle offset datap count

Fn bus_space_read_multi_8 space handle offset datap count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being read and the data array pointer should be properly aligned. On some systems, not obeying these requirements may cause incorrect data to be read, on others it may cause a system crash.

Read operations done by the bus_space_read_multi_N ();
functions may be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. Because the bus_space_read_multi_N ();
functions read the same bus space location multiple times, they place an implicit read barrier between each successive read of that bus space location.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_write_multi_1 space handle offset datap count

Fn bus_space_write_multi_2 space handle offset datap count

Fn bus_space_write_multi_4 space handle offset datap count

Fn bus_space_write_multi_8 space handle offset datap count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being written and the data array pointer should be properly aligned. On some systems, not obeying these requirements may cause incorrect data to be written, on others it may cause a system crash.

Write operations done by the bus_space_write_multi_N ();
functions may be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. Because the bus_space_write_multi_N ();
functions write the same bus space location multiple times, they place an implicit write barrier between each successive write of that bus space location.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

Fn bus_space_set_multi_1 space handle offset value count

Fn bus_space_set_multi_2 space handle offset value count

Fn bus_space_set_multi_4 space handle offset value count

Fn bus_space_set_multi_8 space handle offset value count

For portability, the starting address of the region specified by Fa handle plus the offset should be a multiple of the size of data items being written and the data array pointer should be properly aligned. On some systems, not obeying these requirements may cause incorrect data to be written, on others it may cause a system crash.

Write operations done by the bus_space_set_multi_N ();
functions may be executed out of order with respect to other pending read and write operations unless order is enforced by use of the bus_space_barrier ();
function. Because the bus_space_set_multi_N ();
functions write the same bus space location multiple times, they place an implicit write barrier between each successive write of that bus space location.

These functions will never fail. If they would fail (e.g. because of an argument error), that indicates a software bug which should cause a panic. In that case, they will never return.  

STREAM FUNCTIONS

Fn bus_space_read_stream_1

Fn bus_space_read_stream_2

Fn bus_space_read_stream_4

Fn bus_space_read_stream_8

Fn bus_space_read_multi_stream_1

Fn bus_space_read_multi_stream_2

Fn bus_space_read_multi_stream_4

Fn bus_space_read_multi_stream_8

Fn bus_space_read_region_stream_1

Fn bus_space_read_region_stream_2

Fn bus_space_read_region_stream_4

Fn bus_space_read_region_stream_8

Fn bus_space_write_stream_1

Fn bus_space_write_stream_2

Fn bus_space_write_stream_4

Fn bus_space_write_stream_8

Fn bus_space_write_multi_stream_1

Fn bus_space_write_multi_stream_2

Fn bus_space_write_multi_stream_4

Fn bus_space_write_multi_stream_8

Fn bus_space_write_region_stream_1

Fn bus_space_write_region_stream_2

Fn bus_space_write_region_stream_4

Fn bus_space_write_region_stream_8

Fn bus_space_copy_region_stream_1

Fn bus_space_copy_region_stream_2

Fn bus_space_copy_region_stream_4

Fn bus_space_copy_region_stream_8

Fn bus_space_set_multi_stream_1

Fn bus_space_set_multi_stream_2

Fn bus_space_set_multi_stream_4

Fn bus_space_set_multi_stream_8

Fn bus_space_set_region_stream_1

Fn bus_space_set_region_stream_2

Fn bus_space_set_region_stream_4

Fn bus_space_set_region_stream_8

These functions are defined just as their non-stream counterparts, except that they provide no byte-order translation.  

COMPATIBILITY

SEE ALSO

HISTORY

The manual page was then adapted to the version of the interface that Fx imported for the CAM SCSI drivers, plus subsequent evolution. The Fx version was imported in Fx 3.0 .  

AUTHORS

An Justin Gibbs ported these interfaces to Fx .

An Chris Demetriou wrote this manual page.

An Warner Losh modified it for the Fx implementation.  

BUGS

Index

NAME

SYNOPSIS

DESCRIPTION

CONCEPTS AND GUIDELINES

TYPES

Vt bus_addr_t

Vt bus_size_t

Vt bus_space_tag_t

Vt bus_space_handle_t

MAPPING AND UNMAPPING BUS SPACE

Fn bus_space_map space address size flags handlep

Fn bus_space_unmap space handle size

Fn bus_space_subregion space handle offset size nhandlep

ALLOCATING AND FREEING BUS SPACE

Fn bus_space_alloc space reg_start reg_end size alignment boundary flags addrp handlep

Fn bus_space_free space handle size

READING AND WRITING SINGLE DATA ITEMS

Fn bus_space_read_1 space handle offset

Fn bus_space_read_2 space handle offset

Fn bus_space_read_4 space handle offset

Fn bus_space_read_8 space handle offset

Fn bus_space_write_1 space handle offset value

Fn bus_space_write_2 space handle offset value

Fn bus_space_write_4 space handle offset value

Fn bus_space_write_8 space handle offset value

BARRIERS

Fn bus_space_barrier space handle offset length flags

REGION OPERATIONS

Fn bus_space_read_region_1 space handle offset datap count

Fn bus_space_read_region_2 space handle offset datap count

Fn bus_space_read_region_4 space handle offset datap count

Fn bus_space_read_region_8 space handle offset datap count

Fn bus_space_write_region_1 space handle offset datap count

Fn bus_space_write_region_2 space handle offset datap count

Fn bus_space_write_region_4 space handle offset datap count

Fn bus_space_write_region_8 space handle offset datap count

Fn bus_space_copy_region_1 space srchandle srcoffset dsthandle dstoffset count

Fn bus_space_copy_region_2 space srchandle srcoffset dsthandle dstoffset count

Fn bus_space_copy_region_4 space srchandle srcoffset dsthandle dstoffset count

Fn bus_space_copy_region_8 space srchandle srcoffset dsthandle dstoffset count

Fn bus_space_set_region_1 space handle offset value count

Fn bus_space_set_region_2 space handle offset value count

Fn bus_space_set_region_4 space handle offset value count

Fn bus_space_set_region_8 space handle offset value count

READING AND WRITING A SINGLE LOCATION MULTIPLE TIMES

Fn bus_space_read_multi_1 space handle offset datap count

Fn bus_space_read_multi_2 space handle offset datap count

Fn bus_space_read_multi_4 space handle offset datap count

Fn bus_space_read_multi_8 space handle offset datap count

Fn bus_space_write_multi_1 space handle offset datap count

Fn bus_space_write_multi_2 space handle offset datap count

Fn bus_space_write_multi_4 space handle offset datap count

Fn bus_space_write_multi_8 space handle offset datap count

Fn bus_space_set_multi_1 space handle offset value count

Fn bus_space_set_multi_2 space handle offset value count

Fn bus_space_set_multi_4 space handle offset value count

Fn bus_space_set_multi_8 space handle offset value count

STREAM FUNCTIONS

COMPATIBILITY

SEE ALSO

HISTORY

AUTHORS

BUGS

Партнёры:

Хостинг: