/*
* libiec61883 - Linux IEEE 1394 streaming media library.
* Copyright (C) 2004 Kristian Hogsberg, Dan Dennedy, and Dan Maas.
* This file written by Dan Dennedy.
*
* Bits of raw1394 ARM handling borrowed from
* Christian Toegel's <christian.toegel@gmx.at> demos.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "iec61883.h"
#include "iec61883-private.h"
#include "cooked.h"
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <netinet/in.h>
#include <libraw1394/csr.h>
/*
* Plug register access functions
*
* Please see the convenience macros defined in iec61883.h.
*/
int
iec61883_plug_get(raw1394handle_t h, nodeid_t n, nodeaddr_t a, quadlet_t *value)
{
quadlet_t temp; /* register value */
int result;
result = iec61883_cooked_read( h, n, CSR_REGISTER_BASE + a, sizeof(quadlet_t), &temp);
if (result >= 0)
*value = ntohl(temp); /* endian conversion */
return result;
}
int
iec61883_plug_set(raw1394handle_t h, nodeid_t n, nodeaddr_t a, quadlet_t value)
{
quadlet_t compare, swap, new;
int result;
/* get the current register value for comparison */
result = iec61883_plug_get( h, n, a, &compare );
if (result >= 0)
{
/* convert endian */
compare = htonl(compare);
swap = htonl(value);
result = raw1394_lock( h, n, CSR_REGISTER_BASE + a, EXTCODE_COMPARE_SWAP, swap, compare, &new);
if (new != compare)
result = -EAGAIN;
}
return result;
}
/*
* Local host plugs implementation
*
* This requires the address range mapping feature of libraw1394 1.0.
*/
/* ARM context identifiers */
static char g_arm_callback_context_out[] = "libiec61883 output context";
static char g_arm_callback_context_in[] = "libiec61883 input context";
static struct raw1394_arm_reqhandle g_arm_reqhandle_out;
static struct raw1394_arm_reqhandle g_arm_reqhandle_in;
/* register space */
/* Please note that this is host global. Each port (host adapter)
does not get its own register space. Also, this is only intended
for use by a single application. It appears that when multiple processes
host these plugs, it still works; as long as the application uses the
plug access functions above, then it should work. */
static struct output_registers {
struct iec61883_oMPR mpr;
struct iec61883_oPCR pcr[IEC61883_PCR_MAX];
} g_data_out;
static struct input_registers {
struct iec61883_iMPR mpr;
struct iec61883_iPCR pcr[IEC61883_PCR_MAX];
} g_data_in;
/** Send an async packet in response to a register read.
*
* This function handles host to bus endian conversion.
*
* \param handle A raw1394 handle.
* \param arm_req A pointer to an arm_request struct from the ARM callback
* handler.
* \param a The CSR offset address of the register.
* \param data The base address of the register space to read.
* \return 0 for success, -1 on error.
*/
static int
do_arm_read(raw1394handle_t handle, struct raw1394_arm_request *arm_req,
nodeaddr_t a, quadlet_t *data)
{
quadlet_t *response;
int num=4, offset;
/* allocate response packet */
response = malloc(num * sizeof(quadlet_t));
if (!response)
FAIL("unable to allocate response packet");
memset(response, 0x00, num * sizeof(quadlet_t));
/* fill data of response */
response[0] =
((arm_req->source_nodeid & 0xFFFF) << 16) +
((arm_req->tlabel & 0x3F) << 10) +
(6 << 4); /* tcode = 6 */
response[1] = ((arm_req->destination_nodeid & 0xFFFF) << 16);
/* rcode = resp_complete implied */
DEBUG (" destination_offset=%d",
arm_req->destination_offset - CSR_REGISTER_BASE - a);
offset = (arm_req->destination_offset - CSR_REGISTER_BASE - a)/4;
response[3] = htonl(data[offset]);
DEBUG(" response: 0x%8.8X",response[0]);
DEBUG(" 0x%8.8X",response[1]);
DEBUG(" 0x%8.8X",response[2]);
DEBUG(" 0x%8.8X",response[3]);
/* send response */
raw1394_start_async_send(handle, 16 , 16, 0, response, 0);
free (response);
return 0;
}
/** Update a local register value, and send a response packet.
*
* This function performs a compare/swap lock operation only.
* This function handles host to bus endian conversion.
*
* \param handle A raw1394 handle.
* \param arm_req A pointer to an arm_request struct from the ARM callback
* handler.
* \param a The CSR offset address of the register.
* \param data The base address of the register space to update.
* \return 0 for success, -1 on error.
*/
static int
do_arm_lock(raw1394handle_t handle, struct raw1394_arm_request *arm_req,
nodeaddr_t a, quadlet_t *data)
{
quadlet_t *response = NULL;
int num, offset;
int rcode = RCODE_COMPLETE;
int requested_length = 4;
if (arm_req->extended_transaction_code == EXTCODE_COMPARE_SWAP)
{
quadlet_t arg_q, data_q, old_q, new_q;
/* allocate response packet */
num = 4 + requested_length;
response = malloc(num * sizeof(quadlet_t));
if (!response)
FAIL("unable to allocate response packet");
memset(response, 0x00, num * sizeof(quadlet_t));
/* load data */
offset = (arm_req->destination_offset - CSR_REGISTER_BASE - a)/4;
response[4] = htonl(data[offset]);
/* compare */
arg_q = *(quadlet_t *) (&arm_req->buffer[0]);
data_q = *(quadlet_t *) (&arm_req->buffer[4]);
old_q = *(quadlet_t *) (&response[4]);
new_q = (old_q == arg_q) ? data_q : old_q;
/* swap */
data[offset] = ntohl(new_q);
}
else
{
rcode = RCODE_TYPE_ERROR;
requested_length = 0;
}
/* fill data of response */
response[0] =
((arm_req->source_nodeid & 0xFFFF) << 16) +
((arm_req->tlabel & 0x3F) << 10) +
(0xB << 4); /* tcode = B */
response[1] =
((arm_req->destination_nodeid & 0xFFFF) << 16) +
((rcode & 0xF) << 12);
response[3] =
((requested_length & 0xFFFF) << 16) +
(arm_req->extended_transaction_code & 0xFF);
DEBUG(" response: 0x%8.8X",response[0]);
DEBUG(" 0x%8.8X",response[1]);
DEBUG(" 0x%8.8X",response[2]);
DEBUG(" 0x%8.8X",response[3]);
DEBUG(" 0x%8.8X",response[4]);
/* send response */
raw1394_start_async_send(handle, requested_length + 16, 16, 0, response, 0);
free (response);
return 0;
}
/* local plug ARM handler */
static int
iec61883_arm_callback (raw1394handle_t handle,
struct raw1394_arm_request_response *arm_req_resp,
unsigned int requested_length,
void *pcontext, byte_t request_type)
{
struct raw1394_arm_request *arm_req = arm_req_resp->request;
DEBUG( "request type=%d tcode=%d length=%d", request_type, arm_req->tcode, requested_length);
DEBUG( "context = %s", (char *) pcontext);
fflush(stdout);
if (pcontext == g_arm_callback_context_out && requested_length == 4)
{
if (request_type == RAW1394_ARM_READ && arm_req->tcode == 4)
{
do_arm_read( handle, arm_req, CSR_O_MPR, (quadlet_t *) &g_data_out );
}
else if (request_type == RAW1394_ARM_LOCK)
{
do_arm_lock( handle, arm_req, CSR_O_MPR, (quadlet_t *) &g_data_out );
}
else
{
/* error response */
}
}
else if (pcontext == g_arm_callback_context_in && requested_length == 4)
{
if (request_type == RAW1394_ARM_READ)
{
do_arm_read( handle, arm_req, CSR_I_MPR, (quadlet_t *) &g_data_in );
}
else if (request_type == RAW1394_ARM_LOCK)
{
do_arm_lock( handle, arm_req, CSR_I_MPR, (quadlet_t *) &g_data_in );
}
else
{
/* error response */
}
}
else
{
/* error response */
}
fflush(stdout);
return 0;
}
int
iec61883_plug_impr_init (raw1394handle_t h, unsigned int data_rate)
{
/* validate parameters */
if (data_rate >> 2 != 0)
errno = -EINVAL;
/* initialize data */
memset (&g_data_in, 0, sizeof (g_data_in));
g_data_in.mpr.data_rate = data_rate;
/* initialize host environment */
memset (&g_arm_reqhandle_in, 0, sizeof(g_arm_reqhandle_in));
g_arm_reqhandle_in.arm_callback = (arm_req_callback_t) iec61883_arm_callback;
g_arm_reqhandle_in.pcontext = g_arm_callback_context_in;
/* register callback */
return raw1394_arm_register( h, CSR_REGISTER_BASE + CSR_I_MPR, sizeof(g_data_in),
(byte_t *) &g_data_in, (unsigned long) &g_arm_reqhandle_in,
0, 0, ( RAW1394_ARM_READ | RAW1394_ARM_LOCK ) );
}
void
iec61883_plug_impr_clear (raw1394handle_t h)
{
g_data_in.mpr.n_plugs = 0;
}
int
iec61883_plug_impr_close (raw1394handle_t h)
{
g_data_in.mpr.n_plugs = 0;
return raw1394_arm_unregister(h, CSR_REGISTER_BASE + CSR_I_MPR);
}
int
iec61883_plug_ipcr_add (raw1394handle_t h, unsigned int online)
{
int i = g_data_in.mpr.n_plugs;
/* validate parameters */
if (g_arm_reqhandle_in.arm_callback == NULL)
return -EPERM;
if (i + 1 > IEC61883_PCR_MAX)
return -ENOSPC;
if (online >> 1 != 0)
return -EINVAL;
/* update data */
g_data_in.pcr[i].online = online;
g_data_in.mpr.n_plugs++;
/* return which plug is added */
return i;
}
int
iec61883_plug_ompr_init (raw1394handle_t h, unsigned int data_rate,
unsigned int bcast_channel)
{
/* validate parameters */
if (data_rate >> 2 != 0)
errno = -EINVAL;
if (bcast_channel >> 6 != 0)
errno = -EINVAL;
/* initialize data */
memset (&g_data_out, 0, sizeof (g_data_out));
g_data_out.mpr.data_rate = data_rate;
g_data_out.mpr.bcast_channel = bcast_channel;
/* initialize host environment */
memset (&g_arm_reqhandle_out, 0, sizeof(g_arm_reqhandle_out));
g_arm_reqhandle_out.arm_callback = (arm_req_callback_t) iec61883_arm_callback;
g_arm_reqhandle_out.pcontext = g_arm_callback_context_out;
/* register callback */
return raw1394_arm_register( h, CSR_REGISTER_BASE + CSR_O_MPR, sizeof(g_data_out),
(byte_t *) &g_data_out, (unsigned long) &g_arm_reqhandle_out,
0, 0, ( RAW1394_ARM_READ | RAW1394_ARM_LOCK ) );
}
void
iec61883_plug_ompr_clear (raw1394handle_t h)
{
g_data_out.mpr.n_plugs = 0;
}
int
iec61883_plug_ompr_close (raw1394handle_t h)
{
g_data_out.mpr.n_plugs = 0;
return raw1394_arm_unregister(h, CSR_REGISTER_BASE + CSR_O_MPR);
}
int
iec61883_plug_opcr_add (raw1394handle_t h, unsigned int online,
unsigned int overhead_id, unsigned int payload)
{
int i = g_data_out.mpr.n_plugs;
/* validate parameters */
if (g_arm_reqhandle_out.arm_callback == NULL)
return -EPERM;
if (i + 1 > IEC61883_PCR_MAX)
return -ENOSPC;
if (online >> 1 != 0)
return -EINVAL;
if (overhead_id >> 4 != 0)
return -EINVAL;
if (payload >> 10 != 0)
return -EINVAL;
/* update plug */
g_data_out.pcr[i].online = online;
g_data_out.pcr[i].overhead_id = overhead_id;
g_data_out.pcr[i].payload = payload;
/* increment the number of plugs available */
g_data_out.mpr.n_plugs++;
/* return which plug is added */
return i;
}