5584 lines
160 KiB
Plaintext
5584 lines
160 KiB
Plaintext
<!--
|
|
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook V3.1//EN">
|
|
-->
|
|
<book>
|
|
<bookinfo>
|
|
|
|
<title>libraw1394</title>
|
|
<subtitle>version 2.0.4</subtitle>
|
|
|
|
<copyright>
|
|
<year>2001-2009</year>
|
|
<holder>Andreas Bombe, Dan Maas, Manfred Weihs, and Christian Toegel</holder>
|
|
</copyright>
|
|
|
|
</bookinfo>
|
|
|
|
<toc></toc>
|
|
|
|
<chapter id="introduction">
|
|
<title>Introduction</title>
|
|
|
|
<para>
|
|
The Linux kernel's IEEE 1394 subsystem provides access to the raw 1394 bus
|
|
through the raw1394 module. This includes the standard 1394 transactions
|
|
(read, write, lock) on the active side, isochronous stream receiving and
|
|
sending and dumps of data written to the FCP_COMMAND and FCP_RESPONSE
|
|
registers. raw1394 uses a character device to communicate to user
|
|
programs using a special protocol.
|
|
</para>
|
|
|
|
<para>
|
|
libraw1394 was created with the intent to hide that protocol from
|
|
applications so that
|
|
<orderedlist numeration="arabic">
|
|
<listitem>
|
|
<para>
|
|
the protocol has to be implemented correctly only once.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
all work can be done using easy to understand functions instead of
|
|
handling a complicated command structure.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
only libraw1394 has to be changed when raw1394's interface changes.
|
|
</para>
|
|
</listitem>
|
|
</orderedlist>
|
|
</para>
|
|
|
|
<para>
|
|
To fully achieve the goals (especially 3) libraw1394 is distributed under
|
|
the LGPL (Lesser General Public License - see file COPYING.LIB for more
|
|
information.) to allow linking with any program, be it open source or
|
|
binary only. The requirements are that the libraw1394 part can be
|
|
replaced (relinked) with another version of the library and that changes
|
|
to libraw1394 itself fall under LGPL again. Refer to the LGPL text for
|
|
details.
|
|
</para>
|
|
</chapter>
|
|
|
|
<chapter id="intro1394">
|
|
<title>Short Introduction into IEEE 1394</title>
|
|
|
|
<para>
|
|
IEEE 1394 in fact defines two types of hardware implementations for this
|
|
bus system, cable and backplane. The only one described here and
|
|
supported by the Linux subsystem is the cable implementation. Most people
|
|
not familiar with the standard probably don't even know that there is
|
|
something else than the 1394 cable specification.
|
|
</para>
|
|
|
|
<para>
|
|
If you are familiar with CSR architectures (as defined in ISO/IEC 13213
|
|
(ANSI/IEEE 1212)), then you already know quite a bit of 1394, which is a
|
|
CSR implementation.
|
|
</para>
|
|
|
|
<sect1>
|
|
<title>Bus Structure</title>
|
|
|
|
<para>
|
|
The basic data structures defined in the standard and used in this
|
|
document are the quadlet (32 bit quantity) and the octlet (64 bit
|
|
quantity) and blocks (any quantity of bytes). The bus byte ordering is
|
|
big endian. A transmission can be sent at one of multiple possible
|
|
speeds, which are 100, 200 and 400 Mbit/s for the currently mostly used
|
|
IEEE 1394a spec and up to 3.2 Gbit/s in the recently finalized 1394.b
|
|
standard (these speeds are also referred to as S100, S200, ...).
|
|
</para>
|
|
|
|
<para>
|
|
A 1394 bus consists of up to 64 nodes (with multiple buses possibly
|
|
being connected, but that is outside of the scope of this document and
|
|
not completely standardized yet). Each node is addressed with a 16 bit
|
|
address, which is further divided into a 10 bit bus ID and a 6 bit local
|
|
node number, the so-called physical ID. The physical IDs are completely
|
|
dynamic and determined during the bus reset. The highest values for
|
|
both are special values. Bus ID equal to 1023 means "local bus" (the
|
|
bus the node is connected to), physical ID equal to 63 means "all nodes"
|
|
(broadcast).
|
|
</para>
|
|
|
|
<para>
|
|
The local bus ID 1023 is the only one that can be used unless IEEE
|
|
1394.1 bridge portals to more buses were available. Therefore the node
|
|
IDs have to be given as (1023<<6) | phy_ID. (This is also true
|
|
if libraw1394 runs at a host which contains multiple 1394 bus adapters.
|
|
The local ID 1023 is valid on each of these buses. The Linux host
|
|
itself is no IEEE 1394.1 bridge.)
|
|
</para>
|
|
|
|
<para>
|
|
Each node has a local address space with 48 bit wide addressing.
|
|
The whole bus can thus be seen as a linear 64 bit address space by
|
|
concatenating the node ID (most significant bits) and local
|
|
address (least significant bits). libraw1394 treats them separately in
|
|
function arguments to save the application some fiddling with the bits.
|
|
</para>
|
|
|
|
<para>
|
|
Unlike other buses there aren't many transactions or commands defined,
|
|
higher level commands are defined in terms of addresses accessed instead
|
|
of separate transaction types (comparable to memory mapped registers in
|
|
hardware). The 1394 transactions are:
|
|
|
|
<itemizedlist>
|
|
<listitem>
|
|
<para>read (quadlets and blocks)</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>write (quadlets and blocks)</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>lock (some atomic modifications)</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
|
|
There is also the isochronous transaction (the above three are called
|
|
asynchronous transactions), which is a broadcast stream with guaranteed
|
|
bandwidth. It doesn't contain any address but is distinguished by a 6
|
|
bit channel number.
|
|
</para>
|
|
|
|
<para>
|
|
The bus view is only logical, physically it consists of many
|
|
point-to-point connections between nodes with every node forwarding data
|
|
it receives to every other port which is capable of the speed the
|
|
transaction is sent at (thus a S200 node in the path between two S400
|
|
nodes would limit their communication speed to S200). It forms a tree
|
|
structure with all but one node having a parent and a number of
|
|
children. One node is the root node and has no parents.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Bus Reset</title>
|
|
|
|
<para>
|
|
A bus reset occurs whenever the state of any node changes (including
|
|
addition and removal of nodes). At the beginning a root node is chosen,
|
|
then the tree identification determines for every node which port is
|
|
connected to a parent, child or nothing. Then the SelfID phase begins.
|
|
The root node sends a SelfID grant on its first port connected to a
|
|
child. If that is not a leaf node, it will itself forward the grant to
|
|
its first child. When a leaf node gets a grant, it will pick the lowest
|
|
physical ID not yet in use (starting with 0) and send out a SelfID packet
|
|
with its physical ID and more information, then acknowledge the SelfID
|
|
grant to its parent, which will send a grant to its next child until it
|
|
configured all its children, then pick a physical ID itself, send SelfID
|
|
packet and ack to parent.
|
|
</para>
|
|
|
|
<para>
|
|
After bus reset the used physical IDs are in a sequential range with no
|
|
holes starting from 0 up to the root node having the highest ID. This
|
|
also means that physical IDs can change for many or all nodes with the
|
|
insertion of a new node or moving the role of root to another node. In
|
|
libraw1394 all transactions are tagged automatically with a generation
|
|
number which is increased in every bus reset and transactions with an
|
|
obsolete generation will fail in order to avoid targetting the wrong
|
|
node. Nodes have to be identified in a different way than their
|
|
volatile physical IDs, namely by reading their globally unique ID (GUID)
|
|
contained in the configuration ROM.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Transactions</title>
|
|
|
|
<para>
|
|
The packets transmitted on the bus are acknowledged by the receiving end
|
|
unless they are broadcast packets (broadcast writes and isochronous
|
|
packets). The acknowledge code contains an error code, which either
|
|
signifies error, success or packet pending. In the first two cases the
|
|
transaction completes, in the last a response packet will follow at a
|
|
later time from the targetted node to the source node (this is called a
|
|
split transaction). Only writes can succeed and complete in the ack
|
|
code, reads and locks require a response. Error and packet pending can
|
|
happen for every transaction. The response packets contain a response
|
|
code (rcode) which signifies success or type of error.
|
|
</para>
|
|
|
|
<para>
|
|
For read and write there are two different types, quadlet and block.
|
|
The quadlet types have all their payload (exactly one quadlet) in the
|
|
packet header, the block types have a variable length data block
|
|
appended to the header. Programs using libraw1394 don't have to care
|
|
about that, quadlet transactions are automatically used when the data
|
|
length is 4 bytes and block transactions otherwise.
|
|
</para>
|
|
|
|
<para>
|
|
The lock transaction has several extended transaction codes defined
|
|
which choose the atomic operation to perform, the most used being the
|
|
compare-and-swap (code 0x2). The transaction passes the data value and
|
|
(depending on the operation) the arg value to the target node and
|
|
returns the old value at the target address, but only when the
|
|
transaction does not have an error. All three values are of the same
|
|
size, either one quadlet or one octlet.
|
|
</para>
|
|
|
|
<para>
|
|
In the compare-and-swap case, the data value is written to the target
|
|
address if the old value is identical to the arg value. The old value
|
|
is returned in any case and can be used to find out whether the swap
|
|
succeeded by repeating the compare locally. Compare-and-swap
|
|
is useful for avoiding race conditions when accessing the same
|
|
address from multiple nodes. For example, isochronous resource
|
|
allocation is done using compare-and-swap, as described below. Since
|
|
the old value is always returned, it more efficient to do the first
|
|
attempt with the reset value of the target register as arg instead of
|
|
reading it first. Repeat with the returned old value as new arg value
|
|
if it didn't succeed.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Bus Management</title>
|
|
|
|
<para>
|
|
There are three basic bus service nodes defined in IEEE 1394 (higher
|
|
level protocols may define more): cycle master, isochronous resource
|
|
manager and bus manager. These positions are contended for in and
|
|
shortly after the bus reset and may all be taken by a single node. A
|
|
node does not have to support being any of those but if it is bus
|
|
manager capable it also has to be iso manager capable, if it is iso
|
|
manager capable it also has to be cycle master capable.
|
|
</para>
|
|
|
|
<para>
|
|
The cycle master sends 8000 cycle start packets per second, which
|
|
initiate an iso cycle. Without that, no isochronous transmission is
|
|
possible. Only the root node is allowed to be cycle master, if it is
|
|
not capable then no iso transmissions can occur (and the iso or bus
|
|
manager have to select another node to become root and initiate a bus
|
|
reset).
|
|
</para>
|
|
|
|
<para>
|
|
The isochronous resource manager is the central point where channel and
|
|
bandwidth allocations are stored. A bit in the SelfID shows whether a
|
|
node is iso manager capable or not, the iso manager capable node with
|
|
the highest ID wins the position after a bus reset. Apart from
|
|
containing allocation registers, this one doesn't do much. Only if
|
|
there is no bus manager, it may determine a cycle master capable node to
|
|
become root and initiate a bus reset.
|
|
</para>
|
|
|
|
<para>
|
|
The bus manager has more responsibilities: power management (calculate
|
|
power provision and consumption on the bus and turn on disabled nodes if
|
|
enough power is available), bus optimization (calculate an effective gap
|
|
count, optimize the topology by selecting a better positioned node for
|
|
root) and some registers relevant to topology (topology map containing
|
|
the SelfIDs of the last reset and a speed map, which is obsoleted in
|
|
IEEE 1394a). The bus manager capable nodes contend for the role by
|
|
doing a lock transaction on the bus manager ID register in the iso
|
|
manager, the first to successfully complete the transaction wins the
|
|
role.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Isochronous Transmissions</title>
|
|
|
|
<para>
|
|
Nodes can allocate a channel and bandwidth for isochronous transmissions
|
|
at the iso manager to broadcast timing critical data (e.g. multimedia
|
|
streams) on the bus. However these transmissions are unreliable, there
|
|
is no guarantee that every packet reaches the intended recipients (the
|
|
software and hardware involved also take iso packets a bit more
|
|
lightly). After a cycle start packet, the isochronous cycle begins and
|
|
every node can transmit iso packets, however only one packet per channel
|
|
is allowed. As soon as a gap of a certain length appears (i.e. no node
|
|
sends anymore), the iso cycle ends and the rest of the time until the
|
|
next cycle start is reserved for asynchronous packets.
|
|
</para>
|
|
|
|
<para>
|
|
The channel register on the iso manager consists of 64 bits, each of
|
|
which signifies one channel. A channel can be allocated by any node by
|
|
doing a compare-swap lock request with the new bitmask. Likewise the
|
|
bandwidth can be allocated by doing a lock request with the new value.
|
|
The bandwidth register contains the remaining time available for every
|
|
iso cycle. Since you allocate time, the maximum data you are allowed to
|
|
put into an iso packet depends on the speed you will send at.
|
|
</para>
|
|
|
|
<para>
|
|
On every bus reset, the resource registers are resetted to their initial
|
|
values (all channels free, all bandwidth minus some amount set aside for
|
|
asynchronous communication available), this has to happen since the
|
|
isochronous manager may have moved to another node. Isochronous
|
|
transmissions may continue with the old allocations for 1000ms. During
|
|
that time, the nodes have to reallocate their resources and no new
|
|
allocations are allowed to occur. Only after this period new
|
|
allocations may be done, this avoids nodes losing their allocations over
|
|
a bus reset.
|
|
</para>
|
|
|
|
<para>
|
|
libraw1394 does not provide special functions for allocating iso
|
|
resources nor does it clean up after programs when they exit. Protocols
|
|
exist that require the first node to use some resources to allocate it
|
|
and then leave it for the last node using it to deallocate it. This may
|
|
be different nodes, so automatic behaviour would be very undesirable in
|
|
these cases.
|
|
</para>
|
|
</sect1>
|
|
|
|
</chapter>
|
|
|
|
<chapter id="general">
|
|
<title>Data Structures and Program Flow</title>
|
|
|
|
<sect1>
|
|
<title>Overview</title>
|
|
|
|
<para>
|
|
The 1394 subsystem in Linux is divided into the classical
|
|
three layers, like most other interface subsystems in Linux.
|
|
The in-kernel subsystem consists of the ieee1394 core, which
|
|
provides basic services like handling of the 1394 protocol
|
|
(converting the abstract transactions into packets and back),
|
|
collecting information about bus and nodes and providing some
|
|
services to the bus that are required to be available for
|
|
standards conformant nodes (e.g. CSR registers). Below that
|
|
are the hardware drivers, which handle converting packets and
|
|
bus events to and from hardware accesses on specific 1394
|
|
chipsets.
|
|
</para>
|
|
|
|
<para>
|
|
Above the core are the highlevel drivers, which use the services
|
|
provided by the core to implement protocols for certain devices and act
|
|
as drivers to these. raw1394 is one such driver, however it is not
|
|
specialized to handle one kind of device but is designed to accept
|
|
commands from user space to do any transaction wanted (as far as
|
|
possible from current core design). Using raw1394, normal applications
|
|
can access 1394 nodes on the bus and it is not neccessary to write
|
|
kernel code just for that.
|
|
</para>
|
|
|
|
<para>
|
|
raw1394 communicates to user space like most device drivers do, through
|
|
device files in /dev. It uses a defined protocol on that device, but
|
|
applications don't have to and should not care about that. All of this
|
|
is taken care of by libraw1394, which provides a set of functions that
|
|
convert to and from raw1394 protocol packets and are a lot easier to
|
|
handle than that underlying protocol.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Handles</title>
|
|
|
|
<para>
|
|
The handle presented to the application for using libraw1394 is the
|
|
raw1394handle_t, an opaque data structure (which means you don't need to
|
|
know its internals). The handle (and with it a connection to the kernel
|
|
side of raw1394) is obtained using
|
|
<function>raw1394_new_handle()</function>. Insufficient permissions to
|
|
access the kernel driver will result in failure of this function, among
|
|
other possibilities of failure.
|
|
</para>
|
|
|
|
<para>
|
|
While initializing the handle, a certain order of function calls have to
|
|
be obeyed or undefined results will occur. This order reflects the
|
|
various states of initialization to be done:
|
|
</para>
|
|
|
|
<para>
|
|
<orderedlist>
|
|
<listitem>
|
|
<para><function>raw1394_new_handle()</function></para>
|
|
</listitem>
|
|
<listitem>
|
|
<para><function>raw1394_get_port_info()</function></para>
|
|
</listitem>
|
|
<listitem>
|
|
<para><function>raw1394_set_port()</function></para>
|
|
</listitem>
|
|
</orderedlist>
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Ports</title>
|
|
|
|
<para>
|
|
A computer may have multiple 1394 buses connected by having multiple
|
|
1394 chips. Each of these is called a port, and the handle has to be
|
|
connected to one port before it can be used for anything. Even if no
|
|
nodes are connected to the chip in question, it forms a complete bus
|
|
(with just one node, itself).
|
|
</para>
|
|
|
|
<para>
|
|
A list of available ports together with some information about it (name
|
|
of the hardware, number of connected nodes) is available via
|
|
<function>raw1394_get_port_info()</function>, which is to be called
|
|
right after getting a fresh handle. The user should be presented with a
|
|
choice of available ports if there is more than one. It may be good
|
|
practice to do that even if there is only one port, since that may
|
|
result from a normally configured port just not being available, making
|
|
it confusing to be dropped right into the application attached to a port
|
|
without a choice and notion of anything going wrong.
|
|
</para>
|
|
|
|
<para>
|
|
The choice of port is then reported using
|
|
<function>raw1394_set_port()</function>. If this function fails and
|
|
<symbol>errno</symbol> is set to <symbol>ESTALE</symbol>, then
|
|
something has changed about the ports (port was added or removed)
|
|
between getting the port info and trying to set a port. It is
|
|
required that the current port list is fetched (presenting the user
|
|
with the choice again) and setting the port is retried with the new
|
|
data.
|
|
</para>
|
|
|
|
<para>
|
|
After a successful <function>raw1394_set_port()</function>, the get and
|
|
set port functions must not be used anymore on this handle. Undefined
|
|
results occur if you do so. To make up for this, all the other
|
|
functions are allowed now.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>The Event Loop</title>
|
|
|
|
<para>
|
|
All commands in libraw1394 are asynchronous, with some
|
|
synchronous wrapper functions for some types of transactions.
|
|
This means that there are two streams of data, one going into
|
|
raw1394 and one coming out. With this design you can send out
|
|
multiple transactions without having to wait for the response
|
|
before you can continue (sending out other transactions, for
|
|
example). The responses and other events (like bus resets and
|
|
received isochronous packets) are queued, and you can get them
|
|
with <function>raw1394_loop_iterate()</function> or
|
|
<function>raw1394_loop_iterate_timeout()</function> (which
|
|
always returns after a user-specified timeout if no
|
|
raw1394 event has occurred).
|
|
</para>
|
|
|
|
<para>
|
|
This forms an event loop you may already know from similar systems like
|
|
GUI toolkits. <function>raw1394_loop_iterate()</function> gets one
|
|
message from the event queue in raw1394, processes it with the
|
|
configured callback functions and returns the value returned by the
|
|
callback (so you can signal to the main loop from your callback; the
|
|
standard callbacks all return 0). It normally blocks when there are no
|
|
events and always processes only one event. If you are only receiving
|
|
broadcast events like isochronous packets you thus have to set up a loop
|
|
continuously calling the iterate function to get your callbacks called.
|
|
</para>
|
|
|
|
<para>
|
|
Often it is necessary to have multiple event loops and combine
|
|
them, e.g. if your application uses a GUI toolkit which also
|
|
has its own event loop. In that case you can use
|
|
<function>raw1394_get_fd()</function> to get the file
|
|
descriptor used for this handle by libraw1394. The fd can be
|
|
used to for <function>select()</function> or
|
|
<function>poll()</function> calls together with the other
|
|
loop's fd. (Most toolkits, like GTK and Qt, have special APIs
|
|
for integrating file descriptors into their own event loops).
|
|
</para>
|
|
|
|
<para>
|
|
If using <function>poll()</function>, you must test for
|
|
<symbol>POLLIN</symbol> and <symbol>POLLPRI</symbol>
|
|
events. If using <function>select()</function>, you must test
|
|
for both read and exception activity.
|
|
</para>
|
|
|
|
<para> If any of these conditions trigger, you should then call
|
|
<function>raw1394_loop_iterate()</function> to pick up the
|
|
event. <function>raw1394_loop_iterate()</function> is
|
|
guaranteed not to block when called immediately after select()
|
|
or poll() indicates activity. After the first call you
|
|
continue the main event loop. If more events wait, the
|
|
<function>select()</function>/<function>poll()</function> will
|
|
immediately return again.
|
|
</para>
|
|
|
|
<para>
|
|
You can also use the fd to set the <symbol>O_NONBLOCK</symbol> flag with
|
|
<function>fcntl()</function>. After that, the iterate function will not
|
|
block anymore but fail with <symbol>errno</symbol> set to
|
|
<symbol>EAGAIN</symbol> if no events wait. These are the only legal
|
|
uses for the fd returned by <function>raw1394_get_fd()</function>.
|
|
</para>
|
|
|
|
<para>
|
|
There are some functions which provide a synchronous wrapper for
|
|
transactions, note that these will call
|
|
<function>raw1394_loop_iterate()</function> continuously until their
|
|
transaction is completed, thus having implicit callback invocations
|
|
during their execution. The standard transaction functions have names
|
|
of the form <function>raw1394_start_xxx</function>, the synchronous
|
|
wrappers are called <function>raw1394_xxx</function>.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Handlers</title>
|
|
|
|
<para>
|
|
There are a number of handlers which can be set using the appropriate
|
|
function as described in the function reference and which libraw1394
|
|
will call during a <function>raw1394_loop_iterate()</function>. These
|
|
are:
|
|
|
|
<itemizedlist>
|
|
<listitem>
|
|
<para>tag handler (called for completed commands)</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>bus reset handler (called when a bus reset happens)</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>iso handler (called when an iso packet is received)
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>fcp handler (called when a FCP command or response is
|
|
received)</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
|
|
The bus reset handler is always called, the tag handler for every
|
|
command that completes, the iso handler and fcp handler are only called
|
|
when the application chooses to receive these packets. Handlers return
|
|
an integer value which is passed on by
|
|
<function>raw1394_loop_iterate()</function> (only one handler is called
|
|
per invocation), <constant>0</constant> is returned without a handler in
|
|
place.
|
|
</para>
|
|
|
|
<para>
|
|
The tag handler case is a bit special since the default handler is
|
|
actually doing something. Every command that you start can be given an
|
|
unsigned long tag which is passed untouched to the tag handler when the
|
|
event loop sees a completed command. The default handler expects this
|
|
value to be a pointer to a <structname>raw1394_reqhandle</structname>
|
|
structure, which contains a data pointer and its own callback function
|
|
pointer. The callback gets the untouched data pointer and error code as
|
|
arguments. If you want to use tags that are not
|
|
<structname>raw1394_reqhandle</structname> pointers you have to set up
|
|
your own tag handler.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Generation Numbers</title>
|
|
|
|
<para>
|
|
libraw1394 and the kernel code use generation numbers to identify the
|
|
current bus configuration and increment those on every configuration
|
|
change. The most important generation number is stored per connected
|
|
1394 bus and incremented on every bus reset. There is another number
|
|
managed by raw1394 which identifies global changes (like a complete port
|
|
being added or removed), which is used for the
|
|
<function>raw1394_set_port()</function> function to make sure you don't
|
|
use stale port numbers. This is done transparently to you.
|
|
</para>
|
|
|
|
<para>
|
|
The bus generation number is more relevant for your work. Since nodes
|
|
can change IDs with every bus reset, it is very likely that you don't
|
|
want to send a packet you constructed with the old ID before you noticed
|
|
the bus reset. This does not apply to isochronous transmissions, since
|
|
they are broadcast and do not depend on bus configuration. Therefore
|
|
every packet is automatically tagged with the expected generation
|
|
number, and it will fail to send if that does not match the number
|
|
managed in the kernel for the port in question.
|
|
</para>
|
|
|
|
<para>
|
|
You get the current generation number through the bus reset handler. If
|
|
you don't set a custom bus reset handler, the default handler will
|
|
update the generation number automatically. If you set your own
|
|
handler, you can update the generation number to be used through
|
|
<function>raw1394_update_generation()</function> directly in the handler
|
|
or later.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
<title>Error and Success Codes</title>
|
|
|
|
<para>
|
|
libraw1394 returns the ack/rcode pair in most transaction cases. The
|
|
rcode is undefined in cases where the ack code is not equal to
|
|
<symbol>ack_pending</symbol>. This is stored in a type
|
|
<type>raw1394_errcode_t</type>, from which the ack and rcode parts can
|
|
be extracted using two macros.
|
|
</para>
|
|
|
|
<para>
|
|
With the function <function>raw1394_errcode_to_errno()</function> it is
|
|
possible to convert this to an errno number that conveys roughly the
|
|
same meaning. Many developers will find that easier to handle. This is
|
|
done automatically for the synchronous read/write/lock wrapper
|
|
functions, i.e. they return 0 for success and a negative value for
|
|
failure, in which case they also set the <symbol>errno</symbol> variable
|
|
to the appropriate code. The raw ack/rcode pair can then still be
|
|
retrieved using <function>raw1394_get_errcode()</function>.
|
|
</para>
|
|
</sect1>
|
|
|
|
</chapter>
|
|
|
|
<chapter id="isochronous">
|
|
<title>Isochronous Transmission and Reception</title>
|
|
|
|
<sect1>
|
|
<title>Overview</title>
|
|
<para>
|
|
Isochronous operations involve sending or receiving a constant
|
|
stream of packets at a fixed rate of 8KHz. Unlike raw1394's
|
|
asynchronous API, where you "push" packets to raw1394
|
|
functions at your leisure, the isochronous API is based around
|
|
a "pull" model. During isochronous transmission or reception,
|
|
raw1394 informs your application when a packet must be sent or
|
|
received. You must fulfill these requests in a timely manner
|
|
to avoid breaking the constant stream of isochronous packets.
|
|
</para>
|
|
<para>
|
|
A raw1394 handle may be associated with one isochronous
|
|
stream, either transmitting or receiving (but not both at the
|
|
same time). To transmit or receive more than one stream
|
|
simultaneously, you must create more than one raw1394 handle.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1>
|
|
|
|
<title>Initialization</title>
|
|
|
|
<para>
|
|
When a raw1394 handle is first created, no isochronous
|
|
stream is assocated with it. To begin isochronous
|
|
operations, call either
|
|
<function>raw1394_iso_xmit_init()</function> (transmission) or
|
|
<function>raw1394_iso_recv_init()</function>
|
|
(reception). The parameters to these functions are as follows:
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>handler</symbol> is your function for queueing
|
|
packets to be sent (transmission) or processing received
|
|
packets (reception).
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>buf_packets</symbol> is the number of packets that
|
|
will be buffered at the kernel level. A larger packet buffer
|
|
will be more forgiving of IRQ and application latency,
|
|
however it will consume more kernel memory. For most
|
|
applications, it is sufficient to buffer 2000-16000 packets
|
|
(0.25 seconds to 2.0 seconds maximum latency).
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>max_packet_size</symbol> is the size, in bytes, of
|
|
the largest isochronous packet you intend to handle. This
|
|
size does not include the isochronous header but it does
|
|
include the CIP header specified by many isochronous
|
|
protocols.
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>channel</symbol> is the isochronous channel on which
|
|
you wish to receive or transmit. (currently there is no
|
|
facility for multi-channel transmission or reception).
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>speed</symbol> is the isochronous speed at which you
|
|
wish to operate. Possible values are
|
|
<symbol>RAW1394_ISO_SPEED_100</symbol>,
|
|
<symbol>RAW1394_ISO_SPEED_200</symbol>, and
|
|
<symbol>RAW1394_ISO_SPEED_400</symbol>.
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>irq_interval</symbol> is the maximum latency of the
|
|
kernel buffer, in packets. (To avoid excessive IRQ rates, the
|
|
low-level drivers only trigger an interrupt every
|
|
irq_interval packets). Pass -1 to receive a default value
|
|
that should be suitable for most applications.
|
|
</para>
|
|
|
|
<para>
|
|
<symbol>mode</symbol> for <function>raw1394_iso_recv_init()</function>
|
|
sets whether to use packet-per-buffer or buffer-fill receive mode.
|
|
Possible values are <symbol>RAW1394_DMA_DEFAULT</symbol> (bufferfill
|
|
on ohci1394), <symbol>RAW1394_DMA_BUFFERFILL</symbol>, and
|
|
<symbol>RAW1394_DMA_PACKET_PER_BUFFER</symbol>.
|
|
</para>
|
|
|
|
<para>
|
|
If <function>raw1394_iso_xmit/recv_init()</function> retuns
|
|
successfully, then you may start isochronous operations. You
|
|
may not call
|
|
<function>raw1394_iso_xmit/recv_init()</function> again on
|
|
the same handle without first shutting down the isochronous
|
|
operation with <function>raw1394_iso_shutdown()</function>.
|
|
</para>
|
|
|
|
<para>
|
|
Note that <function>raw1394_iso_xmit_init()</function> and
|
|
<function>raw1394_iso_recv_init()</function> involve
|
|
potentially time-consuming operations like allocating kernel
|
|
and device resources. If you intend to transmit or receive
|
|
several isochronous streams simultaneously, it is advisable
|
|
to initialize all streams before starting any packet
|
|
transmission or reception.
|
|
</para>
|
|
|
|
</sect1>
|
|
|
|
<sect1>
|
|
|
|
<title>Stopping and Starting</title>
|
|
|
|
<para>
|
|
Once the isochronous operation has been initialized, you may
|
|
start and stop packet transmission with
|
|
<function>raw1394_iso_xmit/recv_start()</function> and
|
|
<function>raw1394_iso_stop()</function>. It is legal to call
|
|
these as many times as you want, and it is permissible to
|
|
start an already-started stream or stop an already-stopped
|
|
stream. Packets that have been queued for transmission or
|
|
reception will remain queued when the operation is stopped.
|
|
</para>
|
|
|
|
<para>
|
|
<function>raw1394_iso_xmit/recv_start()</function> allow you
|
|
to specify on which isochronous cycle number to start
|
|
transmitting or receiving packets. Pass -1 to start
|
|
immediately. This parameter is ignored if isochronous
|
|
transmission or reception is already in progress.
|
|
</para>
|
|
|
|
<para>
|
|
<function>raw1394_iso_xmit_start()</function> has an
|
|
additional parameter, <symbol>prebuffer_packets</symbol>,
|
|
which specifies how many packets to queue up before starting
|
|
transmission. Possible values range from zero (start
|
|
transmission immediately after the first packet is queued)
|
|
up to the total number of packets in the buffer.
|
|
</para>
|
|
|
|
<para>
|
|
Once the isochronous operation has started, you must
|
|
repeatedly call <function>raw1394_loop_iterate()</function>
|
|
as usual to drive packet processing.
|
|
</para>
|
|
|
|
</sect1>
|
|
|
|
<sect1>
|
|
|
|
<title>Receiving Packets</title>
|
|
|
|
<para>
|
|
Raw1394 maintains a fixed-size ringbuffer of packets in
|
|
kernel memory. The buffer is filled by the low-level driver
|
|
as it receives packets from the bus. It is your
|
|
application's job to process each packet, after which the
|
|
buffer space it occupied can be re-used for future packets.
|
|
</para>
|
|
|
|
<para>
|
|
The isochronous receive handler you provided will be called
|
|
from <function>raw1394_loop_iterate()</function> after each
|
|
packet is received. Your handler is passed a pointer to the
|
|
first byte of the packet's data payload, plus the packet's
|
|
length in bytes (not counting the isochronous header), the
|
|
cycle number at which it was received, the channel on which
|
|
it was received, and the "tag" and "sy" fields from the
|
|
isochronous header. Note that the packet is at this point
|
|
still in the kernel's receive buffer, so the data pointer is
|
|
only valid until the receive handler returns. You must make
|
|
a copy of the packet's data if you want to keep it.
|
|
</para>
|
|
|
|
<para>
|
|
The receive handler is also passed a "packet(s) dropped"
|
|
flag. If this flag is nonzero, it means that one or more
|
|
incoming packets have been dropped since the last call to
|
|
your handler (usually this is because the kernel buffer has
|
|
completely filled up with packets or a bus reset has
|
|
occurred).
|
|
</para>
|
|
|
|
</sect1>
|
|
|
|
<sect1>
|
|
|
|
<title>Transmitting Packets</title>
|
|
|
|
<para>
|
|
Similar to reception, raw1394 maintains a fixed-size
|
|
ringbuffer of packets in kernel memory. The buffer is filled
|
|
by your application as it queues packets to be sent. The
|
|
buffer is drained by the hardware driver as it transmits
|
|
packets on the 1394 bus.
|
|
</para>
|
|
|
|
<para>
|
|
The isochronous transmit handler you provided will be called
|
|
from <function>raw1394_loop_iterate()</function> whenever
|
|
there is space in the buffer to queue another packet. The
|
|
handler is passed a pointer to the first byte of the buffer
|
|
space for the packet's data payload, pointers to words
|
|
containing the data length in bytes (not counting the
|
|
isochronous header), "tag" and "sy" fields, and the
|
|
isochronous cycle number at which this packet will be
|
|
transmitted. The handler must write the packet's data
|
|
payload into the supplied buffer space, and set the values
|
|
pointed to by "len", "tag", and "sy" to the appropriate
|
|
values. The handler is permitted to write any number of data
|
|
bytes, up and including to the value of
|
|
<symbol>max_packet_size</symbol> passed to
|
|
<function>raw1394_iso_xmit_init()</function>.
|
|
</para>
|
|
|
|
<para>
|
|
Note: If you passed -1 as the starting cycle to
|
|
<function>raw1394_iso_xmit_init()</function>, the cycle
|
|
number provided to your handler will be incorrect until after
|
|
one buffer's worth of packets have been transmitted.
|
|
</para>
|
|
|
|
<para>
|
|
The transmit handler is also passed a "packet(s) dropped"
|
|
flag. If this flag is nonzero, it means that one or more
|
|
outgoing packets have been dropped since the last call to
|
|
your handler (usually this is because the kernel buffer has
|
|
gone completely empty or a bus reset has occurred).
|
|
</para>
|
|
|
|
</sect1>
|
|
|
|
<sect1>
|
|
|
|
<title>Shutting down</title>
|
|
|
|
<para>
|
|
When the isochronous operation has finished, call
|
|
<function>raw1394_iso_shutdown()</function> to release all
|
|
associated resources. If you don't call this function
|
|
explicitly, it will be called automatically when the raw1394
|
|
handle is destroyed.
|
|
</para>
|
|
|
|
</sect1>
|
|
|
|
</chapter>
|
|
|
|
<chapter id="functions">
|
|
<title>Function Reference</title>
|
|
|
|
<refentry id="API-raw1394-iso-xmit-init">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_xmit_init</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_xmit_init</refname>
|
|
<refpurpose>
|
|
initialize isochronous transmission
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_xmit_init </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>raw1394_iso_xmit_handler_t <parameter>handler</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>buf_packets</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>max_packet_size</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>channel</parameter></paramdef>
|
|
<paramdef>enum raw1394_iso_speed <parameter>speed</parameter></paramdef>
|
|
<paramdef>int <parameter>irq_interval</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>handler</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
handler function for queueing packets
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buf_packets</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
number of isochronous packets to buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>max_packet_size</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
largest packet you need to handle, in bytes
|
|
(not including the isochronous header)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
isochronous channel on which to transmit
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>speed</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
speed at which to transmit
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>irq_interval</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
maximum latency of wake-ups, in packets (-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Allocates all user and kernel resources necessary for isochronous transmission.
|
|
Channel and bandwidth allocation at the IRM is not performed.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-init">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_init</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_init</refname>
|
|
<refpurpose>
|
|
initialize isochronous reception
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_init </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>raw1394_iso_recv_handler_t <parameter>handler</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>buf_packets</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>max_packet_size</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>channel</parameter></paramdef>
|
|
<paramdef>enum raw1394_iso_dma_recv_mode <parameter>mode</parameter></paramdef>
|
|
<paramdef>int <parameter>irq_interval</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>handler</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
handler function for receiving packets
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buf_packets</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
number of isochronous packets to buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>max_packet_size</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
largest packet you need to handle, in bytes (not including
|
|
the isochronous header)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
isochronous channel to receive
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>mode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
bufferfill or packet per buffer mode
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>irq_interval</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
maximum latency of wake-ups, in packets
|
|
(-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Allocates all user and kernel resources necessary for isochronous reception.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-multichannel-recv-init">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_multichannel_recv_init</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_multichannel_recv_init</refname>
|
|
<refpurpose>
|
|
initialize multi-channel iso reception
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_multichannel_recv_init </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>raw1394_iso_recv_handler_t <parameter>handler</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>buf_packets</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>max_packet_size</parameter></paramdef>
|
|
<paramdef>int <parameter>irq_interval</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>handler</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
handler function for receiving packets
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buf_packets</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
number of isochronous packets to buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>max_packet_size</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
largest packet you need to handle, in bytes (not including
|
|
the isochronous header)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>irq_interval</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
maximum latency of wake-ups, in packets (-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Allocates all user and kernel resources necessary for isochronous reception.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-listen-channel">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_listen_channel</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_listen_channel</refname>
|
|
<refpurpose>
|
|
listen to a specific channel in multi-channel mode
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_listen_channel </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>channel</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the channel to start listening
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
listen/unlisten on a specific channel (multi-channel mode ONLY)
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-unlisten-channel">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_unlisten_channel</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_unlisten_channel</refname>
|
|
<refpurpose>
|
|
stop listening to a specific channel in multi-channel mode
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_unlisten_channel </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>channel</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the channel to stop listening to
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-set-channel-mask">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_set_channel_mask</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_set_channel_mask</refname>
|
|
<refpurpose>
|
|
listen or unlisten to a whole bunch of channels at once
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_set_channel_mask </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>u_int64_t <parameter>mask</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>mask</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
64-bit mask of channels, 1 means listen, 0 means unlisten,
|
|
channel 0 is LSB, channel 63 is MSB
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
for multi-channel reception mode only
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success, -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-xmit-start">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_xmit_start</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_xmit_start</refname>
|
|
<refpurpose>
|
|
begin isochronous transmission
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_xmit_start </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>int <parameter>start_on_cycle</parameter></paramdef>
|
|
<paramdef>int <parameter>prebuffer_packets</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start_on_cycle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
isochronous cycle number on which to start
|
|
(-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>prebuffer_packets</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
number of packets to queue up before starting transmission
|
|
(-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-start">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_start</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_start</refname>
|
|
<refpurpose>
|
|
begin isochronous reception
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_start </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>int <parameter>start_on_cycle</parameter></paramdef>
|
|
<paramdef>int <parameter>tag_mask</parameter></paramdef>
|
|
<paramdef>int <parameter>sync</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start_on_cycle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
isochronous cycle number on which to start
|
|
(-1 if you don't care)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag_mask</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
mask of tag fields to match (-1 to receive all packets)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>sync</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
not used, reserved for future implementation
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-xmit-write">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_xmit_write</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_xmit_write</refname>
|
|
<refpurpose>
|
|
alternative blocking-write API for ISO transmission
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_xmit_write </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned char * <parameter>data</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>len</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>tag</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>sy</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to packet data buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>len</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
length of packet, in bytes
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
tag field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>sy</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
sync field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
<function>write</function> style API - do NOT use this if you have set an xmit_handler
|
|
if buffer is full, waits for more space UNLESS the file descriptor is
|
|
set to non-blocking, in which case <function>xmit_write</function> will return -1 with
|
|
errno = EAGAIN
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-xmit-sync">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_xmit_sync</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_xmit_sync</refname>
|
|
<refpurpose>
|
|
wait until all queued packets have been sent
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_xmit_sync </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-recv-flush">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_recv_flush</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_recv_flush</refname>
|
|
<refpurpose>
|
|
flush all already received iso packets from kernel into user space
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_iso_recv_flush </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
If you specified an irq_interval > 1 in
|
|
iso_recv_init, you won't be notified for every single iso packet, but
|
|
for groups of them. Now e.g. if irq_interval is 100, and you were just
|
|
notified about iso packets and after them only 20 more packets arrived,
|
|
no notification will be generated (20 < 100). In the case that you know
|
|
that there should be more packets at this moment, you can call this
|
|
function and all iso packets which are already received by the kernel
|
|
will be flushed out to user space.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-stop">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_stop</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_stop</refname>
|
|
<refpurpose>
|
|
halt isochronous transmission or reception
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void <function>raw1394_iso_stop </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-iso-shutdown">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_iso_shutdown</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_iso_shutdown</refname>
|
|
<refpurpose>
|
|
clean up and deallocate all resources for isochronous transmission or reception
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void <function>raw1394_iso_shutdown </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-read-cycle-timer">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_read_cycle_timer</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_read_cycle_timer</refname>
|
|
<refpurpose>
|
|
get the current value of the cycle timer
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_read_cycle_timer </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>u_int32_t * <parameter>cycle_timer</parameter></paramdef>
|
|
<paramdef>u_int64_t * <parameter>local_time</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>cycle_timer</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
buffer for Isochronous Cycle Timer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>local_time</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
buffer for local system time in microseconds since Epoch
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Simultaneously reads the cycle timer register together with the system clock.
|
|
</para><para>
|
|
|
|
Format of <parameter>cycle_timer</parameter>, from MSB to LSB: 7 bits cycleSeconds (seconds, or
|
|
number of cycleCount rollovers), 13 bits cycleCount (isochronous cycles, or
|
|
cycleOffset rollovers), 12 bits cycleOffset (24.576 MHz clock ticks, not
|
|
provided on some hardware). The union of cycleSeconds and cycleCount is the
|
|
current cycle number. The nominal duration of a cycle is 125 microseconds.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the error code of the ioctl, or 0 if successful.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-errcode">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_errcode</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_errcode</refname>
|
|
<refpurpose>
|
|
return error code of async transaction
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>raw1394_errcode_t <function>raw1394_get_errcode </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Some macros are available to extract information from the error code,
|
|
<function>raw1394_errcode_to_errno</function> can be used to convert it to an errno number of
|
|
roughly the same meaning.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the error code of the last <function>raw1394_read</function>, <function>raw1394_write</function>,
|
|
<function>raw1394_lock</function>. The error code is either an internal
|
|
error (i.e. not a bus error) or a combination of acknowledge code and
|
|
response code, as appropriate.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-errcode-to-errno">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_errcode_to_errno</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_errcode_to_errno</refname>
|
|
<refpurpose>
|
|
convert libraw1394 errcode to errno
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_errcode_to_errno </function></funcdef>
|
|
<paramdef>raw1394_errcode_t <parameter>errcode</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>errcode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the error code to convert
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
The error code as retrieved by <function>raw1394_get_errcode</function> is converted into a
|
|
roughly equivalent errno number and returned. <constant>0xdead</constant> is returned for an
|
|
illegal errcode.
|
|
</para><para>
|
|
|
|
It is intended to be used to decide what to do (retry, give up, report error)
|
|
for those programs that aren't interested in details, since these get lost in
|
|
the conversion. However the returned errnos are equivalent in source code
|
|
meaning only, the associated text of e.g. <function>perror</function> is not necessarily
|
|
meaningful.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
<constant>EAGAIN</constant> (retrying might succeed, also generation number
|
|
mismatch), <constant>EREMOTEIO</constant> (other node had internal problems), <constant>EPERM</constant> (operation
|
|
not allowed on this address, e.g. write on read-only location), <constant>EINVAL</constant>
|
|
(invalid argument) and <constant>EFAULT</constant> (invalid pointer).
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-new-handle">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_new_handle</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_new_handle</refname>
|
|
<refpurpose>
|
|
create new handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>raw1394handle_t <function>raw1394_new_handle </function></funcdef>
|
|
<paramdef> <parameter>void</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>void</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
no arguments
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
</para><para>
|
|
|
|
Creates and returns a new handle which can (after being set up) control one
|
|
port. It is not allowed to use the same handle in multiple threads or forked
|
|
processes. It is allowed to create and use multiple handles, however. Use
|
|
one handle per thread which needs it in the multithreaded case.
|
|
</para><para>
|
|
|
|
The default device node is /dev/raw1394, but one can override the default
|
|
by setting environment variable RAW1394DEV. However, if RAW1394DEV points to
|
|
a non-existant or invalid device node, then it also attempts to open the
|
|
default device node.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the created handle or <constant>NULL</constant> when initialization fails. In the latter
|
|
case errno either contains some OS specific error code or EPROTO if
|
|
libraw1394 and raw1394 don't support each other's protocol versions.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-destroy-handle">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_destroy_handle</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_destroy_handle</refname>
|
|
<refpurpose>
|
|
deallocate handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void <function>raw1394_destroy_handle </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
handle to deallocate
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Closes connection with raw1394 on this handle and deallocates everything
|
|
associated with it. It is safe to pass <constant>NULL</constant> as handle, nothing is done in
|
|
this case.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-new-handle-on-port">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_new_handle_on_port</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_new_handle_on_port</refname>
|
|
<refpurpose>
|
|
create a new handle and bind it to a port
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>raw1394handle_t <function>raw1394_new_handle_on_port </function></funcdef>
|
|
<paramdef>int <parameter>port</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>port</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
port to connect to (same as argument to <function>raw1394_set_port</function>)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Same as <function>raw1394_new_handle</function>, but also binds the handle to the
|
|
specified 1394 port. Equivalent to <function>raw1394_new_handle</function> followed by
|
|
<function>raw1394_get_port_info</function> and <function>raw1394_set_port</function>. Useful for
|
|
command-line programs that already know what port they want. If
|
|
<function>raw1394_set_port</function> returns ESTALE, retries automatically.
|
|
</para><para>
|
|
|
|
The default device node is /dev/raw1394, but one can override the default
|
|
by setting environment variable RAW1394DEV. However, if RAW1394DEV points to
|
|
a non-existant or invalid device node, then it also attempts to open the
|
|
default device node.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the new handle on success or NULL on failure
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-busreset-notify">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_busreset_notify</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_busreset_notify</refname>
|
|
<refpurpose>
|
|
Switch off/on busreset-notification for handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_busreset_notify </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>int <parameter>off_on_switch</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>off_on_switch</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
RAW1394_NOTIFY_OFF or RAW1394_NOTIFY_ON
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-fd">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_fd</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_fd</refname>
|
|
<refpurpose>
|
|
get the communication file descriptor
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_get_fd </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This can be used for <function>select</function>/<function>poll</function> calls if you wait on other fds or can be
|
|
integrated into another event loop (e.g. from a GUI application framework).
|
|
It can also be used to set/remove the O_NONBLOCK flag using <function>fcntl</function> to modify
|
|
the blocking behaviour in <function>raw1394_loop_iterate</function>. It must not be used for
|
|
anything else.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the fd used for communication with the raw1394 kernel module or -1
|
|
on failure (sets errno).
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-userdata">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_userdata</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_userdata</refname>
|
|
<refpurpose>
|
|
associate user data with a handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void <function>raw1394_set_userdata </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>void * <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
user data (pointer)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Allows to associate one void pointer with a handle. libraw1394 does not care
|
|
about the data, it just stores it in the handle allowing it to be retrieved
|
|
at any time with <function>raw1394_get_userdata</function>. This can be useful when multiple
|
|
handles are used, so that callbacks can identify the handle.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-userdata">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_userdata</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_userdata</refname>
|
|
<refpurpose>
|
|
retrieve user data from handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void * <function>raw1394_get_userdata </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the user data pointer associated with the handle using
|
|
<function>raw1394_set_userdata</function>.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-local-id">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_local_id</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_local_id</refname>
|
|
<refpurpose>
|
|
get node ID of the current port
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>nodeid_t <function>raw1394_get_local_id </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the node ID of the local node connected to which the handle is
|
|
connected. This value can change with every bus reset.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-irm-id">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_irm_id</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_irm_id</refname>
|
|
<refpurpose>
|
|
get node ID of isochronous resource manager
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>nodeid_t <function>raw1394_get_irm_id </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the node ID of the isochronous resource manager of the bus the handle
|
|
is connected to. This value may change with every bus reset.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-nodecount">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_nodecount</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_nodecount</refname>
|
|
<refpurpose>
|
|
get number of nodes on the bus
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_get_nodecount </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Since the root node always has
|
|
the highest node ID, this number can be used to determine that ID (it's
|
|
LOCAL_BUS|(count-1)).
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the number of nodes on the bus to which the handle is connected.
|
|
This value can change with every bus reset.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-port-info">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_port_info</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_port_info</refname>
|
|
<refpurpose>
|
|
get information about available ports
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_get_port_info </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>struct raw1394_portinfo * <parameter>pinf</parameter></paramdef>
|
|
<paramdef>int <parameter>maxports</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>pinf</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to an array of struct raw1394_portinfo
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>maxports</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
number of elements in <parameter>pinf</parameter>
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Before you can set which port to use, you have to use this function to find
|
|
out which ports exist.
|
|
</para><para>
|
|
|
|
If your program is interactive, you should present the user with this list to
|
|
let them decide which port to use if there is more than one. A
|
|
non-interactive program (and probably interactive ones, too) should provide a
|
|
command line option to choose the port. If <parameter>maxports</parameter> is <constant>0</constant>, <parameter>pinf</parameter> can be
|
|
<constant>NULL</constant>, too.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the number of ports and writes information about them into <parameter>pinf</parameter>, but
|
|
not into more than <parameter>maxports</parameter> elements.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-port">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_port</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_port</refname>
|
|
<refpurpose>
|
|
choose port for handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_set_port </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>int <parameter>port</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>port</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
port to connect to (corresponds to index of struct raw1394_portinfo)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function connects the handle to the port given (as queried with
|
|
<function>raw1394_get_port_info</function>). If successful, <function>raw1394_get_port_info</function> and
|
|
<function>raw1394_set_port</function> are not allowed to be called afterwards on this handle.
|
|
To make up for this, all the other functions (those handling asynchronous and
|
|
isochronous transmissions) can now be called.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
<constant>0</constant> for success or -1 for failure with errno set appropriately. A
|
|
possible failure mode is with errno = <constant>ESTALE</constant>, in this case the configuration
|
|
has changed since the call to <function>raw1394_get_port_info</function> and it has to be called
|
|
again to update your view of the available ports.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-reset-bus">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_reset_bus</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_reset_bus</refname>
|
|
<refpurpose>
|
|
initiate bus reset
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_reset_bus </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function initiates a bus reset on the connected port. Usually this is
|
|
not necessary and should be avoided, this function is here for low level bus
|
|
control and debugging.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
<constant>0</constant> for success or -1 for failure with errno set appropriately
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-reset-bus-new">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_reset_bus_new</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_reset_bus_new</refname>
|
|
<refpurpose>
|
|
Reset the connected bus (with certain type).
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_reset_bus_new </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>int <parameter>type</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>type</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
RAW1394_SHORT_RESET or RAW1394_LONG_RESET
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
<constant>0</constant> for success or -1 for failure
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-loop-iterate">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_loop_iterate</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_loop_iterate</refname>
|
|
<refpurpose>
|
|
get and process one event message
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_loop_iterate </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Get one new message through handle and process it with the registered message
|
|
handler. Note that some other library functions may call this function
|
|
multiple times to wait for their completion, some handler return values may
|
|
get lost if you use these.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
<constant>-1</constant> for an error or the return value of
|
|
the handler which got executed. The default handlers always return zero.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-bus-reset-handler">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_bus_reset_handler</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_bus_reset_handler</refname>
|
|
<refpurpose>
|
|
set bus reset handler
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>bus_reset_handler_t <function>raw1394_set_bus_reset_handler </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>bus_reset_handler_t <parameter>new_h</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>new_h</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to new handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Sets the handler to be called on every bus reset to <parameter>new_h</parameter>.
|
|
The default handler just calls <function>raw1394_update_generation</function>.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the old handler or NULL on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-generation">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_generation</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_generation</refname>
|
|
<refpurpose>
|
|
get generation number of handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>unsigned int <function>raw1394_get_generation </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
The generation number is incremented on every bus reset, and every transaction
|
|
started by raw1394 is tagged with the stored generation number. If these
|
|
don't match, the transaction will abort with an error.
|
|
The generation number of the handle is not automatically updated,
|
|
<function>raw1394_update_generation</function> has to be used for this.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the generation number associated with the handle or UINT_MAX on
|
|
failure.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-update-generation">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_update_generation</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_update_generation</refname>
|
|
<refpurpose>
|
|
set generation number of handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>void <function>raw1394_update_generation </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>generation</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>generation</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
new generation number
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function sets the generation number of the handle to <parameter>gen</parameter>. All requests
|
|
that apply to a single node ID are tagged with this number and abort with an
|
|
error if that is different from the generation number kept in the kernel.
|
|
This avoids acting on the wrong node which may have changed its ID in a bus
|
|
reset.
|
|
</para><para>
|
|
|
|
You should call this within your bus reset handler with an incremented value.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-tag-handler">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_tag_handler</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_tag_handler</refname>
|
|
<refpurpose>
|
|
set request completion handler
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>tag_handler_t <function>raw1394_set_tag_handler </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>tag_handler_t <parameter>new_h</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>new_h</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to new handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Sets the handler to be called whenever a request completes to <parameter>new_h</parameter>.
|
|
The default handler interprets the tag as a pointer
|
|
to a <structname>struct raw1394_reqhandle</structname> and calls the callback in there.
|
|
</para><para>
|
|
|
|
Care must be taken when replacing the tag handler and calling the synchronous
|
|
versions of the transaction functions (i.e. <function>raw1394_read</function>, <function>raw1394_write</function>,
|
|
<function>raw1394_lock</function>) since these do pass pointers to <structname>struct
|
|
raw1394_reqhandle</structname> as the tag and expect the callback to be invoked.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the old handler or NULL on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-arm-tag-handler">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_arm_tag_handler</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_arm_tag_handler</refname>
|
|
<refpurpose>
|
|
set the async request handler
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>arm_tag_handler_t <function>raw1394_set_arm_tag_handler </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>arm_tag_handler_t <parameter>new_h</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>new_h</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to new handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Set the handler that will be called when an async read/write/lock arm_request
|
|
arrived. The default action is to call the arm_callback in the
|
|
raw1394_arm_reqhandle pointed to by arm_tag.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
old handler or NULL on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-set-fcp-handler">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_set_fcp_handler</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_set_fcp_handler</refname>
|
|
<refpurpose>
|
|
set FCP handler
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>fcp_handler_t <function>raw1394_set_fcp_handler </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>fcp_handler_t <parameter>new_h</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>new_h</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to new handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Function Control Protocol is defined in IEC 61883-1.
|
|
</para><para>
|
|
|
|
Sets the handler to be called when either FCP command or FCP response
|
|
registers get written to <parameter>new_h</parameter>. The default handler does nothing.
|
|
In order to actually get FCP events, you have to enable it with
|
|
<function>raw1394_start_fcp_listen</function> and can stop it with <function>raw1394_stop_fcp_listen</function>.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
the old handler or NULL on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-int">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>int</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>int</refname>
|
|
<refpurpose>
|
|
This is the general request handler
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>typedef <function>int </function></funcdef>
|
|
<paramdef> * <parameter>req_callback_t</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>req_callback_t</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
This is the general request handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
It is used by the default tag handler
|
|
when a request completes, it calls the callback and passes it the data
|
|
pointer and the error code of the request.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-int">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>int</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>int</refname>
|
|
<refpurpose>
|
|
This is the general arm-request handle
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>typedef <function>int </function></funcdef>
|
|
<paramdef> * <parameter>arm_req_callback_t</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>arm_req_callback_t</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
This is the general arm-request handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
(arm = address range mapping)
|
|
It is used by the default arm-tag handler when a request has been
|
|
received, it calls the arm_callback.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-arm-register">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_arm_register</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_arm_register</refname>
|
|
<refpurpose>
|
|
register an AddressRangeMapping
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_arm_register </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>start</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>byte_t * <parameter>initial_value</parameter></paramdef>
|
|
<paramdef>octlet_t <parameter>arm_tag</parameter></paramdef>
|
|
<paramdef>arm_options_t <parameter>access_rights</parameter></paramdef>
|
|
<paramdef>arm_options_t <parameter>notification_options</parameter></paramdef>
|
|
<paramdef>arm_options_t <parameter>client_transactions</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>initial_value</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to buffer containing (if necessary) initial value
|
|
NULL means undefined
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>arm_tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifier for arm_tag_handler
|
|
(usually pointer to raw1394_arm_reqhandle)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>access_rights</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
access-rights for registered addressrange handled
|
|
by kernel-part. Value is one or more binary or of the
|
|
following flags - ARM_READ, ARM_WRITE, ARM_LOCK
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>notification_options</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies for which type of request you want
|
|
to be notified. Value is one or more binary or of the
|
|
following flags - ARM_READ, ARM_WRITE, ARM_LOCK
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>client_transactions</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies for which type of request you want
|
|
to handle the request by the client application.
|
|
for those requests no response will be generated, but
|
|
has to be generated by the application.
|
|
Value is one or more binary or of the
|
|
following flags - ARM_READ, ARM_WRITE, ARM_LOCK
|
|
For each bit set here, notification_options and
|
|
access_rights will be ignored.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
ARM = Adress Range Mapping
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-arm-unregister">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_arm_unregister</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_arm_unregister</refname>
|
|
<refpurpose>
|
|
unregister an AddressRangeMapping
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_arm_unregister </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>start</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange for unregistering
|
|
(value of start have to be the same value
|
|
used for registering this adressrange)
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-arm-set-buf">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_arm_set_buf</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_arm_set_buf</refname>
|
|
<refpurpose>
|
|
set the buffer of an AdressRangeMapping
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_arm_set_buf </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>start</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>void * <parameter>buf</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buf</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function copies <parameter>length</parameter> bytes from user memory area <parameter>buf</parameter>
|
|
to one ARM block in kernel memory area
|
|
with start offset <parameter>start</parameter>.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-arm-get-buf">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_arm_get_buf</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_arm_get_buf</refname>
|
|
<refpurpose>
|
|
get the buffer of an AdressRangeMapping
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_arm_get_buf </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>start</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>void * <parameter>buf</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>start</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
identifies addressrange
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buf</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to buffer
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function copies <parameter>length</parameter> bytes from one
|
|
ARM block in kernel memory area with start offset <parameter>start</parameter>
|
|
to user memory area <parameter>buf</parameter>
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-echo-request">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_echo_request</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_echo_request</refname>
|
|
<refpurpose>
|
|
send an echo request to the driver
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_echo_request </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
arbitrary data; raw1394_loop_iterate will return it
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
the driver then send back the
|
|
same request. raw1394_loop_iterate will return data as return value,
|
|
when it processes the echo.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-wake-up">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_wake_up</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_wake_up</refname>
|
|
<refpurpose>
|
|
wake up raw1394_loop_iterate
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_wake_up </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
(or a blocking read from the device
|
|
file). actually this calls raw1394_echo_request with 0 as data.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-phy-packet-write">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_phy_packet_write</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_phy_packet_write</refname>
|
|
<refpurpose>
|
|
send physical request
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_phy_packet_write </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the contents of the packet
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
examples of physical requests are linkon, physicalconfigurationpacket, etc.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-phy-packet-write">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_phy_packet_write</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_phy_packet_write</refname>
|
|
<refpurpose>
|
|
initiate sending a physical request
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_phy_packet_write </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>data</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>tag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the contents of the packet
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
examples of physical requests are linkon, physicalconfigurationpacket, etc.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-read">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_read</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_read</refname>
|
|
<refpurpose>
|
|
initiate a read transaction
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_read </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>buffer</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>tag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of bytes of data to read
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buffer</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to buffer where data will be saved
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function starts the specified read request. If
|
|
<parameter>length</parameter> is <constant>4</constant> a quadlet read is initiated and a block read otherwise.
|
|
</para><para>
|
|
|
|
The transaction is only started, no success of the transaction is implied
|
|
with a successful return of this function. When the transaction completes, a
|
|
<function>raw1394_loop_iterate</function> will call the tag handler and pass it the tag and
|
|
error code of the transaction. <parameter>tag</parameter> should therefore be set to something
|
|
that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
unsigned long).
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-write">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_write</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_write</refname>
|
|
<refpurpose>
|
|
initiate a write transaction
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_write </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>tag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to write to
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of bytes of data to write
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to be sent
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function starts the specified write request. If
|
|
<parameter>length</parameter> is <constant>4</constant> a quadlet write is initiated and a block write otherwise.
|
|
</para><para>
|
|
|
|
The transaction is only started, no success of the transaction is implied
|
|
with a successful return of this function. When the transaction completes, a
|
|
<function>raw1394_loop_iterate</function> will call the tag handler and pass it the tag and
|
|
error code of the transaction. <parameter>tag</parameter> should therefore be set to something
|
|
that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
unsigned long).
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-lock">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_lock</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_lock</refname>
|
|
<refpurpose>
|
|
initiate a 32-bit compare-swap lock transaction
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_lock </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>extcode</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>data</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>arg</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>result</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>tag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>extcode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
extended transaction code determining the lock operation
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>arg</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
arg part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>result</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address where return value will be written
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function starts the specified lock request.
|
|
The transaction is only started, no success of the transaction is implied
|
|
with a successful return of this function. When the transaction completes, a
|
|
<function>raw1394_loop_iterate</function> will call the tag handler and pass it the tag and
|
|
error code of the transaction. <parameter>tag</parameter> should therefore be set to something
|
|
that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
unsigned long).
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-lock64">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_lock64</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_lock64</refname>
|
|
<refpurpose>
|
|
initiate a 64-bit compare-swap lock transaction
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_lock64 </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>extcode</parameter></paramdef>
|
|
<paramdef>octlet_t <parameter>data</parameter></paramdef>
|
|
<paramdef>octlet_t <parameter>arg</parameter></paramdef>
|
|
<paramdef>octlet_t * <parameter>result</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>tag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>extcode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
extended transaction code determining the lock operation
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>arg</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
arg part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>result</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address where return value will be written
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This function starts the specified lock request.
|
|
The transaction is only started, no success of the transaction is implied
|
|
with a successful return of this function. When the transaction completes, a
|
|
<function>raw1394_loop_iterate</function> will call the tag handler and pass it the tag and
|
|
error code of the transaction. <parameter>tag</parameter> should therefore be set to something
|
|
that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
unsigned long).
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-async-stream">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_async_stream</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_async_stream</refname>
|
|
<refpurpose>
|
|
initiate asynchronous stream
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_async_stream </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>channel</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>tag</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>sy</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>speed</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>rawtag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the isochronous channel number to send on
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to be put into packet's tag field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>sy</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to be put into packet's sy field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>speed</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
speed at which to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of data to send, in bytes
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>rawtag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Passes custom tag. Use pointer to raw1394_reqhandle if you use the standard
|
|
tag handler.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-async-send">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_async_send</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_async_send</refname>
|
|
<refpurpose>
|
|
send an asynchronous packet
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_async_send </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>size_t <parameter>header_length</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>expect_response</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
<paramdef>unsigned long <parameter>rawtag</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the amount of bytes of data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>header_length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the number of bytes in the header
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>expect_response</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
indicate with a 0 or 1 whether to receive a completion event
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>rawtag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to identify the request to completion handler
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This starts sending an arbitrary async packet. It gets an array of quadlets
|
|
consisting of header and data (without CRC in between). Header information
|
|
is always in machine byte order, data (data block as well as quadlet data
|
|
in a read response for data quadlet) shall be in big endian byte order.
|
|
expect_response indicates, if we expect a response (i.e. if we will get the
|
|
tag back after the packet was sent or after a response arrived). length is
|
|
the length of the complete packet (header_length + length of the data block).
|
|
The main purpose of this function is to send responses for incoming
|
|
transactions, that are handled by the application.
|
|
Do not use that function, unless you really know, what you do! Sending
|
|
corrupt packet may lead to weird results.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-read">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_read</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_read</refname>
|
|
<refpurpose>
|
|
send async read request to a node and wait for response.
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_read </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>buffer</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of bytes of data to read
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buffer</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to buffer where data will be saved
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
If <parameter>length</parameter> is <constant>4</constant>, a quadlet read request is used.
|
|
</para><para>
|
|
|
|
This does the complete transaction and will return when it's finished. It
|
|
will call <function>raw1394_loop_iterate</function> as often as necessary, return values of
|
|
handlers called will be therefore lost.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-write">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_write</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_write</refname>
|
|
<refpurpose>
|
|
send async write request to a node and wait for response.
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_write </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to write to
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of bytes of data to write
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to be sent
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
If <parameter>length</parameter> is <constant>4</constant>, a quadlet write request is used.
|
|
</para><para>
|
|
|
|
This does the complete transaction and will return when it's finished. It
|
|
will call <function>raw1394_loop_iterate</function> as often as necessary, return values of
|
|
handlers called will be therefore lost.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-lock">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_lock</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_lock</refname>
|
|
<refpurpose>
|
|
send 32-bit compare-swap lock request and wait for response.
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_lock </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>extcode</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>data</parameter></paramdef>
|
|
<paramdef>quadlet_t <parameter>arg</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>result</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>extcode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
extended transaction code determining the lock operation
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>arg</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
arg part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>result</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address where return value will be written
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This does the complete transaction and will return when it's finished. It
|
|
will call <function>raw1394_loop_iterate</function> as often as necessary, return values of
|
|
handlers called will be therefore lost.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-lock64">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_lock64</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_lock64</refname>
|
|
<refpurpose>
|
|
send 64-bit compare-swap lock request and wait for response.
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_lock64 </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>nodeid_t <parameter>node</parameter></paramdef>
|
|
<paramdef>nodeaddr_t <parameter>addr</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>extcode</parameter></paramdef>
|
|
<paramdef>octlet_t <parameter>data</parameter></paramdef>
|
|
<paramdef>octlet_t <parameter>arg</parameter></paramdef>
|
|
<paramdef>octlet_t * <parameter>result</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>node</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
target node ID
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>addr</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address to read from
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>extcode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
extended transaction code determining the lock operation
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>arg</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
arg part of lock parameters
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>result</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
address where return value will be written
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
This does the complete transaction and will return when it's finished. It
|
|
will call <function>raw1394_loop_iterate</function> as often as necessary, return values of
|
|
handlers called will be therefore lost.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-async-stream">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_async_stream</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_async_stream</refname>
|
|
<refpurpose>
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_async_stream </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>channel</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>tag</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>sy</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>speed</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the isochronous channel number to send on
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>tag</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to be put into packet's tag field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>sy</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
data to be put into packet's sy field
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>speed</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
speed at which to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
amount of bytes of data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-async-send">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_async_send</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_async_send</refname>
|
|
<refpurpose>
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_async_send </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>size_t <parameter>length</parameter></paramdef>
|
|
<paramdef>size_t <parameter>header_length</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>expect_response</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>data</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the amount of bytes of data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>header_length</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the number of bytes in the header
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>expect_response</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
indicate with a 0 or 1 whether to receive a completion event
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>data</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
pointer to data to send
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-start-fcp-listen">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_start_fcp_listen</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_start_fcp_listen</refname>
|
|
<refpurpose>
|
|
enable reception of FCP events
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_start_fcp_listen </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
FCP = Function Control Protocol (see IEC 61883-1)
|
|
Enables the reception of FCP events (writes to the FCP_COMMAND or
|
|
FCP_RESPONSE address ranges) on <parameter>handle</parameter>. FCP requests are then passed to the
|
|
callback specified with <function>raw1394_set_fcp_handler</function>.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-stop-fcp-listen">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_stop_fcp_listen</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_stop_fcp_listen</refname>
|
|
<refpurpose>
|
|
disable reception of FCP events
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_stop_fcp_listen </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Stops the reception of FCP events (writes to the FCP_COMMAND or
|
|
FCP_RESPONSE address ranges) on <parameter>handle</parameter>.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
0 on success or -1 on failure (sets errno)
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-libversion">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_libversion</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_libversion</refname>
|
|
<refpurpose>
|
|
Returns the version string
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>const char * <function>raw1394_get_libversion </function></funcdef>
|
|
<paramdef> <parameter>void</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>void</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
no arguments
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
</para><para>
|
|
|
|
Instead, typically, one uses 'pkg-config --mod-version libraw1394'
|
|
Might be useful for an application.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
a pointer to a string containing the version number
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-update-config-rom">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_update_config_rom</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_update_config_rom</refname>
|
|
<refpurpose>
|
|
updates the configuration ROM of a host
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_update_config_rom </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>const quadlet_t * <parameter>new_rom</parameter></paramdef>
|
|
<paramdef>size_t <parameter>size</parameter></paramdef>
|
|
<paramdef>unsigned char <parameter>rom_version</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>new_rom</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
a pointer to the new ROM image
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>size</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the size of the new ROM image in bytes
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>rom_version</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the version numer of the current version, not the new
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
<parameter>rom_version</parameter> must be the current
|
|
version, otherwise it will fail with return value -1.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Returns</title>
|
|
<para>
|
|
-1 (failure) if the version is incorrect,
|
|
-2 (failure) if the new rom version is too big, or
|
|
0 for success
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-get-config-rom">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_get_config_rom</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_get_config_rom</refname>
|
|
<refpurpose>
|
|
reads the current version of the configuration ROM of a host
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_get_config_rom </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>quadlet_t * <parameter>buffer</parameter></paramdef>
|
|
<paramdef>size_t <parameter>buffersize</parameter></paramdef>
|
|
<paramdef>size_t * <parameter>rom_size</parameter></paramdef>
|
|
<paramdef>unsigned char * <parameter>rom_version</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buffer</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
the memory address at which to store the copy of the ROM
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>buffersize</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
is the size of the buffer, <parameter>rom_size</parameter>
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>rom_size</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
upon successful return, contains the size of the ROM
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>rom_version</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
upon successful return, contains the version of the rom
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
returns the size of the current rom image. <parameter>rom_version</parameter> is the
|
|
version number of the fetched rom.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Return</title>
|
|
<para>
|
|
-1 (failure) if the buffer was too small or 0 for success
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-bandwidth-modify">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_bandwidth_modify</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_bandwidth_modify</refname>
|
|
<refpurpose>
|
|
allocate or release bandwidth
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_bandwidth_modify </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>bandwidth</parameter></paramdef>
|
|
<paramdef>enum raw1394_modify_mode <parameter>mode</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
a libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>bandwidth</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
IEEE 1394 Bandwidth Alloction Units
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>mode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
whether to allocate or free
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Communicates with the isochronous resource manager.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Return</title>
|
|
<para>
|
|
-1 for failure, 0 for success
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="API-raw1394-channel-modify">
|
|
<refentryinfo>
|
|
<title>LINUX</title>
|
|
<productname>Kernel Hackers Manual</productname>
|
|
<date>August 2009</date>
|
|
</refentryinfo>
|
|
<refmeta>
|
|
<refentrytitle><phrase>raw1394_channel_modify</phrase></refentrytitle>
|
|
<manvolnum>9</manvolnum>
|
|
<refmiscinfo class="version">unknown kernel version</refmiscinfo>
|
|
</refmeta>
|
|
<refnamediv>
|
|
<refname>raw1394_channel_modify</refname>
|
|
<refpurpose>
|
|
allocate or release isochronous channel
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsynopsisdiv>
|
|
<title>Synopsis</title>
|
|
<funcsynopsis><funcprototype>
|
|
<funcdef>int <function>raw1394_channel_modify </function></funcdef>
|
|
<paramdef>raw1394handle_t <parameter>handle</parameter></paramdef>
|
|
<paramdef>unsigned int <parameter>channel</parameter></paramdef>
|
|
<paramdef>enum raw1394_modify_mode <parameter>mode</parameter></paramdef>
|
|
</funcprototype></funcsynopsis>
|
|
</refsynopsisdiv>
|
|
<refsect1>
|
|
<title>Arguments</title>
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term><parameter>handle</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
a libraw1394 handle
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>channel</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
isochronous channel
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term><parameter>mode</parameter></term>
|
|
<listitem>
|
|
<para>
|
|
whether to allocate or free
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<para>
|
|
Communicates with the isochronous resource manager.
|
|
</para>
|
|
</refsect1>
|
|
<refsect1>
|
|
<title>Return</title>
|
|
<para>
|
|
-1 for failure, 0 for success
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
</chapter>
|
|
|
|
</book>
|