prometheus

Index

BOOL Prm_AddIntServer(
         PCIBoard * board,
         struct Interrupt * interrupt );

APTR Prm_AllocDMABuffer(
         ULONG size );

Allocate memory region accessible by PCI DMA.

size - Size of the region to allocate. NULL is safe
       input, in this case the function fails.

A pointer to allocated region or NULL upon failure.
The region will always be LONG-aligned.

PCIBoard * Prm_FindBoardTagList(
         PCIBoard * previous,
         struct TagItem * tag_list );

PCIBoard * Prm_FindBoardTags(
         PCIBoard * previous,
         TAG tag, ... );

Find the board whose properties match the given set
of attributes.

previous - an opaque pointer to previously found board,
           or NULL to start the search from the beginning
tag_list - a pointer to a taglist specifying attributes to
           match against. If NULL, then all boards will be
           considered matching.

A pointer to next matching board object or NULL if the search
has ended and there is no more match.

You can search for boards with some specific owner using
PRM_BoardOwner tag. However note that in AROS prometheus.library
is a wrapper on top of native object-oriented framework. This
framework uses different concept of device ownership, and
prometheus.library cannot determine correct owner value for devices
locked using those APIs. Those devices are treated as having the
same owner named "AROS", however in reality their owners will be
different.

VOID Prm_FreeDMABuffer(
         APTR buffer,
         ULONG size );

Free memory buffer allocated by Prm_AllocDMABuffer().

buffer - a pointer to a buffer to free. NULL is a safe value,
         in this case the function does nothing.
size   - size of the buffer. Zero is a safe value, in this case
         the function does nothing.

None.

ULONG Prm_GetBoardAttrsTagList(
         PCIBoard * board,
         struct TagItem * tag_list );

ULONG Prm_GetBoardAttrsTags(
         PCIBoard * board,
         TAG tag, ... );

Returns information about the board according to the
specified taglist.

board    - an opaque pointer to board object to query
tag_list - a list of attributes to query. ti_Data for
           every tag should be a pointer to IPTR storage
           where the data will be written. For unrecognized
           tags a value of 0 will be returned. Tags with
           ti_Data set to NULL will be skipped.

Number of successfully processed tags.

AROS implementation of prometheus.library is a wrapper on top of
object-oriented driver stack. Software can use either
prometheus.library, or some other wrapper API (like openpci.library)
or HIDD object-oriented API directly. Concept of device ownership
is different across different APIs, so this method returns correct
device owner only if the device was locked using prometheus.library's
Prm_SetBoardAttrsTagList() function. If device's owner uses another
API, prometheus.library will specify "AROS" default name.

APTR Prm_GetPhysicalAddr(
         APTR address );

UBYTE Prm_ReadConfigByte(
         PCIBoard * board,
         UBYTE offset );

ULONG Prm_ReadConfigLong(
         PCIBoard * board,
         UBYTE offset );

UWORD Prm_ReadConfigWord(
         PCIBoard * board,
         UBYTE offset );

VOID Prm_RemIntServer(
         PCIBoard * board,
         struct Interrupt * interrupt );

ULONG Prm_SetBoardAttrsTagList(
         PCIBoard * board,
         struct TagItem * tag_list );

ULONG Prm_SetBoardAttrsTags(
         PCIBoard * board,
         TAG tag, ... );

VOID Prm_WriteConfigByte(
         PCIBoard * board,
         UBYTE data,
         UBYTE offset );

VOID Prm_WriteConfigLong(
         PCIBoard * board,
         ULONG data,
         UBYTE offset );

VOID Prm_WriteConfigWord(
         PCIBoard * board,
         UWORD data,
         UBYTE offset );