?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / io / 1394 / s1394_asynch.c
blobc3ddd986efbcf6ecdaeae3994327585df68a15a0
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 /*
29 * s1394_asynch.c
30 * 1394 Services Layer Asynchronous Communications Routines
31 * These routines handle all of the tasks relating to asynch commands
32 */
33
34 #include <sys/conf.h>
35 #include <sys/ddi.h>
36 #include <sys/sunddi.h>
37 #include <sys/cmn_err.h>
38 #include <sys/types.h>
39 #include <sys/kmem.h>
40 #include <sys/disp.h>
41 #include <sys/tnf_probe.h>
42
43 #include <sys/1394/t1394.h>
44 #include <sys/1394/s1394.h>
45 #include <sys/1394/h1394.h>
46 #include <sys/1394/ieee1394.h>
47 #include <sys/1394/ieee1212.h>
48
49 static void s1394_handle_lock(cmd1394_cmd_t *cmd);
50
51 static cmd1394_cmd_t *s1394_pending_q_remove(s1394_hal_t *hal);
52
53 static boolean_t s1394_process_pending_q(s1394_hal_t *hal);
54
55 static boolean_t s1394_pending_q_helper(s1394_hal_t *hal, cmd1394_cmd_t *cmd);
56
57 static int s1394_process_split_lock(cmd1394_cmd_t *cmd,
58 cmd1394_cmd_t *target_cmd);
59
60 static int s1394_finish_split_lock(cmd1394_cmd_t *cmd,
61 cmd1394_cmd_t *target_cmd);
62
63 /*
64 * s1394_alloc_cmd()
65 * is used to allocate a command for a target or for a HAL.
66 */
67 int
68 s1394_alloc_cmd(s1394_hal_t *hal, uint_t flags, cmd1394_cmd_t **cmdp)
69 {
70 s1394_cmd_priv_t *s_priv;
71 void *hal_overhead;
72 uint_t cmd_size;
73 int alloc_sleep;
74
75 alloc_sleep = (flags & T1394_ALLOC_CMD_NOSLEEP) ? KM_NOSLEEP : KM_SLEEP;
76
77 if ((alloc_sleep == KM_SLEEP) &&
78 (servicing_interrupt())) {
79 ASSERT(alloc_sleep != KM_SLEEP); /* fail */
80 return (DDI_FAILURE);
81 }
82
83 /* either FCP command or response, but not both */
84 if ((flags &
85 (T1394_ALLOC_CMD_FCP_COMMAND | T1394_ALLOC_CMD_FCP_RESPONSE)) ==
86 (T1394_ALLOC_CMD_FCP_COMMAND | T1394_ALLOC_CMD_FCP_RESPONSE)) {
87 return (DDI_FAILURE);
88 }
89
90 *cmdp = kmem_cache_alloc(hal->hal_kmem_cachep, alloc_sleep);
91 if (*cmdp == NULL) {
92 return (DDI_FAILURE);
93 }
94 cmd_size = sizeof (cmd1394_cmd_t) +
95 sizeof (s1394_cmd_priv_t) + hal->halinfo.hal_overhead;
96 bzero((void *)*cmdp, cmd_size);
97
98 (*cmdp)->cmd_version = T1394_VERSION_V1;
99 (*cmdp)->cmd_result = CMD1394_NOSTATUS;
100
101 /* Get the Services Layer private area */
102 s_priv = S1394_GET_CMD_PRIV(*cmdp);
103
104 /* Set extension type */
105 if (flags & T1394_ALLOC_CMD_FCP_COMMAND) {
106 s1394_fa_init_cmd(s_priv, S1394_FA_TYPE_FCP_CTL);
107 } else if (flags & T1394_ALLOC_CMD_FCP_RESPONSE) {
108 s1394_fa_init_cmd(s_priv, S1394_FA_TYPE_FCP_TGT);
109 }
110
111 /* Set up the hal_overhead ptr in the hal_cmd_private */
112 hal_overhead = (uchar_t *)s_priv + sizeof (s1394_cmd_priv_t);
113 s_priv->hal_cmd_private.hal_overhead = (void *)hal_overhead;
114
115 /* kstats - number of cmd allocs */
116 hal->hal_kstats->cmd_alloc++;
117
118 return (DDI_SUCCESS);
119 }
120
121 /*
122 * s1394_free_cmd()
123 * is used to free a command that had been previously allocated by
124 * s1394_alloc_cmd().
125 */
126 int
127 s1394_free_cmd(s1394_hal_t *hal, cmd1394_cmd_t **cmdp)
128 {
129 s1394_cmd_priv_t *s_priv;
130
131 /* Get the Services Layer private area */
132 s_priv = S1394_GET_CMD_PRIV(*cmdp);
133
134 /* Check that command isn't in use */
135 if (s_priv->cmd_in_use == B_TRUE) {
136 ASSERT(s_priv->cmd_in_use == B_FALSE);
137 return (DDI_FAILURE);
138 }
139
140 /* kstats - number of cmd allocs */
141 kmem_cache_free(hal->hal_kmem_cachep, *cmdp);
142
143 /* Command pointer is set to NULL before returning */
144 *cmdp = NULL;
145
146 /* kstats - number of cmd frees */
147 hal->hal_kstats->cmd_free++;
148
149 return (DDI_SUCCESS);
150 }
151
152 /*
153 * s1394_xfer_asynch_command()
154 * is used to send an asynch command down to the HAL. Based upon the type
155 * of command that is being sent, the appropriate HAL function is called.
156 * Command failures are handled be returning an error and/or shutting down
157 * the HAL, depending on the severity of the error.
158 */
159 int
160 s1394_xfer_asynch_command(s1394_hal_t *hal, cmd1394_cmd_t *cmd, int *err)
161 {
162 s1394_cmd_priv_t *s_priv;
163 h1394_cmd_priv_t *h_priv;
164 s1394_hal_state_t state;
165 dev_info_t *dip;
166 int result_from_hal;
167 int ret;
168
169 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
170
171 mutex_enter(&hal->topology_tree_mutex);
172 state = hal->hal_state;
173 if (((state != S1394_HAL_NORMAL) && (state != S1394_HAL_RESET)) ||
174 (hal->disable_requests_bit == 1)) {
175 *err = s1394_HAL_asynch_error(hal, cmd, state);
176 mutex_exit(&hal->topology_tree_mutex);
177 return (DDI_FAILURE);
178 }
179 mutex_exit(&hal->topology_tree_mutex);
180
181 /* Get the Services Layer private area */
182 s_priv = S1394_GET_CMD_PRIV(cmd);
183
184 /* Get a pointer to the HAL private struct */
185 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
186
187 /* kstats - number of AT requests sent */
188 switch (cmd->cmd_type) {
189 case CMD1394_ASYNCH_RD_QUAD:
190 hal->hal_kstats->atreq_quad_rd++;
191 break;
192
193 case CMD1394_ASYNCH_RD_BLOCK:
194 hal->hal_kstats->atreq_blk_rd++;
195 break;
196
197 case CMD1394_ASYNCH_WR_QUAD:
198 hal->hal_kstats->atreq_quad_wr++;
199 break;
200
201 case CMD1394_ASYNCH_WR_BLOCK:
202 hal->hal_kstats->atreq_blk_wr++;
203 hal->hal_kstats->atreq_blk_wr_size += h_priv->mblk.length;
204 break;
205
206 case CMD1394_ASYNCH_LOCK_32:
207 hal->hal_kstats->atreq_lock32++;
208 break;
209
210 case CMD1394_ASYNCH_LOCK_64:
211 hal->hal_kstats->atreq_lock64++;
212 break;
213 }
214
215 switch (s_priv->cmd_priv_xfer_type) {
216 /* Call the HAL's read entry point */
217 case S1394_CMD_READ:
218 ret = HAL_CALL(hal).read(hal->halinfo.hal_private,
219 (cmd1394_cmd_t *)cmd,
220 (h1394_cmd_priv_t *)&s_priv->hal_cmd_private,
221 &result_from_hal);
222 break;
223
224 /* Call the HAL's write entry point */
225 case S1394_CMD_WRITE:
226 ret = HAL_CALL(hal).write(hal->halinfo.hal_private,
227 (cmd1394_cmd_t *)cmd,
228 (h1394_cmd_priv_t *)&s_priv->hal_cmd_private,
229 &result_from_hal);
230 break;
231
232 /* Call the HAL's lock entry point */
233 case S1394_CMD_LOCK:
234 ret = HAL_CALL(hal).lock(hal->halinfo.hal_private,
235 (cmd1394_cmd_t *)cmd,
236 (h1394_cmd_priv_t *)&s_priv->hal_cmd_private,
237 &result_from_hal);
238 break;
239
240 default:
241 *err = CMD1394_EUNKNOWN_ERROR;
242
243 return (DDI_FAILURE);
244 }
245
246 if (ret == DDI_FAILURE) {
247 switch (result_from_hal) {
248 case H1394_STATUS_EMPTY_TLABEL:
249 /* Out of TLABELs - Unable to send AT req */
250 *err = CMD1394_ENO_ATREQ;
251 break;
252
253 case H1394_STATUS_INVALID_BUSGEN:
254 /* Out of TLABELs - Unable to send AT req */
255 *err = CMD1394_ESTALE_GENERATION;
256 break;
257
258 case H1394_STATUS_NOMORE_SPACE:
259 /* No more space on HAL's HW queue */
260 *err = CMD1394_ENO_ATREQ;
261 break;
262
263 case H1394_STATUS_INTERNAL_ERROR:
264 dip = hal->halinfo.dip;
265
266 /* An unexpected error in the HAL */
267 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
268 ddi_node_name(dip), ddi_get_instance(dip));
269
270 /* Disable the HAL */
271 s1394_hal_shutdown(hal, B_TRUE);
272
273 *err = CMD1394_EFATAL_ERROR;
274 break;
275
276 default:
277 dip = hal->halinfo.dip;
278
279 /* An unexpected error in the HAL */
280 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
281 ddi_node_name(dip), ddi_get_instance(dip));
282
283 /* Disable the HAL */
284 s1394_hal_shutdown(hal, B_TRUE);
285
286 *err = CMD1394_EFATAL_ERROR;
287 break;
288 }
289
290 return (DDI_FAILURE);
291 }
292
293 /* No errors, return success */
294 *err = CMD1394_NOSTATUS;
295
296 return (DDI_SUCCESS);
297 }
298
299 /*
300 * s1394_setup_asynch_command()
301 * is used to setup an asynch command to be sent down to the HAL and out
302 * onto the bus. This function handles setting up the destination address
303 * (if necessary), speed, max_payload, putting the command onto the
304 * outstanding Q list, and any other things that must be done prior to
305 * calling the HAL.
306 */
307 int
308 s1394_setup_asynch_command(s1394_hal_t *hal, s1394_target_t *target,
309 cmd1394_cmd_t *cmd, uint32_t xfer_type, int *err)
310 {
311 s1394_cmd_priv_t *s_priv;
312 h1394_cmd_priv_t *h_priv;
313 uint64_t node;
314 uint32_t from_node;
315 uint32_t to_node;
316 uint32_t bus_capabilities;
317 uint_t current_max_payload;
318 uint_t max_rec;
319 uint_t max_blk;
320
321 ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
322
323 switch (cmd->cmd_type) {
324 case CMD1394_ASYNCH_RD_QUAD:
325 case CMD1394_ASYNCH_WR_QUAD:
326 case CMD1394_ASYNCH_RD_BLOCK:
327 case CMD1394_ASYNCH_WR_BLOCK:
328 case CMD1394_ASYNCH_LOCK_32:
329 case CMD1394_ASYNCH_LOCK_64:
330 break;
331
332 default:
333 *err = CMD1394_EINVALID_COMMAND;
334 return (DDI_FAILURE);
335 }
336
337 /* Check for potential address roll-over */
338 if (s1394_address_rollover(cmd) != B_FALSE) {
339 *err = CMD1394_EADDRESS_ERROR;
340 return (DDI_FAILURE);
341 }
342
343 /* Get the Services Layer private area */
344 s_priv = S1394_GET_CMD_PRIV(cmd);
345
346 /* Set up who sent command on which hal */
347 s_priv->sent_by_target = (s1394_target_t *)target;
348 s_priv->sent_on_hal = (s1394_hal_t *)hal;
349
350 /* Set up command transfer type */
351 s_priv->cmd_priv_xfer_type = xfer_type;
352
353 if (cmd->cmd_options & CMD1394_OVERRIDE_ADDR) {
354 /* Compare the current generation from the HAL struct */
355 /* to the one given by the target */
356
357 /* Speed is to be filled in from speed map */
358 from_node = IEEE1394_NODE_NUM(hal->node_id);
359 to_node = IEEE1394_ADDR_PHY_ID(cmd->cmd_addr);
360
361 if (cmd->bus_generation != hal->generation_count) {
362 *err = CMD1394_ESTALE_GENERATION;
363 return (DDI_FAILURE);
364 }
365
366 } else {
367 /* Set the generation */
368 cmd->bus_generation = hal->generation_count;
369
370 /* If not OVERRIDE_ADDR, then target may not be NULL */
371 ASSERT(target != NULL);
372
373 rw_enter(&hal->target_list_rwlock, RW_READER);
374
375 if ((target->target_state & S1394_TARG_GONE) != 0 ||
376 target->on_node == NULL) {
377 rw_exit(&hal->target_list_rwlock);
378 *err = CMD1394_EDEVICE_REMOVED;
379 return (DDI_FAILURE);
380 }
381
382 ASSERT((target->target_state & S1394_TARG_GONE) == 0);
383 node = target->on_node->node_num;
384 rw_exit(&hal->target_list_rwlock);
385
386 /* Mask in the top 16-bits */
387 cmd->cmd_addr = (cmd->cmd_addr & IEEE1394_ADDR_OFFSET_MASK);
388 cmd->cmd_addr = (cmd->cmd_addr |
389 (node << IEEE1394_ADDR_PHY_ID_SHIFT));
390 cmd->cmd_addr = (cmd->cmd_addr | IEEE1394_ADDR_BUS_ID_MASK);
391
392 /* Speed is to be filled in from speed map */
393 from_node = IEEE1394_NODE_NUM(hal->node_id);
394 to_node = (uint32_t)node;
395 }
396
397 /* Get a pointer to the HAL private struct */
398 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
399
400 /* Copy the generation into the HAL's private field */
401 h_priv->bus_generation = cmd->bus_generation;
402
403 /* Fill in the nodeID */
404 cmd->nodeID = (cmd->cmd_addr & IEEE1394_ADDR_NODE_ID_MASK) >>
405 IEEE1394_ADDR_NODE_ID_SHIFT;
406
407 if (cmd->cmd_options & CMD1394_OVERRIDE_SPEED) {
408 if (cmd->cmd_speed > IEEE1394_S400) {
409 *err = CMD1394_EINVALID_COMMAND;
410 return (DDI_FAILURE);
411
412 } else {
413 s_priv->hal_cmd_private.speed = (int)cmd->cmd_speed;
414 }
415
416 } else {
417 /* Speed is to be filled in from speed map */
418 s_priv->hal_cmd_private.speed = (int)s1394_speed_map_get(hal,
419 from_node, to_node);
420 }
421
422 /* Is it a block request? */
423 if ((cmd->cmd_type == CMD1394_ASYNCH_RD_BLOCK) ||
424 (cmd->cmd_type == CMD1394_ASYNCH_WR_BLOCK)) {
425
426 if (cmd->cmd_u.b.data_block == NULL) {
427 *err = CMD1394_ENULL_MBLK;
428 return (DDI_FAILURE);
429 }
430
431 /* Also need to check for MBLK_TOO_SMALL */
432 if (s1394_mblk_too_small(cmd) != B_FALSE) {
433 *err = CMD1394_EMBLK_TOO_SMALL;
434 return (DDI_FAILURE);
435 }
436
437 /* Initialize bytes_transferred to zero */
438 cmd->cmd_u.b.bytes_transferred = 0;
439
440 /* Handle the MAX_PAYLOAD size */
441 if (cmd->cmd_options & CMD1394_OVERRIDE_ADDR) {
442
443 current_max_payload = 512 <<
444 (s_priv->hal_cmd_private.speed);
445 if (hal->topology_tree[to_node].cfgrom) {
446 bus_capabilities =
447 hal->topology_tree[to_node].cfgrom[
448 IEEE1212_NODE_CAP_QUAD];
449 max_rec = (bus_capabilities &
450 IEEE1394_BIB_MAXREC_MASK) >>
451 IEEE1394_BIB_MAXREC_SHIFT;
452 } else {
453 max_rec = 0;
454 }
455
456 if ((max_rec > 0) && (max_rec < 14)) {
457 max_blk = 1 << (max_rec + 1);
458
459 } else {
460 /* These are either unspecified or reserved */
461 max_blk = 4;
462 }
463 if (max_blk < current_max_payload)
464 current_max_payload = max_blk;
465
466 } else {
467 rw_enter(&hal->target_list_rwlock, RW_READER);
468 current_max_payload = target->current_max_payload;
469 rw_exit(&hal->target_list_rwlock);
470 }
471
472 if (cmd->cmd_options & CMD1394_OVERRIDE_MAX_PAYLOAD) {
473 if (current_max_payload > cmd->cmd_u.b.max_payload)
474 current_max_payload = cmd->cmd_u.b.max_payload;
475 }
476
477 h_priv->mblk.curr_mblk = cmd->cmd_u.b.data_block;
478
479 if (cmd->cmd_type == CMD1394_ASYNCH_WR_BLOCK) {
480 h_priv->mblk.curr_offset =
481 cmd->cmd_u.b.data_block->b_rptr;
482 } else {
483 h_priv->mblk.curr_offset =
484 cmd->cmd_u.b.data_block->b_wptr;
485 }
486
487 if (cmd->cmd_u.b.blk_length > current_max_payload) {
488 h_priv->mblk.length = current_max_payload;
489 s_priv->data_remaining = cmd->cmd_u.b.blk_length;
490
491 } else {
492 h_priv->mblk.length = cmd->cmd_u.b.blk_length;
493 s_priv->data_remaining = cmd->cmd_u.b.blk_length;
494 }
495 }
496
497 /* Mark command as being used */
498 s_priv->cmd_in_use = B_TRUE;
499
500 /* Put command on the HAL's outstanding request Q */
501 s1394_insert_q_asynch_cmd(hal, cmd);
502
503 return (DDI_SUCCESS);
504 }
505
506 /*
507 * s1394_insert_q_asynch_cmd()
508 * is used to insert a given command structure onto a HAL's outstanding
509 * asynch queue.
510 */
511 void
512 s1394_insert_q_asynch_cmd(s1394_hal_t *hal, cmd1394_cmd_t *cmd)
513 {
514 s1394_cmd_priv_t *s_priv;
515 s1394_cmd_priv_t *c_priv;
516 cmd1394_cmd_t *temp_cmd;
517
518 mutex_enter(&hal->outstanding_q_mutex);
519
520 /* Get the Services Layer private area */
521 s_priv = S1394_GET_CMD_PRIV(cmd);
522
523 /* Is the outstanding request queue empty? */
524 if ((hal->outstanding_q_head == NULL) &&
525 (hal->outstanding_q_tail == NULL)) {
526
527 hal->outstanding_q_head = (cmd1394_cmd_t *)cmd;
528 hal->outstanding_q_tail = (cmd1394_cmd_t *)cmd;
529 s_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
530 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
531
532 } else {
533 s_priv->cmd_priv_next = hal->outstanding_q_head;
534 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
535
536 temp_cmd = (cmd1394_cmd_t *)hal->outstanding_q_head;
537 c_priv = (s1394_cmd_priv_t *)((uchar_t *)temp_cmd +
538 sizeof (cmd1394_cmd_t));
539 c_priv->cmd_priv_prev = (cmd1394_cmd_t *)cmd;
540
541 hal->outstanding_q_head = (cmd1394_cmd_t *)cmd;
542 }
543
544 mutex_exit(&hal->outstanding_q_mutex);
545 }
546
547 /*
548 * s1394_remove_q_asynch_cmd()
549 * is used to remove a given command structure from a HAL's outstanding
550 * asynch queue.
551 */
552 void
553 s1394_remove_q_asynch_cmd(s1394_hal_t *hal, cmd1394_cmd_t *cmd)
554 {
555 s1394_cmd_priv_t *s_priv;
556 s1394_cmd_priv_t *c_priv;
557 cmd1394_cmd_t *prev_cmd;
558 cmd1394_cmd_t *next_cmd;
559
560 mutex_enter(&hal->outstanding_q_mutex);
561
562 /* Get the Services Layer private area */
563 s_priv = S1394_GET_CMD_PRIV(cmd);
564
565 prev_cmd = (cmd1394_cmd_t *)s_priv->cmd_priv_prev;
566 next_cmd = (cmd1394_cmd_t *)s_priv->cmd_priv_next;
567
568 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
569 s_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
570
571 if (prev_cmd != NULL) {
572 c_priv = (s1394_cmd_priv_t *)((uchar_t *)prev_cmd +
573 sizeof (cmd1394_cmd_t));
574 c_priv->cmd_priv_next = (cmd1394_cmd_t *)next_cmd;
575
576 } else {
577 if (hal->outstanding_q_head == (cmd1394_cmd_t *)cmd)
578 hal->outstanding_q_head = (cmd1394_cmd_t *)next_cmd;
579 }
580
581 if (next_cmd != NULL) {
582 c_priv = (s1394_cmd_priv_t *)((uchar_t *)next_cmd +
583 sizeof (cmd1394_cmd_t));
584 c_priv->cmd_priv_prev = (cmd1394_cmd_t *)prev_cmd;
585
586 } else {
587 if (hal->outstanding_q_tail == (cmd1394_cmd_t *)cmd)
588 hal->outstanding_q_tail = (cmd1394_cmd_t *)prev_cmd;
589 }
590
591 mutex_exit(&hal->outstanding_q_mutex);
592 }
593
594 /*
595 * s1394_atreq_cmd_complete()
596 * is called by h1394_cmd_is_complete() when an AT request has completed.
597 * Based upon a command's completion status, s1394_atreq_cmd_complete()
598 * determines whether to call the target (or unblock), put the command onto
599 * the pending Q to be sent out later, or to resend the command
600 * (multi-part command).
601 */
602 void
603 s1394_atreq_cmd_complete(s1394_hal_t *hal, cmd1394_cmd_t *req, int status)
604 {
605 s1394_cmd_priv_t *s_priv;
606 h1394_cmd_priv_t *h_priv;
607 dev_info_t *dip;
608 int ret;
609 int cmd_result;
610 int err;
611
612 /* Get the Services Layer private area */
613 s_priv = S1394_GET_CMD_PRIV(req);
614
615 /* If not an ack_complete... */
616 if (status != H1394_CMD_SUCCESS) {
617 /* kstats - number of failure AT responses */
618 switch (req->cmd_type) {
619 case CMD1394_ASYNCH_RD_QUAD:
620 hal->hal_kstats->atresp_quad_rd_fail++;
621 break;
622
623 case CMD1394_ASYNCH_RD_BLOCK:
624 hal->hal_kstats->atresp_blk_rd_fail++;
625 break;
626
627 case CMD1394_ASYNCH_WR_QUAD:
628 hal->hal_kstats->atresp_quad_wr_fail++;
629 break;
630
631 case CMD1394_ASYNCH_WR_BLOCK:
632 hal->hal_kstats->atresp_blk_wr_fail++;
633 break;
634
635 case CMD1394_ASYNCH_LOCK_32:
636 hal->hal_kstats->atresp_lock32_fail++;
637 break;
638
639 case CMD1394_ASYNCH_LOCK_64:
640 hal->hal_kstats->atresp_lock64_fail++;
641 break;
642 }
643
644
645 switch (status) {
646 /* evt_missing_ack */
647 case H1394_CMD_ETIMEOUT:
648 cmd_result = CMD1394_ETIMEOUT;
649 break;
650
651 /* evt_flushed */
652 case H1394_CMD_EBUSRESET:
653 /* Move request to pending Q if cancel on */
654 /* reset is not set */
655 if (req->cmd_options & CMD1394_CANCEL_ON_BUS_RESET) {
656 cmd_result = CMD1394_EBUSRESET;
657 break;
658 }
659 s1394_remove_q_asynch_cmd(hal, req);
660 s1394_pending_q_insert(hal, req, S1394_PENDING_Q_REAR);
661 return;
662
663 /* ack_busy_X */
664 /* ack_busy_A */
665 /* ack_busy_B */
666 case H1394_CMD_EDEVICE_BUSY:
667 cmd_result = CMD1394_EDEVICE_BUSY;
668 break;
669
670 /* ack_data_error */
671 case H1394_CMD_EDATA_ERROR:
672 cmd_result = CMD1394_EDATA_ERROR;
673 break;
674
675 /* ack_type_error */
676 case H1394_CMD_ETYPE_ERROR:
677 cmd_result = CMD1394_ETYPE_ERROR;
678 break;
679
680 /* resp_address_error */
681 /* ack_address_error */
682 case H1394_CMD_EADDR_ERROR:
683 cmd_result = CMD1394_EADDRESS_ERROR;
684 break;
685
686 /* resp_conflict_error */
687 /* ack_conflict_error */
688 case H1394_CMD_ERSRC_CONFLICT:
689 cmd_result = CMD1394_ERSRC_CONFLICT;
690 break;
691
692 /* ack_tardy */
693 case H1394_CMD_EDEVICE_POWERUP:
694 cmd_result = CMD1394_EDEVICE_BUSY;
695 break;
696
697 /* device errors (bad tcodes, ACKs, etc...) */
698 case H1394_CMD_EDEVICE_ERROR:
699 cmd_result = CMD1394_EDEVICE_ERROR;
700 break;
701
702 /* Unknown error type */
703 case H1394_CMD_EUNKNOWN_ERROR:
704 cmd_result = CMD1394_EUNKNOWN_ERROR;
705 break;
706
707 /* Unrecognized error */
708 default:
709 dip = hal->halinfo.dip;
710
711 /* An unexpected error in the HAL */
712 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
713 ddi_node_name(dip), ddi_get_instance(dip));
714
715 /* Disable the HAL */
716 s1394_hal_shutdown(hal, B_TRUE);
717
718 return;
719 }
720
721 /* Remove command from the HAL's outstanding request Q */
722 s1394_remove_q_asynch_cmd(hal, req);
723
724 s_priv->cmd_in_use = B_FALSE;
725
726 req->cmd_result = cmd_result;
727
728 /* Is this a blocking command? */
729 if (req->cmd_options & CMD1394_BLOCKING) {
730 /* Unblock the waiting command */
731 mutex_enter(&s_priv->blocking_mutex);
732 s_priv->blocking_flag = B_TRUE;
733 cv_signal(&s_priv->blocking_cv);
734 mutex_exit(&s_priv->blocking_mutex);
735
736 return;
737 }
738
739 /* Call the target's completion_callback() */
740 if (req->completion_callback != NULL) {
741 req->completion_callback(req);
742 }
743
744 return;
745 }
746
747 /* Successful unless otherwise modified */
748 err = CMD1394_CMDSUCCESS;
749
750 if ((req->cmd_type == CMD1394_ASYNCH_RD_BLOCK) ||
751 (req->cmd_type == CMD1394_ASYNCH_WR_BLOCK)) {
752
753 /* Get a pointer to the HAL private struct */
754 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
755
756 /* Update data_remaining */
757 s_priv->data_remaining -= h_priv->mblk.length;
758
759 /* Increment bytes_transferred */
760 req->cmd_u.b.bytes_transferred += h_priv->mblk.length;
761
762 if (req->cmd_type == CMD1394_ASYNCH_RD_BLOCK)
763 hal->hal_kstats->atreq_blk_rd_size +=
764 h_priv->mblk.length;
765
766 /* Is there still more to send? */
767 if (s_priv->data_remaining > 0) {
768
769 /* Setup the new mblk and offset */
770 h_priv->mblk.curr_mblk = h_priv->mblk.next_mblk;
771 h_priv->mblk.curr_offset = h_priv->mblk.next_offset;
772
773 /* Update destination address */
774 if (!(req->cmd_options &
775 CMD1394_DISABLE_ADDR_INCREMENT)) {
776 req->cmd_addr += h_priv->mblk.length;
777 }
778
779 /*
780 * Use the current MAX_PAYLOAD size. This value
781 * doesn't need to be recalculated because we must
782 * be in the same generation on the bus, else we
783 * would have seen a bus reset error.
784 */
785 if (s_priv->data_remaining < h_priv->mblk.length) {
786 h_priv->mblk.length = s_priv->data_remaining;
787 }
788
789 /* Send command out again */
790 ret = s1394_xfer_asynch_command(hal, req, &err);
791
792 if (ret == DDI_SUCCESS) {
793 return;
794
795 } else if (err == CMD1394_ESTALE_GENERATION) {
796 /* Remove cmd from outstanding request Q */
797 s1394_remove_q_asynch_cmd(hal, req);
798 s1394_pending_q_insert(hal, req,
799 S1394_PENDING_Q_REAR);
800
801 return;
802 }
803 }
804 }
805
806 /* Remove command from the HAL's outstanding request Q */
807 s1394_remove_q_asynch_cmd(hal, req);
808
809 s_priv->cmd_in_use = B_FALSE;
810
811 /* Set status */
812 req->cmd_result = err;
813
814 /* Is this a blocking command? */
815 if (req->cmd_options & CMD1394_BLOCKING) {
816 /* Unblock the waiting command */
817 mutex_enter(&s_priv->blocking_mutex);
818 s_priv->blocking_flag = B_TRUE;
819 cv_signal(&s_priv->blocking_cv);
820 mutex_exit(&s_priv->blocking_mutex);
821
822 return;
823 }
824
825 /* Set status and call completion_callback() */
826 if (req->completion_callback != NULL) {
827
828 req->completion_callback(req);
829
830 return;
831 }
832 }
833
834 /*
835 * s1394_atresp_cmd_complete()
836 * is similar to s1394_atreq_cmd_complete(). It is also called by
837 * h1394_cmd_is_complete(), but when an AT response has completed.
838 * Again, based upon the command's completion status,
839 * s1394_atresp_cmd_complete() determines whether to call the target or
840 * to simply cleanup the command and return.
841 */
842 void
843 s1394_atresp_cmd_complete(s1394_hal_t *hal, cmd1394_cmd_t *resp, int status)
844 {
845 s1394_cmd_priv_t *s_priv;
846 h1394_cmd_priv_t *h_priv;
847 dev_info_t *dip;
848 boolean_t valid_addr_blk;
849 int target_status;
850
851 target_status = CMD1394_CMDSUCCESS;
852
853 /* If not an ack_complete */
854 if (status != H1394_CMD_SUCCESS) {
855 switch (status) {
856 /* evt_missing_ack */
857 case H1394_CMD_ETIMEOUT:
858 target_status = CMD1394_ETIMEOUT;
859 break;
860
861 /* evt_flushed */
862 case H1394_CMD_EBUSRESET:
863 target_status = CMD1394_EBUSRESET;
864 break;
865
866 /* ack_busy_X */
867 /* ack_busy_A */
868 /* ack_busy_B */
869 case H1394_CMD_EDEVICE_BUSY:
870 target_status = CMD1394_EDEVICE_BUSY;
871 break;
872
873 /* ack_data_error */
874 case H1394_CMD_EDATA_ERROR:
875 target_status = CMD1394_EDATA_ERROR;
876 break;
877
878 /* ack_type_error */
879 case H1394_CMD_ETYPE_ERROR:
880 target_status = CMD1394_ETYPE_ERROR;
881 break;
882
883 /* ack_address_error */
884 case H1394_CMD_EADDR_ERROR:
885 target_status = CMD1394_EADDRESS_ERROR;
886 break;
887
888 /* ack_conflict_error */
889 case H1394_CMD_ERSRC_CONFLICT:
890 target_status = CMD1394_ERSRC_CONFLICT;
891 break;
892
893 /* ack_tardy */
894 case H1394_CMD_EDEVICE_POWERUP:
895 target_status = CMD1394_EDEVICE_BUSY;
896 break;
897
898 /* device errors (bad tcodes, ACKs, etc...) */
899 case H1394_CMD_EDEVICE_ERROR:
900 target_status = CMD1394_EDEVICE_ERROR;
901 break;
902
903 /* Unknown error type */
904 case H1394_CMD_EUNKNOWN_ERROR:
905 target_status = CMD1394_EUNKNOWN_ERROR;
906 break;
907
908 /* Unrecognized error */
909 default:
910 dip = hal->halinfo.dip;
911
912 /* An unexpected error in the HAL */
913 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
914 ddi_node_name(dip), ddi_get_instance(dip));
915
916 /* Disable the HAL */
917 s1394_hal_shutdown(hal, B_TRUE);
918
919 return;
920 }
921 }
922
923 /* Get the Services Layer private area */
924 s_priv = S1394_GET_CMD_PRIV(resp);
925
926 /* Get a pointer to the HAL private struct */
927 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
928
929 valid_addr_blk = s_priv->arreq_valid_addr;
930
931 if (valid_addr_blk == B_TRUE) {
932 /* Set the command status */
933 resp->cmd_result = target_status;
934
935 switch (s_priv->cmd_priv_xfer_type) {
936 case S1394_CMD_READ:
937 case S1394_CMD_WRITE:
938 case S1394_CMD_LOCK:
939 if (resp->completion_callback != NULL) {
940 resp->completion_callback(resp);
941 }
942 break;
943
944 default:
945 dip = hal->halinfo.dip;
946
947 /* An unexpected error in the HAL */
948 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
949 ddi_node_name(dip), ddi_get_instance(dip));
950
951 /* Disable the HAL */
952 s1394_hal_shutdown(hal, B_TRUE);
953
954 return;
955 }
956 }
957
958 /* Free the command - Pass it back to the HAL */
959 HAL_CALL(hal).response_complete(hal->halinfo.hal_private, resp, h_priv);
960 }
961
962 /*
963 * s1394_send_response()
964 * is used to send a response to an AR request. Depending on whether the
965 * request was a broadcast request, a write to posted write address space,
966 * or some other request, either a response packet is sent, or the command
967 * is returned to the HAL. A return value of DDI_SUCCESS means that the
968 * command has been handled correctly. It was either successfully sent to
969 * the HAL, or, if it was posted_write of broadcast, it was freed up. A
970 * return value of DDI_FAILURE indicates either a serious error, in which
971 * case the HAL is shutdown, or a failure returned by the HAL, in which
972 * case the command is freed up and notice of the failure is returned.
973 */
974 int
975 s1394_send_response(s1394_hal_t *hal, cmd1394_cmd_t *resp)
976 {
977 s1394_cmd_priv_t *s_priv;
978 h1394_cmd_priv_t *h_priv;
979 dev_info_t *dip;
980 int ret;
981 int result;
982
983 /* Get the Services Layer private area */
984 s_priv = S1394_GET_CMD_PRIV(resp);
985
986 /* Get a pointer to the HAL private struct */
987 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
988
989 /*
990 * If request was broadcast or a write request to a posted write
991 * address, don't send a response
992 */
993 if ((resp->broadcast == 1) || ((s_priv->posted_write == B_TRUE) &&
994 ((resp->cmd_result == CMD1394_ASYNCH_WR_QUAD) ||
995 (resp->cmd_result == CMD1394_ASYNCH_WR_BLOCK)))) {
996
997 /* Free the command - Pass it back to the HAL */
998 HAL_CALL(hal).response_complete(hal->halinfo.hal_private,
999 resp, h_priv);
1000
1001 return (DDI_SUCCESS);
1002 }
1003
1004 /* kstats - number of failure responses sent */
1005 if (resp->cmd_result != IEEE1394_RESP_COMPLETE) {
1006 switch (resp->cmd_type) {
1007 case CMD1394_ASYNCH_RD_QUAD:
1008 hal->hal_kstats->arresp_quad_rd_fail++;
1009 break;
1010
1011 case CMD1394_ASYNCH_RD_BLOCK:
1012 hal->hal_kstats->arresp_blk_rd_fail++;
1013 break;
1014
1015 case CMD1394_ASYNCH_WR_QUAD:
1016 hal->hal_kstats->arresp_quad_wr_fail++;
1017 break;
1018
1019 case CMD1394_ASYNCH_WR_BLOCK:
1020 hal->hal_kstats->arresp_blk_wr_fail++;
1021 break;
1022
1023 case CMD1394_ASYNCH_LOCK_32:
1024 hal->hal_kstats->arresp_lock32_fail++;
1025 break;
1026
1027 case CMD1394_ASYNCH_LOCK_64:
1028 hal->hal_kstats->arresp_lock64_fail++;
1029 break;
1030 }
1031 } else {
1032 if (resp->cmd_type == CMD1394_ASYNCH_RD_BLOCK)
1033 hal->hal_kstats->arreq_blk_rd_size +=
1034 resp->cmd_u.b.blk_length;
1035 }
1036
1037 if (resp->cmd_type == CMD1394_ASYNCH_RD_BLOCK) {
1038 h_priv->mblk.curr_mblk = resp->cmd_u.b.data_block;
1039 h_priv->mblk.curr_offset = resp->cmd_u.b.data_block->b_rptr;
1040 h_priv->mblk.length = resp->cmd_u.b.blk_length;
1041 }
1042
1043 switch (s_priv->cmd_priv_xfer_type) {
1044 case S1394_CMD_READ:
1045 ret = HAL_CALL(hal).read_response(hal->halinfo.hal_private,
1046 resp, h_priv, &result);
1047 break;
1048
1049 case S1394_CMD_WRITE:
1050 ret = HAL_CALL(hal).write_response(hal->halinfo.hal_private,
1051 resp, h_priv, &result);
1052 break;
1053
1054 case S1394_CMD_LOCK:
1055 ret = HAL_CALL(hal).lock_response(hal->halinfo.hal_private,
1056 resp, h_priv, &result);
1057 break;
1058
1059 default:
1060 dip = hal->halinfo.dip;
1061
1062 /* An unexpected error in the HAL */
1063 cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
1064 ddi_node_name(dip), ddi_get_instance(dip));
1065
1066 /* Disable the HAL */
1067 s1394_hal_shutdown(hal, B_TRUE);
1068
1069 return (DDI_FAILURE);
1070 }
1071
1072 /* Unable to send a response */
1073 if (ret != DDI_SUCCESS) {
1074 /* Free the command - Pass it back to the HAL */
1075 HAL_CALL(hal).response_complete(hal->halinfo.hal_private,
1076 resp, h_priv);
1077
1078 return (DDI_FAILURE);
1079 }
1080
1081 return (DDI_SUCCESS);
1082 }
1083
1084 /*
1085 * s1394_compare_swap()
1086 * is used by t1394_lock() to send a lock request. Any of the lock
1087 * requests specified explicitly by the 1394 spec will pass thru here,
1088 * i.e compare-swap, mask-swap, etc.
1089 */
1090 int
1091 s1394_compare_swap(s1394_hal_t *hal, s1394_target_t *target, cmd1394_cmd_t *cmd)
1092 {
1093 s1394_cmd_priv_t *s_priv;
1094 s1394_hal_state_t state;
1095 int err;
1096 int ret;
1097
1098 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1099
1100 /* Lock the topology tree - protect from bus reset */
1101 mutex_enter(&hal->topology_tree_mutex);
1102
1103 ret = s1394_setup_asynch_command(hal, target, cmd, S1394_CMD_LOCK,
1104 &err);
1105
1106 /* Unlock the topology tree */
1107 mutex_exit(&hal->topology_tree_mutex);
1108
1109 /* Get the Services Layer private area */
1110 s_priv = S1394_GET_CMD_PRIV(cmd);
1111
1112 /* Command has now been put onto the queue! */
1113 if (ret != DDI_SUCCESS) {
1114 /* Copy error code into result */
1115 cmd->cmd_result = err;
1116
1117 return (DDI_FAILURE);
1118 }
1119
1120 mutex_enter(&hal->topology_tree_mutex);
1121 state = hal->hal_state;
1122 /* If this command was sent during a bus reset, */
1123 /* then put it onto the pending Q. */
1124 if (state == S1394_HAL_RESET) {
1125 /* Remove cmd from outstanding request Q */
1126 s1394_remove_q_asynch_cmd(hal, cmd);
1127
1128 /* Are we on the bus reset event stack? */
1129 if (s1394_on_br_thread(hal) == B_TRUE) {
1130 /* Blocking commands are not allowed */
1131 if (cmd->cmd_options & CMD1394_BLOCKING) {
1132 mutex_exit(&hal->topology_tree_mutex);
1133
1134 s_priv->cmd_in_use = B_FALSE;
1135
1136 cmd->cmd_result = CMD1394_EINVALID_CONTEXT;
1137
1138 return (DDI_FAILURE);
1139 }
1140 }
1141
1142 s1394_pending_q_insert(hal, cmd, S1394_PENDING_Q_FRONT);
1143 mutex_exit(&hal->topology_tree_mutex);
1144
1145 /* Block (if necessary) */
1146 s1394_block_on_asynch_cmd(cmd);
1147
1148 return (DDI_SUCCESS);
1149 }
1150 mutex_exit(&hal->topology_tree_mutex);
1151
1152 /* Send the command out */
1153 ret = s1394_xfer_asynch_command(hal, cmd, &err);
1154
1155 if (ret != DDI_SUCCESS) {
1156 if (err == CMD1394_ESTALE_GENERATION) {
1157 /* Remove cmd from outstanding request Q */
1158 s1394_remove_q_asynch_cmd(hal, cmd);
1159 s1394_pending_q_insert(hal, cmd, S1394_PENDING_Q_FRONT);
1160
1161 /* Block (if necessary) */
1162 s1394_block_on_asynch_cmd(cmd);
1163
1164 return (DDI_SUCCESS);
1165
1166 } else {
1167 /* Remove cmd from outstanding request Q */
1168 s1394_remove_q_asynch_cmd(hal, cmd);
1169
1170 s_priv->cmd_in_use = B_FALSE;
1171
1172 /* Copy error code into result */
1173 cmd->cmd_result = err;
1174
1175 return (DDI_FAILURE);
1176 }
1177 } else {
1178 /* Block (if necessary) */
1179 s1394_block_on_asynch_cmd(cmd);
1180
1181 return (DDI_SUCCESS);
1182 }
1183 }
1184
1185 /*
1186 * s1394_split_lock_req()
1187 * is also used by t1394_lock() to send a lock request. The difference
1188 * is that s1394_split_lock_req() is used to send the software supported
1189 * lock types, i.e. bit_and, bit_or, etc. These lock requests require
1190 * more than one transaction, typically compare-swap's.
1191 */
1192 int
1193 s1394_split_lock_req(s1394_hal_t *hal, s1394_target_t *target,
1194 cmd1394_cmd_t *cmd)
1195 {
1196 s1394_cmd_priv_t *s_priv;
1197 cmd1394_cmd_t *tmp_cmd;
1198
1199 /* Allocate a temporary command */
1200 if (s1394_alloc_cmd(hal, T1394_ALLOC_CMD_NOSLEEP, &tmp_cmd) !=
1201 DDI_SUCCESS) {
1202 cmd->cmd_result = CMD1394_EUNKNOWN_ERROR;
1203
1204 return (DDI_FAILURE);
1205 }
1206
1207 /* Get the Services Layer private area */
1208 s_priv = S1394_GET_CMD_PRIV(tmp_cmd);
1209
1210 tmp_cmd->completion_callback = s1394_handle_lock;
1211 tmp_cmd->cmd_callback_arg = (opaque_t)cmd;
1212 tmp_cmd->cmd_type = cmd->cmd_type;
1213 tmp_cmd->cmd_addr = cmd->cmd_addr;
1214 tmp_cmd->cmd_options = cmd->cmd_options;
1215 tmp_cmd->bus_generation = cmd->bus_generation;
1216
1217 /* The temporary command can not block */
1218 tmp_cmd->cmd_options = tmp_cmd->cmd_options & ~CMD1394_BLOCKING;
1219
1220 /* Setup compare-swap with data_value == arg_value (read) */
1221 if (tmp_cmd->cmd_type == CMD1394_ASYNCH_LOCK_32) {
1222 tmp_cmd->cmd_u.l32.data_value = 0;
1223 tmp_cmd->cmd_u.l32.arg_value = 0;
1224 tmp_cmd->cmd_u.l32.lock_type = CMD1394_LOCK_COMPARE_SWAP;
1225 s_priv->temp_num_retries = cmd->cmd_u.l32.num_retries;
1226 } else {
1227 tmp_cmd->cmd_u.l64.data_value = 0;
1228 tmp_cmd->cmd_u.l64.arg_value = 0;
1229 tmp_cmd->cmd_u.l64.lock_type = CMD1394_LOCK_COMPARE_SWAP;
1230 s_priv->temp_num_retries = cmd->cmd_u.l64.num_retries;
1231 }
1232
1233 /* Initialize lock_req_step */
1234 s_priv->lock_req_step = 0;
1235
1236 /* Get the Services Layer private area for the target cmd */
1237 s_priv = S1394_GET_CMD_PRIV(cmd);
1238
1239 s_priv->cmd_in_use = B_TRUE;
1240
1241 /* Send the request */
1242 if (s1394_compare_swap(hal, target, tmp_cmd) != DDI_SUCCESS) {
1243 s_priv->cmd_in_use = B_FALSE;
1244
1245 /* Free the temporary command */
1246 if (s1394_free_cmd(hal, &tmp_cmd) != DDI_SUCCESS)
1247 cmd->cmd_result = CMD1394_EUNKNOWN_ERROR;
1248
1249 return (DDI_FAILURE);
1250 }
1251
1252 /* Block (if necessary) */
1253 s1394_block_on_asynch_cmd(cmd);
1254
1255 return (DDI_SUCCESS);
1256 }
1257
1258 /*
1259 * s1394_handle_lock()
1260 * is the callback for s1394_split_lock_req(). It does all of the real
1261 * work. Based on the specific lock type all necessary manipulation is
1262 * performed and another compare swap is sent out. If the transaction
1263 * is unsuccessful, it is retried.
1264 */
1265 static void
1266 s1394_handle_lock(cmd1394_cmd_t *cmd)
1267 {
1268 s1394_hal_t *to_hal;
1269 s1394_target_t *target;
1270 s1394_cmd_priv_t *s_priv;
1271 cmd1394_cmd_t *target_cmd;
1272 uint32_t lock_req_step;
1273 int tcmd_result;
1274 int ret;
1275
1276 /* Get the Services Layer private area */
1277 s_priv = S1394_GET_CMD_PRIV(cmd);
1278
1279 lock_req_step = s_priv->lock_req_step;
1280
1281 /* Get the target's command */
1282 target_cmd = (cmd1394_cmd_t *)cmd->cmd_callback_arg;
1283
1284 /* Get the destination of the command */
1285 to_hal = s_priv->sent_on_hal;
1286
1287 lock_req_step_0:
1288 /* Is this step 0 completing? */
1289 if (lock_req_step == 0) {
1290 /* Was the request successful? */
1291 if (cmd->cmd_result == CMD1394_CMDSUCCESS) {
1292 /* Do any math, bit ops, or byte-swapping necessary */
1293 ret = s1394_process_split_lock(cmd, target_cmd);
1294
1295 if (ret != DDI_SUCCESS) {
1296 tcmd_result = target_cmd->cmd_result;
1297 goto lock_req_done;
1298 }
1299
1300 s_priv->lock_req_step = 1;
1301
1302 target = s_priv->sent_by_target;
1303
1304 if (s1394_compare_swap(to_hal, target, cmd) !=
1305 DDI_SUCCESS) {
1306 tcmd_result = cmd->cmd_result;
1307 goto lock_req_done;
1308 } else {
1309 return;
1310 }
1311 } else {
1312 /* Command failed for some reason */
1313 tcmd_result = cmd->cmd_result;
1314 goto lock_req_done;
1315 }
1316 } else { /* lock_req_step == 1 */
1317 /* Was the request successful? */
1318 if (cmd->cmd_result == CMD1394_CMDSUCCESS) {
1319 /* Do whatever's necessary to finish up the lock */
1320 ret = s1394_finish_split_lock(cmd, target_cmd);
1321
1322 if (ret != DDI_SUCCESS) {
1323 lock_req_step = 0;
1324 goto lock_req_step_0;
1325 } else {
1326 tcmd_result = cmd->cmd_result;
1327 goto lock_req_done;
1328 }
1329 } else {
1330 /* Command failed for some reason */
1331 tcmd_result = cmd->cmd_result;
1332 goto lock_req_done;
1333 }
1334 }
1335
1336 lock_req_done:
1337 if (s1394_free_cmd(to_hal, &cmd) != DDI_SUCCESS) {
1338 }
1339
1340 /* Get the Services Layer private area */
1341 s_priv = S1394_GET_CMD_PRIV(target_cmd);
1342
1343 s_priv->cmd_in_use = B_FALSE;
1344
1345 target_cmd->cmd_result = tcmd_result;
1346
1347 /* Is this a blocking command? */
1348 if (target_cmd->cmd_options & CMD1394_BLOCKING) {
1349 /* Unblock the waiting command */
1350 mutex_enter(&s_priv->blocking_mutex);
1351 s_priv->blocking_flag = B_TRUE;
1352 cv_signal(&s_priv->blocking_cv);
1353 mutex_exit(&s_priv->blocking_mutex);
1354
1355 return;
1356 }
1357
1358 /* Call the target's completion_callback() */
1359 if (target_cmd->completion_callback != NULL)
1360 target_cmd->completion_callback(target_cmd);
1361 }
1362
1363 /*
1364 * s1394_pending_q_insert()
1365 * is used to insert a given command structure onto a HAL's pending queue
1366 * for later processing (after the bus reset). All commands returned by
1367 * the HAL, are inserted onto the rear of the list (first priority), and
1368 * all other commands (from targets during bus reset) are put onto the front.
1369 */
1370 void
1371 s1394_pending_q_insert(s1394_hal_t *hal, cmd1394_cmd_t *cmd, uint_t flags)
1372 {
1373 cmd1394_cmd_t *temp_cmd;
1374 s1394_cmd_priv_t *s_priv;
1375 s1394_cmd_priv_t *c_priv;
1376
1377 mutex_enter(&hal->pending_q_mutex);
1378
1379 /* Get the Services Layer private area */
1380 s_priv = S1394_GET_CMD_PRIV(cmd);
1381
1382 /* Is the outstanding request queue empty? */
1383 if ((hal->pending_q_head == NULL) && (hal->pending_q_tail == NULL)) {
1384
1385 hal->pending_q_head = (cmd1394_cmd_t *)cmd;
1386 hal->pending_q_tail = (cmd1394_cmd_t *)cmd;
1387 s_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
1388 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
1389
1390 } else if (flags == S1394_PENDING_Q_FRONT) {
1391 s_priv->cmd_priv_next = hal->pending_q_head;
1392 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
1393
1394 temp_cmd = (cmd1394_cmd_t *)hal->pending_q_head;
1395 c_priv = (s1394_cmd_priv_t *)((uchar_t *)temp_cmd +
1396 sizeof (cmd1394_cmd_t));
1397 c_priv->cmd_priv_prev = (cmd1394_cmd_t *)cmd;
1398
1399 hal->pending_q_head = (cmd1394_cmd_t *)cmd;
1400
1401 } else {
1402 s_priv->cmd_priv_prev = hal->pending_q_tail;
1403 s_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
1404
1405 temp_cmd = (cmd1394_cmd_t *)hal->pending_q_tail;
1406 c_priv = (s1394_cmd_priv_t *)((uchar_t *)temp_cmd +
1407 sizeof (cmd1394_cmd_t));
1408 c_priv->cmd_priv_next = (cmd1394_cmd_t *)cmd;
1409
1410 hal->pending_q_tail = (cmd1394_cmd_t *)cmd;
1411 }
1412
1413 mutex_exit(&hal->pending_q_mutex);
1414
1415 /* kstats - number of pending Q insertions */
1416 hal->hal_kstats->pending_q_insert++;
1417 }
1418
1419 /*
1420 * s1394_pending_q_remove()
1421 * is used to remove a command structure from a HAL's pending queue for
1422 * processing.
1423 */
1424 static cmd1394_cmd_t *
1425 s1394_pending_q_remove(s1394_hal_t *hal)
1426 {
1427 s1394_cmd_priv_t *s_priv;
1428 s1394_cmd_priv_t *c_priv;
1429 cmd1394_cmd_t *cmd;
1430 cmd1394_cmd_t *prev_cmd;
1431
1432 mutex_enter(&hal->pending_q_mutex);
1433
1434 cmd = (cmd1394_cmd_t *)hal->pending_q_tail;
1435 if (cmd == NULL) {
1436 mutex_exit(&hal->pending_q_mutex);
1437 return (NULL);
1438 }
1439
1440 /* Get the Services Layer private area */
1441 s_priv = S1394_GET_CMD_PRIV(cmd);
1442
1443 prev_cmd = (cmd1394_cmd_t *)s_priv->cmd_priv_prev;
1444
1445 s_priv->cmd_priv_prev = (cmd1394_cmd_t *)NULL;
1446 s_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
1447
1448 if (prev_cmd != NULL) {
1449 c_priv = (s1394_cmd_priv_t *)((uchar_t *)prev_cmd +
1450 sizeof (cmd1394_cmd_t));
1451 c_priv->cmd_priv_next = (cmd1394_cmd_t *)NULL;
1452
1453 } else {
1454 hal->pending_q_head = (cmd1394_cmd_t *)NULL;
1455 }
1456 hal->pending_q_tail = (cmd1394_cmd_t *)prev_cmd;
1457
1458 mutex_exit(&hal->pending_q_mutex);
1459
1460 return (cmd);
1461 }
1462
1463 /*
1464 * s1394_resend_pending_cmds()
1465 * is called when the pending queue is to be flushed. After most of the
1466 * bus reset processing is completed, the pending commands are sent/resent.
1467 */
1468 void
1469 s1394_resend_pending_cmds(s1394_hal_t *hal)
1470 {
1471 int done;
1472
1473 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1474
1475 do {
1476 done = s1394_process_pending_q(hal);
1477 } while (done == B_FALSE);
1478
1479 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1480 }
1481
1482 /*
1483 * s1394_process_pending_q()
1484 * is called to send/resend the commands on the pending queue. All command
1485 * handling can be done here, including notifying the target of failed
1486 * commands, etc. If it is necessary to recompute the address, speed,
1487 * or max_payload for a command, that can be done here too. And if there
1488 * is no reason not to continue sending commands from the pending queue,
1489 * then a B_FALSE is returned, else B_TRUE is returned.
1490 */
1491 static boolean_t
1492 s1394_process_pending_q(s1394_hal_t *hal)
1493 {
1494 s1394_cmd_priv_t *s_priv;
1495 h1394_cmd_priv_t *h_priv;
1496 s1394_target_t *target;
1497 cmd1394_cmd_t *cmd;
1498 uint64_t node;
1499 uint32_t from_node;
1500 uint32_t to_node;
1501 uint_t current_max_payload;
1502 int ret;
1503
1504 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1505
1506 /* Pull a command from the Pending Q */
1507 cmd = s1394_pending_q_remove(hal);
1508
1509 if (cmd == NULL) {
1510 return (B_TRUE);
1511 }
1512
1513 /* Get the Services Layer private area */
1514 s_priv = S1394_GET_CMD_PRIV(cmd);
1515
1516 /* Get a pointer to the HAL private struct */
1517 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
1518
1519 if ((cmd->cmd_options & CMD1394_OVERRIDE_ADDR) ||
1520 (cmd->cmd_options & CMD1394_CANCEL_ON_BUS_RESET)) {
1521 if (h_priv->bus_generation == hal->generation_count) {
1522 ret = s1394_pending_q_helper(hal, cmd);
1523 return (ret);
1524 } else {
1525
1526 s_priv->cmd_in_use = B_FALSE;
1527
1528 cmd->cmd_result = CMD1394_EBUSRESET;
1529
1530 /* Is this a blocking command? */
1531 if (cmd->cmd_options & CMD1394_BLOCKING) {
1532 /* Unblock the waiting command */
1533 mutex_enter(&s_priv->blocking_mutex);
1534 s_priv->blocking_flag = B_TRUE;
1535 cv_signal(&s_priv->blocking_cv);
1536 mutex_exit(&s_priv->blocking_mutex);
1537
1538 return (B_FALSE);
1539 }
1540
1541 /* Call the target's completion_callback() */
1542 if (cmd->completion_callback != NULL) {
1543 cmd->completion_callback(cmd);
1544 }
1545
1546 return (B_FALSE);
1547 }
1548 } else {
1549 if (h_priv->bus_generation == hal->generation_count) {
1550 ret = s1394_pending_q_helper(hal, cmd);
1551 return (ret);
1552 } else {
1553 /* Make sure we can get the topology_tree_mutex */
1554 if (s1394_lock_tree(hal) != DDI_SUCCESS)
1555 return (B_TRUE);
1556
1557 /* Set the generation */
1558 cmd->bus_generation = hal->generation_count;
1559
1560 /* Copy the generation into the HAL's private field */
1561 h_priv->bus_generation = cmd->bus_generation;
1562
1563 target = s_priv->sent_by_target;
1564
1565 /* If not OVERRIDE_ADDR, then target may not be NULL */
1566 ASSERT(target != NULL);
1567
1568 rw_enter(&hal->target_list_rwlock, RW_READER);
1569
1570 if (((target->target_state & S1394_TARG_GONE) == 0) &&
1571 (target->on_node != NULL)) {
1572 node = target->on_node->node_num;
1573 rw_exit(&hal->target_list_rwlock);
1574 } else {
1575 rw_exit(&hal->target_list_rwlock);
1576
1577 s_priv->cmd_in_use = B_FALSE;
1578
1579 cmd->cmd_result = CMD1394_EDEVICE_REMOVED;
1580
1581 /* Is this a blocking command? */
1582 if (cmd->cmd_options & CMD1394_BLOCKING) {
1583 s1394_unlock_tree(hal);
1584
1585 /* Unblock the waiting command */
1586 mutex_enter(&s_priv->blocking_mutex);
1587 s_priv->blocking_flag = B_TRUE;
1588 cv_signal(&s_priv->blocking_cv);
1589 mutex_exit(&s_priv->blocking_mutex);
1590
1591 return (B_FALSE);
1592 }
1593
1594 /* Call the target's completion_callback() */
1595 if (cmd->completion_callback != NULL) {
1596 s1394_unlock_tree(hal);
1597 cmd->completion_callback(cmd);
1598 return (B_FALSE);
1599 } else {
1600 s1394_unlock_tree(hal);
1601 return (B_FALSE);
1602 }
1603 }
1604
1605 /* Mask in the top 16-bits */
1606 cmd->cmd_addr = cmd->cmd_addr &
1607 IEEE1394_ADDR_OFFSET_MASK;
1608 cmd->cmd_addr = cmd->cmd_addr |
1609 (node << IEEE1394_ADDR_PHY_ID_SHIFT);
1610 cmd->cmd_addr = cmd->cmd_addr |
1611 IEEE1394_ADDR_BUS_ID_MASK;
1612
1613 /* Speed is to be filled in from speed map */
1614 from_node = IEEE1394_NODE_NUM(hal->node_id);
1615 to_node = (uint32_t)node;
1616
1617 /* Fill in the nodeID */
1618 cmd->nodeID =
1619 (cmd->cmd_addr & IEEE1394_ADDR_NODE_ID_MASK) >>
1620 IEEE1394_ADDR_NODE_ID_SHIFT;
1621
1622 if (cmd->cmd_options & CMD1394_OVERRIDE_SPEED) {
1623 s_priv->hal_cmd_private.speed =
1624 (int)cmd->cmd_speed;
1625 } else {
1626 /* Speed is to be filled in from speed map */
1627 s_priv->hal_cmd_private.speed =
1628 (int)s1394_speed_map_get(hal, from_node,
1629 to_node);
1630 }
1631
1632 /* Is it a block request? */
1633 if ((cmd->cmd_type == CMD1394_ASYNCH_RD_BLOCK) ||
1634 (cmd->cmd_type == CMD1394_ASYNCH_WR_BLOCK)) {
1635
1636 /* Get a pointer to the HAL private struct */
1637 h_priv = (h1394_cmd_priv_t *)&s_priv->
1638 hal_cmd_private;
1639
1640 /* Handle the MAX_PAYLOAD size */
1641 if (s_priv->sent_by_target != NULL) {
1642 current_max_payload =
1643 s_priv->sent_by_target->
1644 current_max_payload;
1645 } else {
1646 current_max_payload = 4;
1647 }
1648 if (cmd->cmd_options &
1649 CMD1394_OVERRIDE_MAX_PAYLOAD) {
1650 if (current_max_payload >
1651 cmd->cmd_u.b.max_payload)
1652 current_max_payload =
1653 cmd->cmd_u.b.max_payload;
1654 }
1655 if (s_priv->data_remaining <
1656 current_max_payload) {
1657 h_priv->mblk.length =
1658 s_priv->data_remaining;
1659 } else {
1660 h_priv->mblk.length =
1661 current_max_payload;
1662 }
1663 }
1664 s1394_unlock_tree(hal);
1665 ret = s1394_pending_q_helper(hal, cmd);
1666 return (ret);
1667 }
1668 }
1669 }
1670
1671 /*
1672 * s1394_pending_q_helper()
1673 * is a "helper" function for s1394_process_pending_q(). It attempts to
1674 * resend commands, handling error conditions whenever necessary.
1675 */
1676 static boolean_t
1677 s1394_pending_q_helper(s1394_hal_t *hal, cmd1394_cmd_t *cmd)
1678 {
1679 s1394_cmd_priv_t *s_priv;
1680 int err;
1681 int ret;
1682
1683 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));
1684
1685 /* Get the Services Layer private area */
1686 s_priv = S1394_GET_CMD_PRIV(cmd);
1687
1688 /* Put cmd on outstanding request Q */
1689 s1394_insert_q_asynch_cmd(hal, cmd);
1690
1691 /* Send command out again */
1692 ret = s1394_xfer_asynch_command(hal, cmd, &err);
1693
1694 if (ret != DDI_SUCCESS) {
1695 if (err == CMD1394_ESTALE_GENERATION) {
1696 /* Remove cmd outstanding req Q */
1697 s1394_remove_q_asynch_cmd(hal, cmd);
1698 s1394_pending_q_insert(hal, cmd, S1394_PENDING_Q_FRONT);
1699
1700 return (B_TRUE);
1701 } else {
1702 /* Remove cmd from outstanding request Q */
1703 s1394_remove_q_asynch_cmd(hal, cmd);
1704
1705 s_priv->cmd_in_use = B_FALSE;
1706
1707 cmd->cmd_result = err;
1708
1709 /* Is this a blocking command? */
1710 if (cmd->cmd_options & CMD1394_BLOCKING) {
1711 /* Unblock waiting command */
1712 mutex_enter(&s_priv->blocking_mutex);
1713 s_priv->blocking_flag = B_TRUE;
1714 cv_signal(&s_priv->blocking_cv);
1715 mutex_exit(&s_priv->blocking_mutex);
1716
1717 return (B_FALSE);
1718 }
1719
1720 /* Call target completion_callback() */
1721 if (cmd->completion_callback != NULL) {
1722 cmd->completion_callback(cmd);
1723 return (B_FALSE);
1724 } else {
1725 return (B_FALSE);
1726 }
1727 }
1728 }
1729
1730 return (B_FALSE);
1731 }
1732
1733 /*
1734 * s1394_process_split_lock()
1735 * is a "helper" function for the s1394_handle_lock() callback. Its
1736 * job is to perform whatever manipulation is required for the given
1737 * request.
1738 */
1739 static int
1740 s1394_process_split_lock(cmd1394_cmd_t *cmd, cmd1394_cmd_t *target_cmd)
1741 {
1742 uint64_t new_value64;
1743 uint64_t data_value64;
1744 uint64_t arg_value64;
1745 uint64_t old_value64;
1746 uint64_t temp_value64;
1747 uint32_t new_value32;
1748 uint32_t data_value32;
1749 uint32_t arg_value32;
1750 uint32_t old_value32;
1751 uint32_t temp_value32;
1752
1753 if (cmd->cmd_type == CMD1394_ASYNCH_LOCK_32) {
1754 old_value32 = cmd->cmd_u.l32.old_value;
1755 data_value32 = target_cmd->cmd_u.l32.data_value;
1756 arg_value32 = target_cmd->cmd_u.l32.arg_value;
1757
1758 /* Lock type specific */
1759 switch (target_cmd->cmd_u.l32.lock_type) {
1760 case CMD1394_LOCK_BIT_AND:
1761 new_value32 = old_value32 & data_value32;
1762 break;
1763
1764 case CMD1394_LOCK_BIT_OR:
1765 new_value32 = old_value32 | data_value32;
1766 break;
1767
1768 case CMD1394_LOCK_BIT_XOR:
1769 new_value32 = old_value32 ^ data_value32;
1770 break;
1771
1772 case CMD1394_LOCK_INCREMENT:
1773 old_value32 = T1394_DATA32(old_value32);
1774 new_value32 = old_value32 + 1;
1775 new_value32 = T1394_DATA32(new_value32);
1776 old_value32 = T1394_DATA32(old_value32);
1777 break;
1778
1779 case CMD1394_LOCK_DECREMENT:
1780 old_value32 = T1394_DATA32(old_value32);
1781 new_value32 = old_value32 - 1;
1782 new_value32 = T1394_DATA32(new_value32);
1783 old_value32 = T1394_DATA32(old_value32);
1784 break;
1785
1786 case CMD1394_LOCK_ADD:
1787 old_value32 = T1394_DATA32(old_value32);
1788 new_value32 = old_value32 + data_value32;
1789 new_value32 = T1394_DATA32(new_value32);
1790 old_value32 = T1394_DATA32(old_value32);
1791 break;
1792
1793 case CMD1394_LOCK_SUBTRACT:
1794 old_value32 = T1394_DATA32(old_value32);
1795 new_value32 = old_value32 - data_value32;
1796 new_value32 = T1394_DATA32(new_value32);
1797 old_value32 = T1394_DATA32(old_value32);
1798 break;
1799
1800 case CMD1394_LOCK_THRESH_ADD:
1801 old_value32 = T1394_DATA32(old_value32);
1802 temp_value32 = (old_value32 + data_value32);
1803 if ((temp_value32 >= old_value32) &&
1804 (temp_value32 <= arg_value32)) {
1805 new_value32 = T1394_DATA32(temp_value32);
1806 old_value32 = T1394_DATA32(old_value32);
1807 } else {
1808 /* Failed threshold add */
1809 target_cmd->cmd_u.l32.old_value =
1810 T1394_DATA32(cmd->cmd_u.l32.old_value);
1811 target_cmd->cmd_result = CMD1394_CMDSUCCESS;
1812 return (DDI_FAILURE);
1813 }
1814 break;
1815
1816 case CMD1394_LOCK_THRESH_SUBTRACT:
1817 old_value32 = T1394_DATA32(old_value32);
1818 temp_value32 = (old_value32 - data_value32);
1819 if ((old_value32 >= data_value32) &&
1820 (temp_value32 >= arg_value32)) {
1821 new_value32 = T1394_DATA32(temp_value32);
1822 old_value32 = T1394_DATA32(old_value32);
1823 } else {
1824 /* Failed threshold subtract */
1825 target_cmd->cmd_u.l32.old_value =
1826 T1394_DATA32(cmd->cmd_u.l32.old_value);
1827 target_cmd->cmd_result = CMD1394_CMDSUCCESS;
1828 return (DDI_FAILURE);
1829 }
1830 break;
1831
1832 case CMD1394_LOCK_CLIP_ADD:
1833 old_value32 = T1394_DATA32(old_value32);
1834 temp_value32 = (old_value32 + data_value32);
1835 if ((temp_value32 < old_value32) ||
1836 (temp_value32 > arg_value32))
1837 new_value32 = T1394_DATA32(arg_value32);
1838 else
1839 new_value32 = T1394_DATA32(temp_value32);
1840 old_value32 = T1394_DATA32(old_value32);
1841 break;
1842
1843 case CMD1394_LOCK_CLIP_SUBTRACT:
1844 old_value32 = T1394_DATA32(old_value32);
1845 temp_value32 = (old_value32 - data_value32);
1846 if ((data_value32 > old_value32) ||
1847 (temp_value32 < arg_value32))
1848 new_value32 = T1394_DATA32(arg_value32);
1849 else
1850 new_value32 = T1394_DATA32(temp_value32);
1851 old_value32 = T1394_DATA32(old_value32);
1852 break;
1853 }
1854
1855 /* Send compare-swap lock request */
1856 cmd->cmd_u.l32.arg_value = old_value32;
1857 cmd->cmd_u.l32.data_value = new_value32;
1858 } else {
1859 old_value64 = cmd->cmd_u.l64.old_value;
1860 data_value64 = target_cmd->cmd_u.l64.data_value;
1861 arg_value64 = target_cmd->cmd_u.l64.arg_value;
1862
1863 /* Lock type specific */
1864 switch (target_cmd->cmd_u.l64.lock_type) {
1865 case CMD1394_LOCK_BIT_AND:
1866 new_value64 = old_value64 & data_value64;
1867 break;
1868
1869 case CMD1394_LOCK_BIT_OR:
1870 new_value64 = old_value64 | data_value64;
1871 break;
1872
1873 case CMD1394_LOCK_BIT_XOR:
1874 new_value64 = old_value64 ^ data_value64;
1875 break;
1876
1877 case CMD1394_LOCK_INCREMENT:
1878 old_value64 = T1394_DATA64(old_value64);
1879 new_value64 = old_value64 + 1;
1880 new_value64 = T1394_DATA64(new_value64);
1881 old_value64 = T1394_DATA64(old_value64);
1882 break;
1883
1884 case CMD1394_LOCK_DECREMENT:
1885 old_value64 = T1394_DATA64(old_value64);
1886 new_value64 = old_value64 - 1;
1887 new_value64 = T1394_DATA64(new_value64);
1888 old_value64 = T1394_DATA64(old_value64);
1889 break;
1890
1891 case CMD1394_LOCK_ADD:
1892 old_value64 = T1394_DATA64(old_value64);
1893 new_value64 = old_value64 + data_value64;
1894 new_value64 = T1394_DATA64(new_value64);
1895 old_value64 = T1394_DATA64(old_value64);
1896 break;
1897
1898 case CMD1394_LOCK_SUBTRACT:
1899 old_value64 = T1394_DATA64(old_value64);
1900 new_value64 = old_value64 - data_value64;
1901 new_value64 = T1394_DATA64(new_value64);
1902 old_value64 = T1394_DATA64(old_value64);
1903 break;
1904
1905 case CMD1394_LOCK_THRESH_ADD:
1906 old_value64 = T1394_DATA64(old_value64);
1907 temp_value64 = (old_value64 + data_value64);
1908 if ((temp_value64 >= old_value64) &&
1909 (temp_value64 <= arg_value64)) {
1910 new_value64 = T1394_DATA64(temp_value64);
1911 old_value64 = T1394_DATA64(old_value64);
1912 } else {
1913 /* Failed threshold add */
1914 target_cmd->cmd_u.l64.old_value =
1915 T1394_DATA64(cmd->cmd_u.l64.old_value);
1916 target_cmd->cmd_result = CMD1394_CMDSUCCESS;
1917 return (DDI_FAILURE);
1918 }
1919 break;
1920
1921 case CMD1394_LOCK_THRESH_SUBTRACT:
1922 old_value64 = T1394_DATA64(old_value64);
1923 temp_value64 = (old_value64 - data_value64);
1924 if ((old_value64 >= data_value64) &&
1925 (temp_value64 >= arg_value64)) {
1926 new_value64 = T1394_DATA64(temp_value64);
1927 old_value64 = T1394_DATA64(old_value64);
1928 } else {
1929 /* Failed threshold subtract */
1930 target_cmd->cmd_u.l64.old_value =
1931 T1394_DATA64(cmd->cmd_u.l64.old_value);
1932 target_cmd->cmd_result = CMD1394_CMDSUCCESS;
1933 return (DDI_FAILURE);
1934 }
1935 break;
1936
1937 case CMD1394_LOCK_CLIP_ADD:
1938 old_value64 = T1394_DATA64(old_value64);
1939 temp_value64 = (old_value64 + data_value64);
1940 if ((temp_value64 < old_value64) ||
1941 (temp_value64 > arg_value64))
1942 new_value64 = T1394_DATA64(arg_value64);
1943 else
1944 new_value64 = T1394_DATA64(temp_value64);
1945 old_value64 = T1394_DATA64(old_value64);
1946 break;
1947
1948 case CMD1394_LOCK_CLIP_SUBTRACT:
1949 old_value64 = T1394_DATA64(old_value64);
1950 temp_value64 = (old_value64 - data_value64);
1951 if ((data_value64 > old_value64) ||
1952 (temp_value64 < arg_value64))
1953 new_value64 = T1394_DATA64(arg_value64);
1954 else
1955 new_value64 = T1394_DATA64(temp_value64);
1956 old_value64 = T1394_DATA64(old_value64);
1957 break;
1958 }
1959
1960 /* Send compare-swap lock request */
1961 cmd->cmd_u.l64.arg_value = old_value64;
1962 cmd->cmd_u.l64.data_value = new_value64;
1963 }
1964
1965 return (DDI_SUCCESS);
1966 }
1967
1968 /*
1969 * s1394_finish_split_lock()
1970 * is another "helper" function for the s1394_handle_lock() callback.
1971 * Its job is to finish up whatever lock request procesing is necessary.
1972 */
1973 static int
1974 s1394_finish_split_lock(cmd1394_cmd_t *cmd, cmd1394_cmd_t *target_cmd)
1975 {
1976 s1394_cmd_priv_t *s_priv;
1977 uint64_t tmp_value64;
1978 uint32_t tmp_value32;
1979
1980 /* Get the Services Layer private area */
1981 s_priv = S1394_GET_CMD_PRIV(cmd);
1982
1983 if (((cmd->cmd_type == CMD1394_ASYNCH_LOCK_32) &&
1984 (cmd->cmd_u.l32.old_value == cmd->cmd_u.l32.arg_value)) ||
1985 ((cmd->cmd_type == CMD1394_ASYNCH_LOCK_64) &&
1986 (cmd->cmd_u.l64.old_value == cmd->cmd_u.l64.arg_value))) {
1987
1988 if (cmd->cmd_type == CMD1394_ASYNCH_LOCK_32) {
1989 switch (cmd->cmd_u.l32.lock_type) {
1990 case CMD1394_LOCK_INCREMENT:
1991 case CMD1394_LOCK_DECREMENT:
1992 case CMD1394_LOCK_ADD:
1993 case CMD1394_LOCK_SUBTRACT:
1994 case CMD1394_LOCK_THRESH_ADD:
1995 case CMD1394_LOCK_THRESH_SUBTRACT:
1996 case CMD1394_LOCK_CLIP_ADD:
1997 case CMD1394_LOCK_CLIP_SUBTRACT:
1998 tmp_value32 = cmd->cmd_u.l32.old_value;
1999 tmp_value32 = T1394_DATA32(tmp_value32);
2000 target_cmd->cmd_u.l32.old_value = tmp_value32;
2001 break;
2002 default:
2003 tmp_value32 = cmd->cmd_u.l32.old_value;
2004 target_cmd->cmd_u.l32.old_value = tmp_value32;
2005 break;
2006 }
2007 } else {
2008 switch (cmd->cmd_u.l64.lock_type) {
2009 case CMD1394_LOCK_INCREMENT:
2010 case CMD1394_LOCK_DECREMENT:
2011 case CMD1394_LOCK_ADD:
2012 case CMD1394_LOCK_SUBTRACT:
2013 case CMD1394_LOCK_THRESH_ADD:
2014 case CMD1394_LOCK_THRESH_SUBTRACT:
2015 case CMD1394_LOCK_CLIP_ADD:
2016 case CMD1394_LOCK_CLIP_SUBTRACT:
2017 tmp_value64 = cmd->cmd_u.l64.old_value;
2018 tmp_value64 = T1394_DATA64(tmp_value64);
2019 target_cmd->cmd_u.l64.old_value = tmp_value64;
2020 break;
2021 default:
2022 tmp_value64 = cmd->cmd_u.l64.old_value;
2023 target_cmd->cmd_u.l64.old_value = tmp_value64;
2024 break;
2025 }
2026 }
2027 /* Set status */
2028 target_cmd->cmd_result = CMD1394_CMDSUCCESS;
2029 return (DDI_SUCCESS);
2030 } else {
2031 if (s_priv->temp_num_retries > 0) {
2032 /* Decrement retry count */
2033 s_priv->temp_num_retries--;
2034
2035 /* Reset lock_req_step */
2036 s_priv->lock_req_step = 0;
2037
2038 /* Resend... start at step 0 again */
2039
2040 return (DDI_FAILURE);
2041 } else {
2042 /* Failed... RETRIES_EXCEEDED */
2043 target_cmd->cmd_result = CMD1394_ERETRIES_EXCEEDED;
2044 return (DDI_SUCCESS);
2045 }
2046 }
2047 }