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