443 lines
14 KiB
C
443 lines
14 KiB
C
/*
|
|
* libraw1394 - library for raw access to the 1394 bus with the Linux subsystem.
|
|
*
|
|
* Copyright (C) 1999,2000,2001,2002 Andreas Bombe
|
|
* 2002 Christian Toegel <christian.toegel@gmx.at>
|
|
* 2002 Manfred Weihs <weihs@ict.tuwien.ac.at>
|
|
*
|
|
* This library is licensed under the GNU Lesser General Public License (LGPL),
|
|
* version 2.1 or later. See the file COPYING.LIB in the distribution for
|
|
* details.
|
|
*
|
|
*
|
|
* Contributions:
|
|
*
|
|
* Christian Toegel <christian.toegel@gmx.at>
|
|
* lock64 request
|
|
* transmit physical packet
|
|
* raw1394_echo_request, raw1394_wake_up (interrupt blocking wait)
|
|
*
|
|
* Manfred Weihs <weihs@ict.tuwien.ac.at>
|
|
* raw1394_start_async_send, raw1394_async_send
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
|
|
#include "raw1394.h"
|
|
#include "kernel-raw1394.h"
|
|
#include "raw1394_private.h"
|
|
|
|
|
|
/**
|
|
* raw1394_start_read - initiate a read transaction
|
|
* @node: target node
|
|
* @addr: address to read from
|
|
* @length: amount of data to read
|
|
* @buffer: pointer to buffer where data will be saved
|
|
* @tag: data to identify the request to completion handler
|
|
*
|
|
* This function starts the specified read request and returns %0 for success
|
|
* and a negative number for an error, in which case errno will be set. If
|
|
* @length is %4 a quadlet read is initiated and a block read otherwise.
|
|
*
|
|
* The transaction is only started, no success of the transaction is implied
|
|
* with a successful return of this function. When the transaction completes, a
|
|
* raw1394_loop_iterate() will call the tag handler and pass it the tag and
|
|
* error code of the transaction. @tag should therefore be set to something
|
|
* that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
* unsigned long).
|
|
**/
|
|
int raw1394_start_read(struct raw1394_handle *handle, nodeid_t node,
|
|
nodeaddr_t addr, size_t length, quadlet_t *buffer,
|
|
unsigned long tag)
|
|
{
|
|
struct raw1394_request req;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_ASYNC_READ;
|
|
req.generation = handle->generation;
|
|
req.tag = tag;
|
|
|
|
req.address = ((__u64)node << 48) | addr;
|
|
req.length = length;
|
|
req.recvb = ptr2int(buffer);
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
|
|
/**
|
|
* raw1394_start_write - initiate a write transaction
|
|
* @node: target node
|
|
* @addr: address to write to
|
|
* @length: amount of data to write
|
|
* @data: pointer to data to be sent
|
|
* @tag: data to identify the request to completion handler
|
|
*
|
|
* This function starts the specified write request and returns %0 for success
|
|
* and a negative number for an error, in which case errno will be set. If
|
|
* @length is %4 a quadlet write is initiated and a block write otherwise.
|
|
*
|
|
* The transaction is only started, no success of the transaction is implied
|
|
* with a successful return of this function. When the transaction completes, a
|
|
* raw1394_loop_iterate() will call the tag handler and pass it the tag and
|
|
* error code of the transaction. @tag should therefore be set to something
|
|
* that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
* unsigned long).
|
|
**/
|
|
int raw1394_start_write(struct raw1394_handle *handle, nodeid_t node,
|
|
nodeaddr_t addr, size_t length, quadlet_t *data,
|
|
unsigned long tag)
|
|
{
|
|
struct raw1394_request req;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_ASYNC_WRITE;
|
|
req.generation = handle->generation;
|
|
req.tag = tag;
|
|
|
|
req.address = ((__u64)node << 48) | addr;
|
|
req.length = length;
|
|
req.sendb = ptr2int(data);
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
|
|
/**
|
|
* raw1394_start_lock - initiate a lock transaction
|
|
* @node: target node
|
|
* @addr: address to read from
|
|
* @extcode: extended transaction code determining the lock operation
|
|
* @data: data part of lock parameters
|
|
* @arg: arg part of lock parameters
|
|
* @result: address where return value will be written
|
|
* @tag: data to identify the request to completion handler
|
|
*
|
|
* This function starts the specified lock request and returns %0 for success
|
|
* and a negative number for an error, in which case errno will be set.
|
|
*
|
|
* The transaction is only started, no success of the transaction is implied
|
|
* with a successful return of this function. When the transaction completes, a
|
|
* raw1394_loop_iterate() will call the tag handler and pass it the tag and
|
|
* error code of the transaction. @tag should therefore be set to something
|
|
* that uniquely identifies this transaction (e.g. a struct pointer casted to
|
|
* unsigned long).
|
|
**/
|
|
int raw1394_start_lock(struct raw1394_handle *handle, nodeid_t node,
|
|
nodeaddr_t addr, unsigned int extcode, quadlet_t data,
|
|
quadlet_t arg, quadlet_t *result, unsigned long tag)
|
|
{
|
|
struct raw1394_request req;
|
|
quadlet_t sendbuf[2];
|
|
|
|
if ((extcode > 7) || (extcode == 0)) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_LOCK;
|
|
req.generation = handle->generation;
|
|
req.tag = tag;
|
|
|
|
req.address = ((__u64)node << 48) | addr;
|
|
req.sendb = ptr2int(sendbuf);
|
|
req.recvb = ptr2int(result);
|
|
req.misc = extcode;
|
|
|
|
switch (extcode) {
|
|
case 3: /* EXTCODE_FETCH_ADD */
|
|
case 4: /* EXTCODE_LITTLE_ADD */
|
|
sendbuf[0] = data;
|
|
req.length = 4;
|
|
break;
|
|
default:
|
|
sendbuf[0] = arg;
|
|
sendbuf[1] = data;
|
|
req.length = 8;
|
|
break;
|
|
}
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
int raw1394_start_lock64(struct raw1394_handle *handle, nodeid_t node,
|
|
nodeaddr_t addr, unsigned int extcode, octlet_t data,
|
|
octlet_t arg, octlet_t *result, unsigned long tag)
|
|
{
|
|
struct raw1394_request req;
|
|
octlet_t sendbuf[2];
|
|
|
|
if ((extcode > 7) || (extcode == 0)) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_LOCK64;
|
|
req.generation = handle->generation;
|
|
req.tag = tag;
|
|
|
|
req.address = ((__u64)node << 48) | addr;
|
|
req.sendb = ptr2int(sendbuf);
|
|
req.recvb = ptr2int(result);
|
|
req.misc = extcode;
|
|
|
|
switch (extcode) {
|
|
case 3: /* EXTCODE_FETCH_ADD */
|
|
case 4: /* EXTCODE_LITTLE_ADD */
|
|
sendbuf[0] = data;
|
|
req.length = 8;
|
|
break;
|
|
default:
|
|
sendbuf[0] = arg;
|
|
sendbuf[1] = data;
|
|
req.length = 16;
|
|
break;
|
|
}
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
|
|
/**
|
|
* raw1394_start_iso_write - initiate an isochronous packet write
|
|
* @channel: channel number on which to send on
|
|
* @tag: data to be put into packet's tag field
|
|
* @sy: data to be put into packet's sy field
|
|
* @speed: speed at which to send
|
|
* @length: amount of data to send
|
|
* @data: pointer to data to send
|
|
* @rawtag: data to identify the request to completion handler
|
|
*
|
|
* This function starts the specified isochronous packet transmission and
|
|
* returns %0 for success and a negative number for an error, in which case
|
|
* errno will be set.
|
|
*
|
|
* When the send completes, a raw1394_loop_iterate() will call the tag handler
|
|
* and pass it the tag and error code of the transaction. @tag should therefore
|
|
* be set to something that uniquely identifies this transaction (e.g. a struct
|
|
* pointer casted to unsigned long).
|
|
*
|
|
* Isochronous packets are automatically
|
|
**/
|
|
int raw1394_start_iso_write(struct raw1394_handle *handle, unsigned int channel,
|
|
unsigned int tag, unsigned int sy,
|
|
unsigned int speed, size_t length, quadlet_t *data,
|
|
unsigned long rawtag)
|
|
{
|
|
struct raw1394_request req;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_ISO_SEND;
|
|
req.generation = handle->generation;
|
|
req.tag = rawtag;
|
|
|
|
req.address = ((__u64)channel << 48) | speed;
|
|
req.misc = (tag << 16) | sy;
|
|
req.length = length;
|
|
req.sendb = ptr2int(data);
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
int raw1394_start_async_stream(struct raw1394_handle *handle,
|
|
unsigned int channel,
|
|
unsigned int tag, unsigned int sy,
|
|
unsigned int speed, size_t length, quadlet_t *data,
|
|
unsigned long rawtag)
|
|
{
|
|
struct raw1394_request *req = &handle->req;
|
|
|
|
CLEAR_REQ(req);
|
|
|
|
req->type = RAW1394_REQ_ASYNC_STREAM;
|
|
req->generation = handle->generation;
|
|
req->tag = rawtag;
|
|
|
|
req->address = ((__u64)channel << 48) | speed;
|
|
req->misc = (tag << 16) | sy;
|
|
req->length = length;
|
|
req->sendb = ptr2int(data);
|
|
|
|
return (int)write(handle->fd, req, sizeof(*req));
|
|
}
|
|
|
|
int raw1394_start_async_send(struct raw1394_handle *handle,
|
|
size_t length, size_t header_length, unsigned int expect_response,
|
|
quadlet_t *data, unsigned long rawtag)
|
|
{
|
|
struct raw1394_request req;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_ASYNC_SEND;
|
|
req.generation = handle->generation;
|
|
req.tag = rawtag;
|
|
|
|
req.length = length;
|
|
req.misc = (expect_response << 16) | (header_length & 0xffff);
|
|
req.sendb = ptr2int(data);
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
|
|
#define SYNCFUNC_VARS \
|
|
struct sync_cb_data sd = { 0, 0 }; \
|
|
struct raw1394_reqhandle rh = { (req_callback_t)_raw1394_sync_cb, \
|
|
&sd }; \
|
|
int err = 0
|
|
|
|
#define SYNCFUNC_BODY \
|
|
while (!sd.done) { \
|
|
if (err < 0) return err; \
|
|
err = raw1394_loop_iterate(handle); \
|
|
} \
|
|
handle->err = sd.errcode; \
|
|
errno = raw1394_errcode_to_errno(sd.errcode); \
|
|
return (errno ? -1 : 0)
|
|
|
|
int raw1394_read(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
|
|
size_t length, quadlet_t *buffer)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_read(handle, node, addr, length, buffer,
|
|
(unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
int raw1394_write(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
|
|
size_t length, quadlet_t *data)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_write(handle, node, addr, length, data,
|
|
(unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
int raw1394_lock(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
|
|
unsigned int extcode, quadlet_t data, quadlet_t arg,
|
|
quadlet_t *result)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_lock(handle, node, addr, extcode, data, arg, result,
|
|
(unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
int raw1394_lock64(struct raw1394_handle *handle, nodeid_t node, nodeaddr_t addr,
|
|
unsigned int extcode, octlet_t data, octlet_t arg,
|
|
octlet_t *result)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_lock64(handle, node, addr, extcode, data, arg, result,
|
|
(unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
|
|
int raw1394_iso_write(struct raw1394_handle *handle, unsigned int channel,
|
|
unsigned int tag, unsigned int sy, unsigned int speed,
|
|
size_t length, quadlet_t *data)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_iso_write(handle, channel, tag, sy, speed, length,
|
|
data, (unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
int raw1394_async_stream(struct raw1394_handle *handle, unsigned int channel,
|
|
unsigned int tag, unsigned int sy, unsigned int speed,
|
|
size_t length, quadlet_t *data)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_async_stream(handle, channel, tag, sy, speed, length,
|
|
data, (unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
int raw1394_async_send(struct raw1394_handle *handle ,
|
|
size_t length, size_t header_length, unsigned int expect_response,
|
|
quadlet_t *data)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_async_send(handle, length, header_length, expect_response,
|
|
data, (unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY;
|
|
}
|
|
|
|
|
|
|
|
int raw1394_start_phy_packet_write(struct raw1394_handle *handle,
|
|
quadlet_t data, unsigned long tag)
|
|
{
|
|
struct raw1394_request req;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_PHYPACKET;
|
|
req.generation = handle->generation;
|
|
req.tag = tag;
|
|
|
|
req.sendb = data;
|
|
|
|
return (int)write(handle->fd, &req, sizeof(req));
|
|
}
|
|
|
|
int raw1394_phy_packet_write (struct raw1394_handle *handle, quadlet_t data)
|
|
{
|
|
SYNCFUNC_VARS;
|
|
|
|
err = raw1394_start_phy_packet_write(handle, data, (unsigned long)&rh);
|
|
|
|
SYNCFUNC_BODY; /* return 0 on success */
|
|
}
|
|
|
|
int raw1394_echo_request(struct raw1394_handle *handle, quadlet_t data)
|
|
{
|
|
struct raw1394_request req;
|
|
int retval=0;
|
|
|
|
CLEAR_REQ(&req);
|
|
|
|
req.type = RAW1394_REQ_ECHO;
|
|
req.misc = data;
|
|
|
|
retval = (int)write(handle->fd, &req, sizeof(req));
|
|
if (retval == sizeof(req)) {
|
|
return 0; /* succcess */
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int raw1394_wake_up(raw1394handle_t handle)
|
|
{
|
|
return raw1394_echo_request(handle, 0);
|
|
}
|
|
|
|
#undef SYNCFUNC_VARS
|
|
#undef SYNCFUNC_BODY
|