[deliverable/linux.git] / drivers / ieee1394 / ieee1394_transactions.c

/*
 * IEEE 1394 for Linux
 *
 * Transaction support.
 *
 * Copyright (C) 1999 Andreas E. Bombe
 *
 * This code is licensed under the GPL.  See the file COPYING in the root
 * directory of the kernel sources for details.
 */

#include <linux/bitops.h>
#include <linux/spinlock.h>
#include <linux/wait.h>

#include <asm/bug.h>
#include <asm/errno.h>

#include "ieee1394.h"
#include "ieee1394_types.h"
#include "hosts.h"
#include "ieee1394_core.h"
#include "ieee1394_transactions.h"

#define PREP_ASYNC_HEAD_ADDRESS(tc) \
        packet->tcode = tc; \
        packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
                | (1 << 8) | (tc << 4); \
        packet->header[1] = (packet->host->node_id << 16) | (addr >> 32); \
        packet->header[2] = addr & 0xffffffff

#ifndef HPSB_DEBUG_TLABELS
static
#endif
spinlock_t hpsb_tlabel_lock = SPIN_LOCK_UNLOCKED;

static DECLARE_WAIT_QUEUE_HEAD(tlabel_wq);

static void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
{
	PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ);
	packet->header_size = 12;
	packet->data_size = 0;
	packet->expect_response = 1;
}

static void fill_async_readblock(struct hpsb_packet *packet, u64 addr,
				 int length)
{
	PREP_ASYNC_HEAD_ADDRESS(TCODE_READB);
	packet->header[3] = length << 16;
	packet->header_size = 16;
	packet->data_size = 0;
	packet->expect_response = 1;
}

static void fill_async_writequad(struct hpsb_packet *packet, u64 addr,
				 quadlet_t data)
{
	PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ);
	packet->header[3] = data;
	packet->header_size = 16;
	packet->data_size = 0;
	packet->expect_response = 1;
}

static void fill_async_writeblock(struct hpsb_packet *packet, u64 addr,
				  int length)
{
	PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB);
	packet->header[3] = length << 16;
	packet->header_size = 16;
	packet->expect_response = 1;
	packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
}

static void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
			    int length)
{
	PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST);
	packet->header[3] = (length << 16) | extcode;
	packet->header_size = 16;
	packet->data_size = length;
	packet->expect_response = 1;
}

static void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
			    int tag, int sync)
{
	packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
	    | (TCODE_ISO_DATA << 4) | sync;

	packet->header_size = 4;
	packet->data_size = length;
	packet->type = hpsb_iso;
	packet->tcode = TCODE_ISO_DATA;
}

static void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
{
	packet->header[0] = data;
	packet->header[1] = ~data;
	packet->header_size = 8;
	packet->data_size = 0;
	packet->expect_response = 0;
	packet->type = hpsb_raw;	/* No CRC added */
	packet->speed_code = IEEE1394_SPEED_100;	/* Force speed to be 100Mbps */
}

static void fill_async_stream_packet(struct hpsb_packet *packet, int length,
				     int channel, int tag, int sync)
{
	packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
	    | (TCODE_STREAM_DATA << 4) | sync;

	packet->header_size = 4;
	packet->data_size = length;
	packet->type = hpsb_async;
	packet->tcode = TCODE_ISO_DATA;
}

/* same as hpsb_get_tlabel, except that it returns immediately */
static int hpsb_get_tlabel_atomic(struct hpsb_packet *packet)
{
	unsigned long flags, *tp;
	u8 *next;
	int tlabel, n = NODEID_TO_NODE(packet->node_id);

	/* Broadcast transactions are complete once the request has been sent.
	 * Use the same transaction label for all broadcast transactions. */
	if (unlikely(n == ALL_NODES)) {
		packet->tlabel = 0;
		return 0;
	}
	tp = packet->host->tl_pool[n].map;
	next = &packet->host->next_tl[n];

	spin_lock_irqsave(&hpsb_tlabel_lock, flags);
	tlabel = find_next_zero_bit(tp, 64, *next);
	if (tlabel > 63)
		tlabel = find_first_zero_bit(tp, 64);
	if (tlabel > 63) {
		spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
		return -EAGAIN;
	}
	__set_bit(tlabel, tp);
	*next = (tlabel + 1) & 63;
	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);

	packet->tlabel = tlabel;
	return 0;
}

/**
 * hpsb_get_tlabel - allocate a transaction label
 * @packet: the packet whose tlabel and tl_pool we set
 *
 * Every asynchronous transaction on the 1394 bus needs a transaction
 * label to match the response to the request.  This label has to be
 * different from any other transaction label in an outstanding request to
 * the same node to make matching possible without ambiguity.
 *
 * There are 64 different tlabels, so an allocated tlabel has to be freed
 * with hpsb_free_tlabel() after the transaction is complete (unless it's
 * reused again for the same target node).
 *
 * Return value: Zero on success, otherwise non-zero. A non-zero return
 * generally means there are no available tlabels. If this is called out
 * of interrupt or atomic context, then it will sleep until can return a
 * tlabel or a signal is received.
 */
int hpsb_get_tlabel(struct hpsb_packet *packet)
{
	if (irqs_disabled() || in_atomic())
		return hpsb_get_tlabel_atomic(packet);

	/* NB: The macro wait_event_interruptible() is called with a condition
	 * argument with side effect.  This is only possible because the side
	 * effect does not occur until the condition became true, and
	 * wait_event_interruptible() won't evaluate the condition again after
	 * that. */
	return wait_event_interruptible(tlabel_wq,
					!hpsb_get_tlabel_atomic(packet));
}

/**
 * hpsb_free_tlabel - free an allocated transaction label
 * @packet: packet whose tlabel and tl_pool needs to be cleared
 *
 * Frees the transaction label allocated with hpsb_get_tlabel().  The
 * tlabel has to be freed after the transaction is complete (i.e. response
 * was received for a split transaction or packet was sent for a unified
 * transaction).
 *
 * A tlabel must not be freed twice.
 */
void hpsb_free_tlabel(struct hpsb_packet *packet)
{
	unsigned long flags, *tp;
	int tlabel, n = NODEID_TO_NODE(packet->node_id);

	if (unlikely(n == ALL_NODES))
		return;
	tp = packet->host->tl_pool[n].map;
	tlabel = packet->tlabel;
	BUG_ON(tlabel > 63 || tlabel < 0);

	spin_lock_irqsave(&hpsb_tlabel_lock, flags);
	BUG_ON(!__test_and_clear_bit(tlabel, tp));
	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);

	wake_up_interruptible(&tlabel_wq);
}

int hpsb_packet_success(struct hpsb_packet *packet)
{
	switch (packet->ack_code) {
	case ACK_PENDING:
		switch ((packet->header[1] >> 12) & 0xf) {
		case RCODE_COMPLETE:
			return 0;
		case RCODE_CONFLICT_ERROR:
			return -EAGAIN;
		case RCODE_DATA_ERROR:
			return -EREMOTEIO;
		case RCODE_TYPE_ERROR:
			return -EACCES;
		case RCODE_ADDRESS_ERROR:
			return -EINVAL;
		default:
			HPSB_ERR("received reserved rcode %d from node %d",
				 (packet->header[1] >> 12) & 0xf,
				 packet->node_id);
			return -EAGAIN;
		}
		BUG();

	case ACK_BUSY_X:
	case ACK_BUSY_A:
	case ACK_BUSY_B:
		return -EBUSY;

	case ACK_TYPE_ERROR:
		return -EACCES;

	case ACK_COMPLETE:
		if (packet->tcode == TCODE_WRITEQ
		    || packet->tcode == TCODE_WRITEB) {
			return 0;
		} else {
			HPSB_ERR("impossible ack_complete from node %d "
				 "(tcode %d)", packet->node_id, packet->tcode);
			return -EAGAIN;
		}

	case ACK_DATA_ERROR:
		if (packet->tcode == TCODE_WRITEB
		    || packet->tcode == TCODE_LOCK_REQUEST) {
			return -EAGAIN;
		} else {
			HPSB_ERR("impossible ack_data_error from node %d "
				 "(tcode %d)", packet->node_id, packet->tcode);
			return -EAGAIN;
		}

	case ACK_ADDRESS_ERROR:
		return -EINVAL;

	case ACK_TARDY:
	case ACK_CONFLICT_ERROR:
	case ACKX_NONE:
	case ACKX_SEND_ERROR:
	case ACKX_ABORTED:
	case ACKX_TIMEOUT:
		/* error while sending */
		return -EAGAIN;

	default:
		HPSB_ERR("got invalid ack %d from node %d (tcode %d)",
			 packet->ack_code, packet->node_id, packet->tcode);
		return -EAGAIN;
	}
	BUG();
}

struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node,
					 u64 addr, size_t length)
{
	struct hpsb_packet *packet;

	if (length == 0)
		return NULL;

	packet = hpsb_alloc_packet(length);
	if (!packet)
		return NULL;

	packet->host = host;
	packet->node_id = node;

	if (hpsb_get_tlabel(packet)) {
		hpsb_free_packet(packet);
		return NULL;
	}

	if (length == 4)
		fill_async_readquad(packet, addr);
	else
		fill_async_readblock(packet, addr, length);

	return packet;
}

struct hpsb_packet *hpsb_make_writepacket(struct hpsb_host *host, nodeid_t node,
					  u64 addr, quadlet_t * buffer,
					  size_t length)
{
	struct hpsb_packet *packet;

	if (length == 0)
		return NULL;

	packet = hpsb_alloc_packet(length);
	if (!packet)
		return NULL;

	if (length % 4) {	/* zero padding bytes */
		packet->data[length >> 2] = 0;
	}
	packet->host = host;
	packet->node_id = node;

	if (hpsb_get_tlabel(packet)) {
		hpsb_free_packet(packet);
		return NULL;
	}

	if (length == 4) {
		fill_async_writequad(packet, addr, buffer ? *buffer : 0);
	} else {
		fill_async_writeblock(packet, addr, length);
		if (buffer)
			memcpy(packet->data, buffer, length);
	}

	return packet;
}

struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 * buffer,
					   int length, int channel, int tag,
					   int sync)
{
	struct hpsb_packet *packet;

	if (length == 0)
		return NULL;

	packet = hpsb_alloc_packet(length);
	if (!packet)
		return NULL;

	if (length % 4) {	/* zero padding bytes */
		packet->data[length >> 2] = 0;
	}
	packet->host = host;

	if (hpsb_get_tlabel(packet)) {
		hpsb_free_packet(packet);
		return NULL;
	}

	fill_async_stream_packet(packet, length, channel, tag, sync);
	if (buffer)
		memcpy(packet->data, buffer, length);

	return packet;
}

struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node,
					 u64 addr, int extcode,
					 quadlet_t * data, quadlet_t arg)
{
	struct hpsb_packet *p;
	u32 length;

	p = hpsb_alloc_packet(8);
	if (!p)
		return NULL;

	p->host = host;
	p->node_id = node;
	if (hpsb_get_tlabel(p)) {
		hpsb_free_packet(p);
		return NULL;
	}

	switch (extcode) {
	case EXTCODE_FETCH_ADD:
	case EXTCODE_LITTLE_ADD:
		length = 4;
		if (data)
			p->data[0] = *data;
		break;
	default:
		length = 8;
		if (data) {
			p->data[0] = arg;
			p->data[1] = *data;
		}
		break;
	}
	fill_async_lock(p, addr, extcode, length);

	return p;
}

struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host,
					   nodeid_t node, u64 addr, int extcode,
					   octlet_t * data, octlet_t arg)
{
	struct hpsb_packet *p;
	u32 length;

	p = hpsb_alloc_packet(16);
	if (!p)
		return NULL;

	p->host = host;
	p->node_id = node;
	if (hpsb_get_tlabel(p)) {
		hpsb_free_packet(p);
		return NULL;
	}

	switch (extcode) {
	case EXTCODE_FETCH_ADD:
	case EXTCODE_LITTLE_ADD:
		length = 8;
		if (data) {
			p->data[0] = *data >> 32;
			p->data[1] = *data & 0xffffffff;
		}
		break;
	default:
		length = 16;
		if (data) {
			p->data[0] = arg >> 32;
			p->data[1] = arg & 0xffffffff;
			p->data[2] = *data >> 32;
			p->data[3] = *data & 0xffffffff;
		}
		break;
	}
	fill_async_lock(p, addr, extcode, length);

	return p;
}

struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host, quadlet_t data)
{
	struct hpsb_packet *p;

	p = hpsb_alloc_packet(0);
	if (!p)
		return NULL;

	p->host = host;
	fill_phy_packet(p, data);

	return p;
}

struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host,
					int length, int channel,
					int tag, int sync)
{
	struct hpsb_packet *p;

	p = hpsb_alloc_packet(length);
	if (!p)
		return NULL;

	p->host = host;
	fill_iso_packet(p, length, channel, tag, sync);

	p->generation = get_hpsb_generation(host);

	return p;
}

/*
 * FIXME - these functions should probably read from / write to user space to
 * avoid in kernel buffers for user space callers
 */

int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation,
	      u64 addr, quadlet_t * buffer, size_t length)
{
	struct hpsb_packet *packet;
	int retval = 0;

	if (length == 0)
		return -EINVAL;

	BUG_ON(in_interrupt());	// We can't be called in an interrupt, yet

	packet = hpsb_make_readpacket(host, node, addr, length);

	if (!packet) {
		return -ENOMEM;
	}

	packet->generation = generation;
	retval = hpsb_send_packet_and_wait(packet);
	if (retval < 0)
		goto hpsb_read_fail;

	retval = hpsb_packet_success(packet);

	if (retval == 0) {
		if (length == 4) {
			*buffer = packet->header[3];
		} else {
			memcpy(buffer, packet->data, length);
		}
	}

      hpsb_read_fail:
	hpsb_free_tlabel(packet);
	hpsb_free_packet(packet);

	return retval;
}

int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
	       u64 addr, quadlet_t * buffer, size_t length)
{
	struct hpsb_packet *packet;
	int retval;

	if (length == 0)
		return -EINVAL;

	BUG_ON(in_interrupt());	// We can't be called in an interrupt, yet

	packet = hpsb_make_writepacket(host, node, addr, buffer, length);

	if (!packet)
		return -ENOMEM;

	packet->generation = generation;
	retval = hpsb_send_packet_and_wait(packet);
	if (retval < 0)
		goto hpsb_write_fail;

	retval = hpsb_packet_success(packet);

      hpsb_write_fail:
	hpsb_free_tlabel(packet);
	hpsb_free_packet(packet);

	return retval;
}

#if 0

int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
	      u64 addr, int extcode, quadlet_t * data, quadlet_t arg)
{
	struct hpsb_packet *packet;
	int retval = 0;

	BUG_ON(in_interrupt());	// We can't be called in an interrupt, yet

	packet = hpsb_make_lockpacket(host, node, addr, extcode, data, arg);
	if (!packet)
		return -ENOMEM;

	packet->generation = generation;
	retval = hpsb_send_packet_and_wait(packet);
	if (retval < 0)
		goto hpsb_lock_fail;

	retval = hpsb_packet_success(packet);

	if (retval == 0) {
		*data = packet->data[0];
	}

      hpsb_lock_fail:
	hpsb_free_tlabel(packet);
	hpsb_free_packet(packet);

	return retval;
}

int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation,
		   quadlet_t * buffer, size_t length, u32 specifier_id,
		   unsigned int version)
{
	struct hpsb_packet *packet;
	int retval = 0;
	u16 specifier_id_hi = (specifier_id & 0x00ffff00) >> 8;
	u8 specifier_id_lo = specifier_id & 0xff;

	HPSB_VERBOSE("Send GASP: channel = %d, length = %Zd", channel, length);

	length += 8;

	packet = hpsb_make_streampacket(host, NULL, length, channel, 3, 0);
	if (!packet)
		return -ENOMEM;

	packet->data[0] = cpu_to_be32((host->node_id << 16) | specifier_id_hi);
	packet->data[1] =
	    cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff));

	memcpy(&(packet->data[2]), buffer, length - 8);

	packet->generation = generation;

	packet->no_waiter = 1;

	retval = hpsb_send_packet(packet);
	if (retval < 0)
		hpsb_free_packet(packet);

	return retval;
}

#endif				/*  0  */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* IEEE 1394 for Linux
	3	*
	4	* Transaction support.
	5	*
	6	* Copyright (C) 1999 Andreas E. Bombe
	7	*
	8	* This code is licensed under the GPL. See the file COPYING in the root
	9	* directory of the kernel sources for details.
	10	*/
	11
1da177e4	12	#include <linux/bitops.h>
9951903e SR	13	#include <linux/spinlock.h>
9951903e SR	14	#include <linux/wait.h>
1da177e4	15
d83e7d8e	16	#include <asm/bug.h>
1da177e4 LT	17	#include <asm/errno.h>
	18
	19	#include "ieee1394.h"
	20	#include "ieee1394_types.h"
	21	#include "hosts.h"
	22	#include "ieee1394_core.h"
e27d3014	23	#include "ieee1394_transactions.h"
1da177e4	24
1da177e4 LT	25	#define PREP_ASYNC_HEAD_ADDRESS(tc) \
	26	packet->tcode = tc; \
	27	packet->header[0] = (packet->node_id << 16) \| (packet->tlabel << 10) \
	28	\| (1 << 8) \| (tc << 4); \
	29	packet->header[1] = (packet->host->node_id << 16) \| (addr >> 32); \
	30	packet->header[2] = addr & 0xffffffff
	31
9951903e SR	32	#ifndef HPSB_DEBUG_TLABELS
	33	static
	34	#endif
	35	spinlock_t hpsb_tlabel_lock = SPIN_LOCK_UNLOCKED;
	36
	37	static DECLARE_WAIT_QUEUE_HEAD(tlabel_wq);
	38
1da177e4 LT	39	static void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
1da177e4 LT	40	{
16c333a3 JMH	41	PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ);
	42	packet->header_size = 12;
	43	packet->data_size = 0;
	44	packet->expect_response = 1;
1da177e4 LT	45	}
1da177e4 LT	46
16c333a3 JMH	47	static void fill_async_readblock(struct hpsb_packet *packet, u64 addr,
16c333a3 JMH	48	int length)
1da177e4	49	{
16c333a3 JMH	50	PREP_ASYNC_HEAD_ADDRESS(TCODE_READB);
	51	packet->header[3] = length << 16;
	52	packet->header_size = 16;
	53	packet->data_size = 0;
	54	packet->expect_response = 1;
1da177e4 LT	55	}
1da177e4 LT	56
16c333a3 JMH	57	static void fill_async_writequad(struct hpsb_packet *packet, u64 addr,
16c333a3 JMH	58	quadlet_t data)
1da177e4	59	{
16c333a3 JMH	60	PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ);
	61	packet->header[3] = data;
	62	packet->header_size = 16;
	63	packet->data_size = 0;
	64	packet->expect_response = 1;
1da177e4 LT	65	}
1da177e4 LT	66
16c333a3 JMH	67	static void fill_async_writeblock(struct hpsb_packet *packet, u64 addr,
16c333a3 JMH	68	int length)
1da177e4	69	{
16c333a3 JMH	70	PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB);
	71	packet->header[3] = length << 16;
	72	packet->header_size = 16;
	73	packet->expect_response = 1;
	74	packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
1da177e4 LT	75	}
	76
	77	static void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
16c333a3	78	int length)
1da177e4	79	{
16c333a3 JMH	80	PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST);
	81	packet->header[3] = (length << 16) \| extcode;
	82	packet->header_size = 16;
	83	packet->data_size = length;
	84	packet->expect_response = 1;
1da177e4 LT	85	}
	86
	87	static void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
16c333a3	88	int tag, int sync)
1da177e4	89	{
16c333a3 JMH	90	packet->header[0] = (length << 16) \| (tag << 14) \| (channel << 8)
16c333a3 JMH	91	\| (TCODE_ISO_DATA << 4) \| sync;
1da177e4	92
16c333a3 JMH	93	packet->header_size = 4;
	94	packet->data_size = length;
	95	packet->type = hpsb_iso;
	96	packet->tcode = TCODE_ISO_DATA;
1da177e4 LT	97	}
	98
	99	static void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
	100	{
16c333a3 JMH	101	packet->header[0] = data;
	102	packet->header[1] = ~data;
	103	packet->header_size = 8;
	104	packet->data_size = 0;
	105	packet->expect_response = 0;
	106	packet->type = hpsb_raw; /* No CRC added */
	107	packet->speed_code = IEEE1394_SPEED_100; /* Force speed to be 100Mbps */
1da177e4 LT	108	}
	109
	110	static void fill_async_stream_packet(struct hpsb_packet *packet, int length,
	111	int channel, int tag, int sync)
	112	{
	113	packet->header[0] = (length << 16) \| (tag << 14) \| (channel << 8)
16c333a3	114	\| (TCODE_STREAM_DATA << 4) \| sync;
1da177e4 LT	115
	116	packet->header_size = 4;
	117	packet->data_size = length;
	118	packet->type = hpsb_async;
	119	packet->tcode = TCODE_ISO_DATA;
	120	}
	121
9951903e SR	122	/* same as hpsb_get_tlabel, except that it returns immediately */
	123	static int hpsb_get_tlabel_atomic(struct hpsb_packet *packet)
	124	{
	125	unsigned long flags, *tp;
	126	u8 *next;
	127	int tlabel, n = NODEID_TO_NODE(packet->node_id);
	128
	129	/* Broadcast transactions are complete once the request has been sent.
	130	* Use the same transaction label for all broadcast transactions. */
	131	if (unlikely(n == ALL_NODES)) {
	132	packet->tlabel = 0;
	133	return 0;
	134	}
	135	tp = packet->host->tl_pool[n].map;
	136	next = &packet->host->next_tl[n];
	137
	138	spin_lock_irqsave(&hpsb_tlabel_lock, flags);
	139	tlabel = find_next_zero_bit(tp, 64, *next);
	140	if (tlabel > 63)
	141	tlabel = find_first_zero_bit(tp, 64);
	142	if (tlabel > 63) {
	143	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
	144	return -EAGAIN;
	145	}
	146	__set_bit(tlabel, tp);
	147	*next = (tlabel + 1) & 63;
	148	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
	149
	150	packet->tlabel = tlabel;
	151	return 0;
	152	}
	153
1da177e4 LT	154	/**
1da177e4 LT	155	* hpsb_get_tlabel - allocate a transaction label
9951903e	156	* @packet: the packet whose tlabel and tl_pool we set
1da177e4 LT	157	*
	158	* Every asynchronous transaction on the 1394 bus needs a transaction
	159	* label to match the response to the request. This label has to be
	160	* different from any other transaction label in an outstanding request to
	161	* the same node to make matching possible without ambiguity.
	162	*
	163	* There are 64 different tlabels, so an allocated tlabel has to be freed
	164	* with hpsb_free_tlabel() after the transaction is complete (unless it's
	165	* reused again for the same target node).
	166	*
	167	* Return value: Zero on success, otherwise non-zero. A non-zero return
	168	* generally means there are no available tlabels. If this is called out
	169	* of interrupt or atomic context, then it will sleep until can return a
9951903e	170	* tlabel or a signal is received.
1da177e4 LT	171	*/
	172	int hpsb_get_tlabel(struct hpsb_packet *packet)
	173	{
9951903e SR	174	if (irqs_disabled() \|\| in_atomic())
	175	return hpsb_get_tlabel_atomic(packet);
	176
	177	/* NB: The macro wait_event_interruptible() is called with a condition
	178	* argument with side effect. This is only possible because the side
	179	* effect does not occur until the condition became true, and
	180	* wait_event_interruptible() won't evaluate the condition again after
	181	* that. */
	182	return wait_event_interruptible(tlabel_wq,
	183	!hpsb_get_tlabel_atomic(packet));
1da177e4 LT	184	}
	185
	186	/**
	187	* hpsb_free_tlabel - free an allocated transaction label
9951903e	188	* @packet: packet whose tlabel and tl_pool needs to be cleared
1da177e4 LT	189	*
	190	* Frees the transaction label allocated with hpsb_get_tlabel(). The
	191	* tlabel has to be freed after the transaction is complete (i.e. response
	192	* was received for a split transaction or packet was sent for a unified
	193	* transaction).
	194	*
	195	* A tlabel must not be freed twice.
	196	*/
	197	void hpsb_free_tlabel(struct hpsb_packet *packet)
	198	{
9951903e SR	199	unsigned long flags, *tp;
9951903e SR	200	int tlabel, n = NODEID_TO_NODE(packet->node_id);
1da177e4	201
eaf88450 BC	202	if (unlikely(n == ALL_NODES))
eaf88450 BC	203	return;
9951903e SR	204	tp = packet->host->tl_pool[n].map;
	205	tlabel = packet->tlabel;
	206	BUG_ON(tlabel > 63 \|\| tlabel < 0);
1da177e4	207
9951903e SR	208	spin_lock_irqsave(&hpsb_tlabel_lock, flags);
	209	BUG_ON(!__test_and_clear_bit(tlabel, tp));
	210	spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
1da177e4	211
9951903e	212	wake_up_interruptible(&tlabel_wq);
1da177e4 LT	213	}
1da177e4 LT	214
1da177e4 LT	215	int hpsb_packet_success(struct hpsb_packet *packet)
1da177e4 LT	216	{
16c333a3 JMH	217	switch (packet->ack_code) {
	218	case ACK_PENDING:
	219	switch ((packet->header[1] >> 12) & 0xf) {
	220	case RCODE_COMPLETE:
	221	return 0;
	222	case RCODE_CONFLICT_ERROR:
	223	return -EAGAIN;
	224	case RCODE_DATA_ERROR:
	225	return -EREMOTEIO;
	226	case RCODE_TYPE_ERROR:
	227	return -EACCES;
	228	case RCODE_ADDRESS_ERROR:
	229	return -EINVAL;
	230	default:
	231	HPSB_ERR("received reserved rcode %d from node %d",
	232	(packet->header[1] >> 12) & 0xf,
	233	packet->node_id);
	234	return -EAGAIN;
	235	}
d83e7d8e	236	BUG();
16c333a3 JMH	237
	238	case ACK_BUSY_X:
	239	case ACK_BUSY_A:
	240	case ACK_BUSY_B:
	241	return -EBUSY;
	242
	243	case ACK_TYPE_ERROR:
	244	return -EACCES;
	245
	246	case ACK_COMPLETE:
	247	if (packet->tcode == TCODE_WRITEQ
	248	\|\| packet->tcode == TCODE_WRITEB) {
	249	return 0;
	250	} else {
	251	HPSB_ERR("impossible ack_complete from node %d "
	252	"(tcode %d)", packet->node_id, packet->tcode);
	253	return -EAGAIN;
	254	}
	255
	256	case ACK_DATA_ERROR:
	257	if (packet->tcode == TCODE_WRITEB
	258	\|\| packet->tcode == TCODE_LOCK_REQUEST) {
	259	return -EAGAIN;
	260	} else {
	261	HPSB_ERR("impossible ack_data_error from node %d "
	262	"(tcode %d)", packet->node_id, packet->tcode);
	263	return -EAGAIN;
	264	}
	265
	266	case ACK_ADDRESS_ERROR:
	267	return -EINVAL;
	268
	269	case ACK_TARDY:
	270	case ACK_CONFLICT_ERROR:
	271	case ACKX_NONE:
	272	case ACKX_SEND_ERROR:
	273	case ACKX_ABORTED:
	274	case ACKX_TIMEOUT:
	275	/* error while sending */
	276	return -EAGAIN;
	277
	278	default:
	279	HPSB_ERR("got invalid ack %d from node %d (tcode %d)",
	280	packet->ack_code, packet->node_id, packet->tcode);
	281	return -EAGAIN;
	282	}
d83e7d8e	283	BUG();
1da177e4 LT	284	}
	285
	286	struct hpsb_packet hpsb_make_readpacket(struct hpsb_host host, nodeid_t node,
	287	u64 addr, size_t length)
	288	{
16c333a3	289	struct hpsb_packet *packet;
1da177e4 LT	290
	291	if (length == 0)
	292	return NULL;
	293
	294	packet = hpsb_alloc_packet(length);
	295	if (!packet)
	296	return NULL;
	297
	298	packet->host = host;
	299	packet->node_id = node;
	300
	301	if (hpsb_get_tlabel(packet)) {
	302	hpsb_free_packet(packet);
	303	return NULL;
	304	}
	305
	306	if (length == 4)
	307	fill_async_readquad(packet, addr);
	308	else
	309	fill_async_readblock(packet, addr, length);
	310
	311	return packet;
	312	}
	313
16c333a3 JMH	314	struct hpsb_packet hpsb_make_writepacket(struct hpsb_host host, nodeid_t node,
	315	u64 addr, quadlet_t * buffer,
	316	size_t length)
1da177e4 LT	317	{
	318	struct hpsb_packet *packet;
	319
	320	if (length == 0)
	321	return NULL;
	322
	323	packet = hpsb_alloc_packet(length);
	324	if (!packet)
	325	return NULL;
	326
16c333a3	327	if (length % 4) { /* zero padding bytes */
1da177e4 LT	328	packet->data[length >> 2] = 0;
	329	}
	330	packet->host = host;
	331	packet->node_id = node;
	332
	333	if (hpsb_get_tlabel(packet)) {
	334	hpsb_free_packet(packet);
	335	return NULL;
	336	}
	337
	338	if (length == 4) {
	339	fill_async_writequad(packet, addr, buffer ? *buffer : 0);
	340	} else {
	341	fill_async_writeblock(packet, addr, length);
	342	if (buffer)
	343	memcpy(packet->data, buffer, length);
	344	}
	345
	346	return packet;
	347	}
	348
16c333a3 JMH	349	struct hpsb_packet hpsb_make_streampacket(struct hpsb_host host, u8 * buffer,
	350	int length, int channel, int tag,
	351	int sync)
1da177e4 LT	352	{
	353	struct hpsb_packet *packet;
	354
	355	if (length == 0)
	356	return NULL;
	357
	358	packet = hpsb_alloc_packet(length);
	359	if (!packet)
	360	return NULL;
	361
16c333a3	362	if (length % 4) { /* zero padding bytes */
1da177e4 LT	363	packet->data[length >> 2] = 0;
	364	}
	365	packet->host = host;
	366
	367	if (hpsb_get_tlabel(packet)) {
	368	hpsb_free_packet(packet);
	369	return NULL;
	370	}
	371
	372	fill_async_stream_packet(packet, length, channel, tag, sync);
	373	if (buffer)
	374	memcpy(packet->data, buffer, length);
	375
	376	return packet;
	377	}
	378
	379	struct hpsb_packet hpsb_make_lockpacket(struct hpsb_host host, nodeid_t node,
16c333a3 JMH	380	u64 addr, int extcode,
16c333a3 JMH	381	quadlet_t * data, quadlet_t arg)
1da177e4 LT	382	{
	383	struct hpsb_packet *p;
	384	u32 length;
	385
	386	p = hpsb_alloc_packet(8);
16c333a3 JMH	387	if (!p)
16c333a3 JMH	388	return NULL;
1da177e4 LT	389
	390	p->host = host;
	391	p->node_id = node;
	392	if (hpsb_get_tlabel(p)) {
	393	hpsb_free_packet(p);
	394	return NULL;
	395	}
	396
	397	switch (extcode) {
	398	case EXTCODE_FETCH_ADD:
	399	case EXTCODE_LITTLE_ADD:
	400	length = 4;
	401	if (data)
	402	p->data[0] = *data;
	403	break;
	404	default:
	405	length = 8;
	406	if (data) {
	407	p->data[0] = arg;
	408	p->data[1] = *data;
	409	}
	410	break;
	411	}
	412	fill_async_lock(p, addr, extcode, length);
	413
	414	return p;
	415	}
	416
16c333a3 JMH	417	struct hpsb_packet hpsb_make_lock64packet(struct hpsb_host host,
	418	nodeid_t node, u64 addr, int extcode,
	419	octlet_t * data, octlet_t arg)
1da177e4 LT	420	{
	421	struct hpsb_packet *p;
	422	u32 length;
	423
	424	p = hpsb_alloc_packet(16);
16c333a3 JMH	425	if (!p)
16c333a3 JMH	426	return NULL;
1da177e4 LT	427
	428	p->host = host;
	429	p->node_id = node;
	430	if (hpsb_get_tlabel(p)) {
	431	hpsb_free_packet(p);
	432	return NULL;
	433	}
	434
	435	switch (extcode) {
	436	case EXTCODE_FETCH_ADD:
	437	case EXTCODE_LITTLE_ADD:
	438	length = 8;
	439	if (data) {
	440	p->data[0] = *data >> 32;
	441	p->data[1] = *data & 0xffffffff;
	442	}
	443	break;
	444	default:
	445	length = 16;
	446	if (data) {
	447	p->data[0] = arg >> 32;
	448	p->data[1] = arg & 0xffffffff;
	449	p->data[2] = *data >> 32;
	450	p->data[3] = *data & 0xffffffff;
	451	}
	452	break;
	453	}
	454	fill_async_lock(p, addr, extcode, length);
	455
	456	return p;
	457	}
	458
16c333a3	459	struct hpsb_packet hpsb_make_phypacket(struct hpsb_host host, quadlet_t data)
1da177e4	460	{
16c333a3	461	struct hpsb_packet *p;
1da177e4	462
16c333a3 JMH	463	p = hpsb_alloc_packet(0);
	464	if (!p)
	465	return NULL;
1da177e4	466
16c333a3 JMH	467	p->host = host;
16c333a3 JMH	468	fill_phy_packet(p, data);
1da177e4	469
16c333a3	470	return p;
1da177e4 LT	471	}
	472
	473	struct hpsb_packet hpsb_make_isopacket(struct hpsb_host host,
	474	int length, int channel,
	475	int tag, int sync)
	476	{
	477	struct hpsb_packet *p;
	478
	479	p = hpsb_alloc_packet(length);
16c333a3 JMH	480	if (!p)
16c333a3 JMH	481	return NULL;
1da177e4 LT	482
	483	p->host = host;
	484	fill_iso_packet(p, length, channel, tag, sync);
	485
	486	p->generation = get_hpsb_generation(host);
	487
	488	return p;
	489	}
	490
	491	/*
	492	* FIXME - these functions should probably read from / write to user space to
	493	* avoid in kernel buffers for user space callers
	494	*/
	495
	496	int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation,
16c333a3	497	u64 addr, quadlet_t * buffer, size_t length)
1da177e4	498	{
16c333a3 JMH	499	struct hpsb_packet *packet;
16c333a3 JMH	500	int retval = 0;
1da177e4	501
16c333a3 JMH	502	if (length == 0)
16c333a3 JMH	503	return -EINVAL;
1da177e4	504
16c333a3	505	BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
1da177e4 LT	506
	507	packet = hpsb_make_readpacket(host, node, addr, length);
	508
16c333a3 JMH	509	if (!packet) {
	510	return -ENOMEM;
	511	}
1da177e4 LT	512
1da177e4 LT	513	packet->generation = generation;
16c333a3	514	retval = hpsb_send_packet_and_wait(packet);
1da177e4 LT	515	if (retval < 0)
	516	goto hpsb_read_fail;
	517
16c333a3	518	retval = hpsb_packet_success(packet);
1da177e4	519
16c333a3 JMH	520	if (retval == 0) {
	521	if (length == 4) {
	522	*buffer = packet->header[3];
	523	} else {
	524	memcpy(buffer, packet->data, length);
	525	}
	526	}
1da177e4	527
16c333a3 JMH	528	hpsb_read_fail:
	529	hpsb_free_tlabel(packet);
	530	hpsb_free_packet(packet);
1da177e4	531
16c333a3	532	return retval;
1da177e4 LT	533	}
1da177e4 LT	534
1da177e4	535	int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
16c333a3	536	u64 addr, quadlet_t * buffer, size_t length)
1da177e4 LT	537	{
	538	struct hpsb_packet *packet;
	539	int retval;
	540
	541	if (length == 0)
	542	return -EINVAL;
	543
16c333a3	544	BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
1da177e4	545
16c333a3	546	packet = hpsb_make_writepacket(host, node, addr, buffer, length);
1da177e4 LT	547
	548	if (!packet)
	549	return -ENOMEM;
	550
	551	packet->generation = generation;
16c333a3	552	retval = hpsb_send_packet_and_wait(packet);
1da177e4 LT	553	if (retval < 0)
	554	goto hpsb_write_fail;
	555
16c333a3	556	retval = hpsb_packet_success(packet);
1da177e4	557
16c333a3 JMH	558	hpsb_write_fail:
	559	hpsb_free_tlabel(packet);
	560	hpsb_free_packet(packet);
1da177e4	561
16c333a3	562	return retval;
1da177e4 LT	563	}
1da177e4 LT	564
9ac485dc	565	#if 0
1da177e4 LT	566
1da177e4 LT	567	int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
16c333a3	568	u64 addr, int extcode, quadlet_t * data, quadlet_t arg)
1da177e4	569	{
16c333a3 JMH	570	struct hpsb_packet *packet;
16c333a3 JMH	571	int retval = 0;
1da177e4	572
16c333a3	573	BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
1da177e4 LT	574
1da177e4 LT	575	packet = hpsb_make_lockpacket(host, node, addr, extcode, data, arg);
16c333a3 JMH	576	if (!packet)
16c333a3 JMH	577	return -ENOMEM;
1da177e4 LT	578
1da177e4 LT	579	packet->generation = generation;
16c333a3	580	retval = hpsb_send_packet_and_wait(packet);
1da177e4 LT	581	if (retval < 0)
	582	goto hpsb_lock_fail;
	583
16c333a3	584	retval = hpsb_packet_success(packet);
1da177e4	585
16c333a3 JMH	586	if (retval == 0) {
	587	*data = packet->data[0];
	588	}
1da177e4	589
16c333a3 JMH	590	hpsb_lock_fail:
	591	hpsb_free_tlabel(packet);
	592	hpsb_free_packet(packet);
1da177e4	593
16c333a3	594	return retval;
1da177e4 LT	595	}
1da177e4 LT	596
1da177e4	597	int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation,
16c333a3	598	quadlet_t * buffer, size_t length, u32 specifier_id,
1da177e4 LT	599	unsigned int version)
	600	{
	601	struct hpsb_packet *packet;
	602	int retval = 0;
	603	u16 specifier_id_hi = (specifier_id & 0x00ffff00) >> 8;
	604	u8 specifier_id_lo = specifier_id & 0xff;
	605
	606	HPSB_VERBOSE("Send GASP: channel = %d, length = %Zd", channel, length);
	607
	608	length += 8;
	609
	610	packet = hpsb_make_streampacket(host, NULL, length, channel, 3, 0);
	611	if (!packet)
	612	return -ENOMEM;
	613
	614	packet->data[0] = cpu_to_be32((host->node_id << 16) \| specifier_id_hi);
16c333a3 JMH	615	packet->data[1] =
16c333a3 JMH	616	cpu_to_be32((specifier_id_lo << 24) \| (version & 0x00ffffff));
1da177e4 LT	617
	618	memcpy(&(packet->data[2]), buffer, length - 8);
	619
	620	packet->generation = generation;
	621
	622	packet->no_waiter = 1;
	623
	624	retval = hpsb_send_packet(packet);
	625	if (retval < 0)
	626	hpsb_free_packet(packet);
	627
	628	return retval;
	629	}
9ac485dc	630
16c333a3	631	#endif /* 0 */