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