ia64/linux-2.6.18-xen.hg

view drivers/ieee1394/ieee1394_transactions.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
12 #include <linux/sched.h>
13 #include <linux/bitops.h>
14 #include <linux/smp_lock.h>
15 #include <linux/interrupt.h>
17 #include <asm/errno.h>
19 #include "ieee1394.h"
20 #include "ieee1394_types.h"
21 #include "hosts.h"
22 #include "ieee1394_core.h"
23 #include "highlevel.h"
24 #include "nodemgr.h"
25 #include "ieee1394_transactions.h"
27 #define PREP_ASYNC_HEAD_ADDRESS(tc) \
28 packet->tcode = tc; \
29 packet->header[0] = (packet->node_id << 16) | (packet->tlabel << 10) \
30 | (1 << 8) | (tc << 4); \
31 packet->header[1] = (packet->host->node_id << 16) | (addr >> 32); \
32 packet->header[2] = addr & 0xffffffff
34 static void fill_async_readquad(struct hpsb_packet *packet, u64 addr)
35 {
36 PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ);
37 packet->header_size = 12;
38 packet->data_size = 0;
39 packet->expect_response = 1;
40 }
42 static void fill_async_readblock(struct hpsb_packet *packet, u64 addr,
43 int length)
44 {
45 PREP_ASYNC_HEAD_ADDRESS(TCODE_READB);
46 packet->header[3] = length << 16;
47 packet->header_size = 16;
48 packet->data_size = 0;
49 packet->expect_response = 1;
50 }
52 static void fill_async_writequad(struct hpsb_packet *packet, u64 addr,
53 quadlet_t data)
54 {
55 PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ);
56 packet->header[3] = data;
57 packet->header_size = 16;
58 packet->data_size = 0;
59 packet->expect_response = 1;
60 }
62 static void fill_async_writeblock(struct hpsb_packet *packet, u64 addr,
63 int length)
64 {
65 PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB);
66 packet->header[3] = length << 16;
67 packet->header_size = 16;
68 packet->expect_response = 1;
69 packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0);
70 }
72 static void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode,
73 int length)
74 {
75 PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST);
76 packet->header[3] = (length << 16) | extcode;
77 packet->header_size = 16;
78 packet->data_size = length;
79 packet->expect_response = 1;
80 }
82 static void fill_iso_packet(struct hpsb_packet *packet, int length, int channel,
83 int tag, int sync)
84 {
85 packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
86 | (TCODE_ISO_DATA << 4) | sync;
88 packet->header_size = 4;
89 packet->data_size = length;
90 packet->type = hpsb_iso;
91 packet->tcode = TCODE_ISO_DATA;
92 }
94 static void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data)
95 {
96 packet->header[0] = data;
97 packet->header[1] = ~data;
98 packet->header_size = 8;
99 packet->data_size = 0;
100 packet->expect_response = 0;
101 packet->type = hpsb_raw; /* No CRC added */
102 packet->speed_code = IEEE1394_SPEED_100; /* Force speed to be 100Mbps */
103 }
105 static void fill_async_stream_packet(struct hpsb_packet *packet, int length,
106 int channel, int tag, int sync)
107 {
108 packet->header[0] = (length << 16) | (tag << 14) | (channel << 8)
109 | (TCODE_STREAM_DATA << 4) | sync;
111 packet->header_size = 4;
112 packet->data_size = length;
113 packet->type = hpsb_async;
114 packet->tcode = TCODE_ISO_DATA;
115 }
117 /**
118 * hpsb_get_tlabel - allocate a transaction label
119 * @packet: the packet who's tlabel/tpool we set
120 *
121 * Every asynchronous transaction on the 1394 bus needs a transaction
122 * label to match the response to the request. This label has to be
123 * different from any other transaction label in an outstanding request to
124 * the same node to make matching possible without ambiguity.
125 *
126 * There are 64 different tlabels, so an allocated tlabel has to be freed
127 * with hpsb_free_tlabel() after the transaction is complete (unless it's
128 * reused again for the same target node).
129 *
130 * Return value: Zero on success, otherwise non-zero. A non-zero return
131 * generally means there are no available tlabels. If this is called out
132 * of interrupt or atomic context, then it will sleep until can return a
133 * tlabel.
134 */
135 int hpsb_get_tlabel(struct hpsb_packet *packet)
136 {
137 unsigned long flags;
138 struct hpsb_tlabel_pool *tp;
139 int n = NODEID_TO_NODE(packet->node_id);
141 if (unlikely(n == ALL_NODES))
142 return 0;
143 tp = &packet->host->tpool[n];
145 if (irqs_disabled() || in_atomic()) {
146 if (down_trylock(&tp->count))
147 return 1;
148 } else {
149 down(&tp->count);
150 }
152 spin_lock_irqsave(&tp->lock, flags);
154 packet->tlabel = find_next_zero_bit(tp->pool, 64, tp->next);
155 if (packet->tlabel > 63)
156 packet->tlabel = find_first_zero_bit(tp->pool, 64);
157 tp->next = (packet->tlabel + 1) % 64;
158 /* Should _never_ happen */
159 BUG_ON(test_and_set_bit(packet->tlabel, tp->pool));
160 tp->allocations++;
161 spin_unlock_irqrestore(&tp->lock, flags);
163 return 0;
164 }
166 /**
167 * hpsb_free_tlabel - free an allocated transaction label
168 * @packet: packet whos tlabel/tpool needs to be cleared
169 *
170 * Frees the transaction label allocated with hpsb_get_tlabel(). The
171 * tlabel has to be freed after the transaction is complete (i.e. response
172 * was received for a split transaction or packet was sent for a unified
173 * transaction).
174 *
175 * A tlabel must not be freed twice.
176 */
177 void hpsb_free_tlabel(struct hpsb_packet *packet)
178 {
179 unsigned long flags;
180 struct hpsb_tlabel_pool *tp;
181 int n = NODEID_TO_NODE(packet->node_id);
183 if (unlikely(n == ALL_NODES))
184 return;
185 tp = &packet->host->tpool[n];
187 BUG_ON(packet->tlabel > 63 || packet->tlabel < 0);
189 spin_lock_irqsave(&tp->lock, flags);
190 BUG_ON(!test_and_clear_bit(packet->tlabel, tp->pool));
191 spin_unlock_irqrestore(&tp->lock, flags);
193 up(&tp->count);
194 }
196 int hpsb_packet_success(struct hpsb_packet *packet)
197 {
198 switch (packet->ack_code) {
199 case ACK_PENDING:
200 switch ((packet->header[1] >> 12) & 0xf) {
201 case RCODE_COMPLETE:
202 return 0;
203 case RCODE_CONFLICT_ERROR:
204 return -EAGAIN;
205 case RCODE_DATA_ERROR:
206 return -EREMOTEIO;
207 case RCODE_TYPE_ERROR:
208 return -EACCES;
209 case RCODE_ADDRESS_ERROR:
210 return -EINVAL;
211 default:
212 HPSB_ERR("received reserved rcode %d from node %d",
213 (packet->header[1] >> 12) & 0xf,
214 packet->node_id);
215 return -EAGAIN;
216 }
217 HPSB_PANIC("reached unreachable code 1 in %s", __FUNCTION__);
219 case ACK_BUSY_X:
220 case ACK_BUSY_A:
221 case ACK_BUSY_B:
222 return -EBUSY;
224 case ACK_TYPE_ERROR:
225 return -EACCES;
227 case ACK_COMPLETE:
228 if (packet->tcode == TCODE_WRITEQ
229 || packet->tcode == TCODE_WRITEB) {
230 return 0;
231 } else {
232 HPSB_ERR("impossible ack_complete from node %d "
233 "(tcode %d)", packet->node_id, packet->tcode);
234 return -EAGAIN;
235 }
237 case ACK_DATA_ERROR:
238 if (packet->tcode == TCODE_WRITEB
239 || packet->tcode == TCODE_LOCK_REQUEST) {
240 return -EAGAIN;
241 } else {
242 HPSB_ERR("impossible ack_data_error from node %d "
243 "(tcode %d)", packet->node_id, packet->tcode);
244 return -EAGAIN;
245 }
247 case ACK_ADDRESS_ERROR:
248 return -EINVAL;
250 case ACK_TARDY:
251 case ACK_CONFLICT_ERROR:
252 case ACKX_NONE:
253 case ACKX_SEND_ERROR:
254 case ACKX_ABORTED:
255 case ACKX_TIMEOUT:
256 /* error while sending */
257 return -EAGAIN;
259 default:
260 HPSB_ERR("got invalid ack %d from node %d (tcode %d)",
261 packet->ack_code, packet->node_id, packet->tcode);
262 return -EAGAIN;
263 }
265 HPSB_PANIC("reached unreachable code 2 in %s", __FUNCTION__);
266 }
268 struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node,
269 u64 addr, size_t length)
270 {
271 struct hpsb_packet *packet;
273 if (length == 0)
274 return NULL;
276 packet = hpsb_alloc_packet(length);
277 if (!packet)
278 return NULL;
280 packet->host = host;
281 packet->node_id = node;
283 if (hpsb_get_tlabel(packet)) {
284 hpsb_free_packet(packet);
285 return NULL;
286 }
288 if (length == 4)
289 fill_async_readquad(packet, addr);
290 else
291 fill_async_readblock(packet, addr, length);
293 return packet;
294 }
296 struct hpsb_packet *hpsb_make_writepacket(struct hpsb_host *host, nodeid_t node,
297 u64 addr, quadlet_t * buffer,
298 size_t length)
299 {
300 struct hpsb_packet *packet;
302 if (length == 0)
303 return NULL;
305 packet = hpsb_alloc_packet(length);
306 if (!packet)
307 return NULL;
309 if (length % 4) { /* zero padding bytes */
310 packet->data[length >> 2] = 0;
311 }
312 packet->host = host;
313 packet->node_id = node;
315 if (hpsb_get_tlabel(packet)) {
316 hpsb_free_packet(packet);
317 return NULL;
318 }
320 if (length == 4) {
321 fill_async_writequad(packet, addr, buffer ? *buffer : 0);
322 } else {
323 fill_async_writeblock(packet, addr, length);
324 if (buffer)
325 memcpy(packet->data, buffer, length);
326 }
328 return packet;
329 }
331 struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 * buffer,
332 int length, int channel, int tag,
333 int sync)
334 {
335 struct hpsb_packet *packet;
337 if (length == 0)
338 return NULL;
340 packet = hpsb_alloc_packet(length);
341 if (!packet)
342 return NULL;
344 if (length % 4) { /* zero padding bytes */
345 packet->data[length >> 2] = 0;
346 }
347 packet->host = host;
349 if (hpsb_get_tlabel(packet)) {
350 hpsb_free_packet(packet);
351 return NULL;
352 }
354 fill_async_stream_packet(packet, length, channel, tag, sync);
355 if (buffer)
356 memcpy(packet->data, buffer, length);
358 return packet;
359 }
361 struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node,
362 u64 addr, int extcode,
363 quadlet_t * data, quadlet_t arg)
364 {
365 struct hpsb_packet *p;
366 u32 length;
368 p = hpsb_alloc_packet(8);
369 if (!p)
370 return NULL;
372 p->host = host;
373 p->node_id = node;
374 if (hpsb_get_tlabel(p)) {
375 hpsb_free_packet(p);
376 return NULL;
377 }
379 switch (extcode) {
380 case EXTCODE_FETCH_ADD:
381 case EXTCODE_LITTLE_ADD:
382 length = 4;
383 if (data)
384 p->data[0] = *data;
385 break;
386 default:
387 length = 8;
388 if (data) {
389 p->data[0] = arg;
390 p->data[1] = *data;
391 }
392 break;
393 }
394 fill_async_lock(p, addr, extcode, length);
396 return p;
397 }
399 struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host,
400 nodeid_t node, u64 addr, int extcode,
401 octlet_t * data, octlet_t arg)
402 {
403 struct hpsb_packet *p;
404 u32 length;
406 p = hpsb_alloc_packet(16);
407 if (!p)
408 return NULL;
410 p->host = host;
411 p->node_id = node;
412 if (hpsb_get_tlabel(p)) {
413 hpsb_free_packet(p);
414 return NULL;
415 }
417 switch (extcode) {
418 case EXTCODE_FETCH_ADD:
419 case EXTCODE_LITTLE_ADD:
420 length = 8;
421 if (data) {
422 p->data[0] = *data >> 32;
423 p->data[1] = *data & 0xffffffff;
424 }
425 break;
426 default:
427 length = 16;
428 if (data) {
429 p->data[0] = arg >> 32;
430 p->data[1] = arg & 0xffffffff;
431 p->data[2] = *data >> 32;
432 p->data[3] = *data & 0xffffffff;
433 }
434 break;
435 }
436 fill_async_lock(p, addr, extcode, length);
438 return p;
439 }
441 struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host, quadlet_t data)
442 {
443 struct hpsb_packet *p;
445 p = hpsb_alloc_packet(0);
446 if (!p)
447 return NULL;
449 p->host = host;
450 fill_phy_packet(p, data);
452 return p;
453 }
455 struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host,
456 int length, int channel,
457 int tag, int sync)
458 {
459 struct hpsb_packet *p;
461 p = hpsb_alloc_packet(length);
462 if (!p)
463 return NULL;
465 p->host = host;
466 fill_iso_packet(p, length, channel, tag, sync);
468 p->generation = get_hpsb_generation(host);
470 return p;
471 }
473 /*
474 * FIXME - these functions should probably read from / write to user space to
475 * avoid in kernel buffers for user space callers
476 */
478 int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation,
479 u64 addr, quadlet_t * buffer, size_t length)
480 {
481 struct hpsb_packet *packet;
482 int retval = 0;
484 if (length == 0)
485 return -EINVAL;
487 BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
489 packet = hpsb_make_readpacket(host, node, addr, length);
491 if (!packet) {
492 return -ENOMEM;
493 }
495 packet->generation = generation;
496 retval = hpsb_send_packet_and_wait(packet);
497 if (retval < 0)
498 goto hpsb_read_fail;
500 retval = hpsb_packet_success(packet);
502 if (retval == 0) {
503 if (length == 4) {
504 *buffer = packet->header[3];
505 } else {
506 memcpy(buffer, packet->data, length);
507 }
508 }
510 hpsb_read_fail:
511 hpsb_free_tlabel(packet);
512 hpsb_free_packet(packet);
514 return retval;
515 }
517 int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation,
518 u64 addr, quadlet_t * buffer, size_t length)
519 {
520 struct hpsb_packet *packet;
521 int retval;
523 if (length == 0)
524 return -EINVAL;
526 BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
528 packet = hpsb_make_writepacket(host, node, addr, buffer, length);
530 if (!packet)
531 return -ENOMEM;
533 packet->generation = generation;
534 retval = hpsb_send_packet_and_wait(packet);
535 if (retval < 0)
536 goto hpsb_write_fail;
538 retval = hpsb_packet_success(packet);
540 hpsb_write_fail:
541 hpsb_free_tlabel(packet);
542 hpsb_free_packet(packet);
544 return retval;
545 }
547 #if 0
549 int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation,
550 u64 addr, int extcode, quadlet_t * data, quadlet_t arg)
551 {
552 struct hpsb_packet *packet;
553 int retval = 0;
555 BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet
557 packet = hpsb_make_lockpacket(host, node, addr, extcode, data, arg);
558 if (!packet)
559 return -ENOMEM;
561 packet->generation = generation;
562 retval = hpsb_send_packet_and_wait(packet);
563 if (retval < 0)
564 goto hpsb_lock_fail;
566 retval = hpsb_packet_success(packet);
568 if (retval == 0) {
569 *data = packet->data[0];
570 }
572 hpsb_lock_fail:
573 hpsb_free_tlabel(packet);
574 hpsb_free_packet(packet);
576 return retval;
577 }
579 int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation,
580 quadlet_t * buffer, size_t length, u32 specifier_id,
581 unsigned int version)
582 {
583 struct hpsb_packet *packet;
584 int retval = 0;
585 u16 specifier_id_hi = (specifier_id & 0x00ffff00) >> 8;
586 u8 specifier_id_lo = specifier_id & 0xff;
588 HPSB_VERBOSE("Send GASP: channel = %d, length = %Zd", channel, length);
590 length += 8;
592 packet = hpsb_make_streampacket(host, NULL, length, channel, 3, 0);
593 if (!packet)
594 return -ENOMEM;
596 packet->data[0] = cpu_to_be32((host->node_id << 16) | specifier_id_hi);
597 packet->data[1] =
598 cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff));
600 memcpy(&(packet->data[2]), buffer, length - 8);
602 packet->generation = generation;
604 packet->no_waiter = 1;
606 retval = hpsb_send_packet(packet);
607 if (retval < 0)
608 hpsb_free_packet(packet);
610 return retval;
611 }
613 #endif /* 0 */