ieee1394: eth1394: some conditions are unlikely
[linux-2.6.git] / drivers / ieee1394 / ieee1394_transactions.c
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
38 static
39 #endif
40 DEFINE_SPINLOCK(hpsb_tlabel_lock);
41
42 static DECLARE_WAIT_QUEUE_HEAD(tlabel_wq);
43
44 static 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
52 static 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
62 static 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
72 static 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
82 static 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
92 static 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
104 static 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
115 static 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 */
128 static 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  */
177 int 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  */
202 void 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  */
229 int 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
300 struct 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
328 struct 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
363 struct 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
400 struct 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
438 struct 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
480 struct 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
494 struct 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  * FIXME - these functions should probably read from / write to user space to
514  * avoid in kernel buffers for user space callers
515  */
516
517 /**
518  * hpsb_read - generic read function
519  *
520  * Recognizes the local node ID and act accordingly.  Automatically uses a
521  * quadlet read request if @length == 4 and and a block read request otherwise.
522  * It does not yet support lengths that are not a multiple of 4.
523  *
524  * You must explicitly specifiy the @generation for which the node ID is valid,
525  * to avoid sending packets to the wrong nodes when we race with a bus reset.
526  */
527 int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation,
528               u64 addr, quadlet_t * buffer, size_t length)
529 {
530         struct hpsb_packet *packet;
531         int retval = 0;
532
533         if (length == 0)
534                 return -EINVAL;
535
536         BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
537
538         packet = hpsb_make_readpacket(host, node, addr, length);
539
540         if (!packet) {
541                 return -ENOMEM;
542         }
543
544         packet->generation = generation;
545         retval = hpsb_send_packet_and_wait(packet);
546         if (retval < 0)
547                 goto hpsb_read_fail;
548
549         retval = hpsb_packet_success(packet);
550
551         if (retval == 0) {
552                 if (length == 4) {
553                         *buffer = packet->header[3];
554                 } else {
555                         memcpy(buffer, packet->data, length);
556                 }
557         }
558
559       hpsb_read_fail:
560         hpsb_free_tlabel(packet);
561         hpsb_free_packet(packet);
562
563         return retval;
564 }
565
566 /**
567  * hpsb_write - generic write function
568  *
569  * Recognizes the local node ID and act accordingly.  Automatically uses a
570  * quadlet write request if @length == 4 and and a block write request
571  * otherwise.  It does not yet support lengths that are not a multiple of 4.
572  *
573  * You must explicitly specifiy the @generation for which the node ID is valid,
574  * to avoid sending packets to the wrong nodes when we race with a bus reset.
575  */
576 int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
577                u64 addr, quadlet_t * buffer, size_t length)
578 {
579         struct hpsb_packet *packet;
580         int retval;
581
582         if (length == 0)
583                 return -EINVAL;
584
585         BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
586
587         packet = hpsb_make_writepacket(host, node, addr, buffer, length);
588
589         if (!packet)
590                 return -ENOMEM;
591
592         packet->generation = generation;
593         retval = hpsb_send_packet_and_wait(packet);
594         if (retval < 0)
595                 goto hpsb_write_fail;
596
597         retval = hpsb_packet_success(packet);
598
599       hpsb_write_fail:
600         hpsb_free_tlabel(packet);
601         hpsb_free_packet(packet);
602
603         return retval;
604 }
605
606 #if 0
607
608 int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
609               u64 addr, int extcode, quadlet_t * data, quadlet_t arg)
610 {
611         struct hpsb_packet *packet;
612         int retval = 0;
613
614         BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
615
616         packet = hpsb_make_lockpacket(host, node, addr, extcode, data, arg);
617         if (!packet)
618                 return -ENOMEM;
619
620         packet->generation = generation;
621         retval = hpsb_send_packet_and_wait(packet);
622         if (retval < 0)
623                 goto hpsb_lock_fail;
624
625         retval = hpsb_packet_success(packet);
626
627         if (retval == 0) {
628                 *data = packet->data[0];
629         }
630
631       hpsb_lock_fail:
632         hpsb_free_tlabel(packet);
633         hpsb_free_packet(packet);
634
635         return retval;
636 }
637
638 int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation,
639                    quadlet_t * buffer, size_t length, u32 specifier_id,
640                    unsigned int version)
641 {
642         struct hpsb_packet *packet;
643         int retval = 0;
644         u16 specifier_id_hi = (specifier_id & 0x00ffff00) >> 8;
645         u8 specifier_id_lo = specifier_id & 0xff;
646
647         HPSB_VERBOSE("Send GASP: channel = %d, length = %Zd", channel, length);
648
649         length += 8;
650
651         packet = hpsb_make_streampacket(host, NULL, length, channel, 3, 0);
652         if (!packet)
653                 return -ENOMEM;
654
655         packet->data[0] = cpu_to_be32((host->node_id << 16) | specifier_id_hi);
656         packet->data[1] =
657             cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff));
658
659         memcpy(&(packet->data[2]), buffer, length - 8);
660
661         packet->generation = generation;
662
663         packet->no_waiter = 1;
664
665         retval = hpsb_send_packet(packet);
666         if (retval < 0)
667                 hpsb_free_packet(packet);
668
669         return retval;
670 }
671
672 #endif                          /*  0  */