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