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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * t1394.c 31 * 1394 Target Driver Interface 32 * This file contains all of the 1394 Software Framework routines called 33 * by target drivers 34 */ 35 36 #include <sys/conf.h> 37 #include <sys/ddi.h> 38 #include <sys/sunddi.h> 39 #include <sys/types.h> 40 #include <sys/kmem.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 48 static int s1394_allow_detach = 0; 49 50 /* 51 * Function: t1394_attach() 52 * Input(s): dip The dip given to the target driver 53 * in it's attach() routine 54 * version The version of the target driver - 55 * T1394_VERSION_V1 56 * flags The flags parameter is unused (for now) 57 * 58 * Output(s): attachinfo Used to pass info back to target, 59 * including bus generation, local 60 * node ID, dma attribute, etc. 61 * t1394_hdl The target "handle" to be used for 62 * all subsequent calls into the 63 * 1394 Software Framework 64 * 65 * Description: t1394_attach() registers the target (based on its dip) with 66 * the 1394 Software Framework. It returns the bus_generation, 67 * local_nodeID, iblock_cookie and other useful information to 68 * the target, as well as a handle (t1394_hdl) that will be used 69 * in all subsequent calls into this framework. 70 */ 71 /* ARGSUSED */ 72 int 73 t1394_attach(dev_info_t *dip, int version, uint_t flags, 74 t1394_attachinfo_t *attachinfo, t1394_handle_t *t1394_hdl) 75 { 76 s1394_hal_t *hal; 77 s1394_target_t *target; 78 uint_t dev; 79 uint_t curr; 80 uint_t unit_dir; 81 int hp_node = 0; 82 83 ASSERT(t1394_hdl != NULL); 84 ASSERT(attachinfo != NULL); 85 86 TNF_PROBE_0_DEBUG(t1394_attach_enter, S1394_TNF_SL_HOTPLUG_STACK, ""); 87 88 *t1394_hdl = NULL; 89 90 if (version != T1394_VERSION_V1) { 91 TNF_PROBE_1(t1394_attach_error, S1394_TNF_SL_HOTPLUG_ERROR, "", 92 tnf_string, msg, "Invalid version"); 93 TNF_PROBE_0_DEBUG(t1394_attach_exit, 94 S1394_TNF_SL_HOTPLUG_STACK, ""); 95 return (DDI_FAILURE); 96 } 97 98 hal = s1394_dip_to_hal(ddi_get_parent(dip)); 99 if (hal == NULL) { 100 TNF_PROBE_1(t1394_attach_error, S1394_TNF_SL_HOTPLUG_ERROR, "", 101 tnf_string, msg, "No parent dip found for target"); 102 TNF_PROBE_0_DEBUG(t1394_attach_exit, 103 S1394_TNF_SL_HOTPLUG_STACK, ""); 104 return (DDI_FAILURE); 105 } 106 107 ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex)); 108 109 hp_node = ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 110 "hp-node"); 111 112 /* Allocate space for s1394_target_t */ 113 target = kmem_zalloc(sizeof (s1394_target_t), KM_SLEEP); 114 115 mutex_enter(&hal->topology_tree_mutex); 116 117 target->target_version = version; 118 119 /* Copy in the params */ 120 target->target_dip = dip; 121 target->on_hal = hal; 122 123 /* Place the target on the appropriate node */ 124 target->on_node = NULL; 125 126 rw_enter(&target->on_hal->target_list_rwlock, RW_WRITER); 127 if (hp_node != 0) { 128 s1394_add_target_to_node(target); 129 /* 130 * on_node can be NULL if the node got unplugged 131 * while the target driver is in its attach routine. 132 */ 133 if (target->on_node == NULL) { 134 s1394_remove_target_from_node(target); 135 rw_exit(&target->on_hal->target_list_rwlock); 136 mutex_exit(&hal->topology_tree_mutex); 137 kmem_free(target, sizeof (s1394_target_t)); 138 TNF_PROBE_1(t1394_attach_error, 139 S1394_TNF_SL_HOTPLUG_ERROR, "", tnf_string, msg, 140 "on_node == NULL"); 141 TNF_PROBE_0_DEBUG(t1394_attach_exit, 142 S1394_TNF_SL_HOTPLUG_STACK, ""); 143 return (DDI_FAILURE); 144 } 145 146 target->target_state = S1394_TARG_HP_NODE; 147 if (S1394_NODE_BUS_PWR_CONSUMER(target->on_node) == B_TRUE) 148 target->target_state |= S1394_TARG_BUS_PWR_CONSUMER; 149 } 150 151 /* Return the current generation */ 152 attachinfo->localinfo.bus_generation = target->on_hal->generation_count; 153 154 /* Fill in hal node id */ 155 attachinfo->localinfo.local_nodeID = target->on_hal->node_id; 156 157 /* Give the target driver the iblock_cookie */ 158 attachinfo->iblock_cookie = target->on_hal->halinfo.hw_interrupt; 159 160 /* Give the target driver the attributes */ 161 attachinfo->acc_attr = target->on_hal->halinfo.acc_attr; 162 attachinfo->dma_attr = target->on_hal->halinfo.dma_attr; 163 164 unit_dir = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 165 DDI_PROP_DONTPASS, "unit-dir-offset", 0); 166 target->unit_dir = unit_dir; 167 168 /* By default, disable all physical AR requests */ 169 target->physical_arreq_enabled = 0; 170 171 172 /* Get dev_max_payload & current_max_payload */ 173 s1394_get_maxpayload(target, &dev, &curr); 174 target->dev_max_payload = dev; 175 target->current_max_payload = curr; 176 177 /* Add into linked list */ 178 if ((target->on_hal->target_head == NULL) && 179 (target->on_hal->target_tail == NULL)) { 180 target->on_hal->target_head = target; 181 target->on_hal->target_tail = target; 182 } else { 183 target->on_hal->target_tail->target_next = target; 184 target->target_prev = target->on_hal->target_tail; 185 target->on_hal->target_tail = target; 186 } 187 rw_exit(&target->on_hal->target_list_rwlock); 188 189 /* Fill in services layer private info */ 190 *t1394_hdl = (t1394_handle_t)target; 191 192 mutex_exit(&hal->topology_tree_mutex); 193 194 TNF_PROBE_0_DEBUG(t1394_attach_exit, S1394_TNF_SL_HOTPLUG_STACK, ""); 195 return (DDI_SUCCESS); 196 } 197 198 /* 199 * Function: t1394_detach() 200 * Input(s): t1394_hdl The target "handle" returned by 201 * t1394_attach() 202 * flags The flags parameter is unused (for now) 203 * 204 * Output(s): DDI_SUCCESS Target successfully detached 205 * DDI_FAILURE Target failed to detach 206 * 207 * Description: t1394_detach() unregisters the target from the 1394 Software 208 * Framework. t1394_detach() can fail if the target has any 209 * allocated commands that haven't been freed. 210 */ 211 /* ARGSUSED */ 212 int 213 t1394_detach(t1394_handle_t *t1394_hdl, uint_t flags) 214 { 215 s1394_target_t *target; 216 uint_t num_cmds; 217 218 TNF_PROBE_0_DEBUG(t1394_detach_enter, S1394_TNF_SL_HOTPLUG_STACK, ""); 219 220 ASSERT(t1394_hdl != NULL); 221 222 target = (s1394_target_t *)(*t1394_hdl); 223 224 ASSERT(target->on_hal); 225 226 mutex_enter(&target->on_hal->topology_tree_mutex); 227 rw_enter(&target->on_hal->target_list_rwlock, RW_WRITER); 228 229 /* How many cmds has this target allocated? */ 230 num_cmds = target->target_num_cmds; 231 232 if (num_cmds != 0) { 233 rw_exit(&target->on_hal->target_list_rwlock); 234 mutex_exit(&target->on_hal->topology_tree_mutex); 235 TNF_PROBE_1(t1394_detach_error, S1394_TNF_SL_HOTPLUG_ERROR, "", 236 tnf_string, msg, "Must free all commands before detach()"); 237 TNF_PROBE_0_DEBUG(t1394_detach_exit, 238 S1394_TNF_SL_HOTPLUG_STACK, ""); 239 return (DDI_FAILURE); 240 } 241 242 /* 243 * Remove from linked lists. Topology tree is already locked 244 * so that the node won't go away while we are looking at it. 245 */ 246 if ((target->on_hal->target_head == target) && 247 (target->on_hal->target_tail == target)) { 248 target->on_hal->target_head = NULL; 249 target->on_hal->target_tail = NULL; 250 } else { 251 if (target->target_prev) 252 target->target_prev->target_next = target->target_next; 253 if (target->target_next) 254 target->target_next->target_prev = target->target_prev; 255 if (target->on_hal->target_head == target) 256 target->on_hal->target_head = target->target_next; 257 if (target->on_hal->target_tail == target) 258 target->on_hal->target_tail = target->target_prev; 259 } 260 261 s1394_remove_target_from_node(target); 262 rw_exit(&target->on_hal->target_list_rwlock); 263 264 mutex_exit(&target->on_hal->topology_tree_mutex); 265 266 /* Free memory */ 267 kmem_free(target, sizeof (s1394_target_t)); 268 269 *t1394_hdl = NULL; 270 271 TNF_PROBE_0_DEBUG(t1394_detach_exit, S1394_TNF_SL_HOTPLUG_STACK, ""); 272 return (DDI_SUCCESS); 273 } 274 275 /* 276 * Function: t1394_alloc_cmd() 277 * Input(s): t1394_hdl The target "handle" returned by 278 * t1394_attach() 279 * flags The flags parameter is described below 280 * 281 * Output(s): cmdp Pointer to the newly allocated command 282 * 283 * Description: t1394_alloc_cmd() allocates a command for use with the 284 * t1394_read(), t1394_write(), or t1394_lock() interfaces 285 * of the 1394 Software Framework. By default, t1394_alloc_cmd() 286 * may sleep while allocating memory for the command structure. 287 * If this is undesirable, the target may set the 288 * T1394_ALLOC_CMD_NOSLEEP bit in the flags parameter. Also, 289 * this call may fail because a target driver has already 290 * allocated MAX_NUMBER_ALLOC_CMDS commands. 291 */ 292 int 293 t1394_alloc_cmd(t1394_handle_t t1394_hdl, uint_t flags, cmd1394_cmd_t **cmdp) 294 { 295 s1394_hal_t *hal; 296 s1394_target_t *target; 297 s1394_cmd_priv_t *s_priv; 298 uint_t num_cmds; 299 300 TNF_PROBE_0_DEBUG(t1394_alloc_cmd_enter, S1394_TNF_SL_ATREQ_STACK, ""); 301 302 ASSERT(t1394_hdl != NULL); 303 304 target = (s1394_target_t *)t1394_hdl; 305 306 /* Find the HAL this target resides on */ 307 hal = target->on_hal; 308 309 rw_enter(&hal->target_list_rwlock, RW_WRITER); 310 311 /* How many cmds has this target allocated? */ 312 num_cmds = target->target_num_cmds; 313 314 if (num_cmds >= MAX_NUMBER_ALLOC_CMDS) { 315 rw_exit(&hal->target_list_rwlock); 316 TNF_PROBE_1(t1394_alloc_cmd_error, S1394_TNF_SL_ATREQ_ERROR, 317 "", tnf_string, msg, "Attempted to alloc > " 318 "MAX_NUMBER_ALLOC_CMDS"); 319 TNF_PROBE_0_DEBUG(t1394_alloc_cmd_exit, 320 S1394_TNF_SL_ATREQ_STACK, ""); 321 /* kstats - cmd alloc failures */ 322 hal->hal_kstats->cmd_alloc_fail++; 323 return (DDI_FAILURE); 324 } 325 326 /* Increment the number of cmds this target has allocated? */ 327 target->target_num_cmds = num_cmds + 1; 328 329 if (s1394_alloc_cmd(hal, flags, cmdp) != DDI_SUCCESS) { 330 target->target_num_cmds = num_cmds; /* Undo increment */ 331 rw_exit(&hal->target_list_rwlock); 332 TNF_PROBE_1(t1394_alloc_cmd_error, S1394_TNF_SL_ATREQ_ERROR, "", 333 tnf_string, msg, "Failed to allocate command structure"); 334 TNF_PROBE_0_DEBUG(t1394_alloc_cmd_exit, 335 S1394_TNF_SL_ATREQ_STACK, ""); 336 /* kstats - cmd alloc failures */ 337 hal->hal_kstats->cmd_alloc_fail++; 338 return (DDI_FAILURE); 339 } 340 341 rw_exit(&hal->target_list_rwlock); 342 343 /* Get the Services Layer private area */ 344 s_priv = S1394_GET_CMD_PRIV(*cmdp); 345 346 /* Initialize the command's blocking mutex */ 347 mutex_init(&s_priv->blocking_mutex, NULL, MUTEX_DRIVER, 348 hal->halinfo.hw_interrupt); 349 350 /* Initialize the command's blocking condition variable */ 351 cv_init(&s_priv->blocking_cv, NULL, CV_DRIVER, NULL); 352 353 TNF_PROBE_0_DEBUG(t1394_alloc_cmd_exit, S1394_TNF_SL_ATREQ_STACK, ""); 354 return (DDI_SUCCESS); 355 } 356 357 /* 358 * Function: t1394_free_cmd() 359 * Input(s): t1394_hdl The target "handle" returned by 360 * t1394_attach() 361 * flags The flags parameter is unused (for now) 362 * cmdp Pointer to the command to be freed 363 * 364 * Output(s): DDI_SUCCESS Target successfully freed command 365 * DDI_FAILURE Target failed to free command 366 * 367 * Description: t1394_free_cmd() attempts to free a command that has previously 368 * been allocated by the target driver. It is possible for 369 * t1394_free_cmd() to fail because the command is currently 370 * in-use by the 1394 Software Framework. 371 */ 372 /* ARGSUSED */ 373 int 374 t1394_free_cmd(t1394_handle_t t1394_hdl, uint_t flags, cmd1394_cmd_t **cmdp) 375 { 376 s1394_hal_t *hal; 377 s1394_target_t *target; 378 s1394_cmd_priv_t *s_priv; 379 uint_t num_cmds; 380 381 TNF_PROBE_0_DEBUG(t1394_free_cmd_enter, S1394_TNF_SL_ATREQ_STACK, ""); 382 383 ASSERT(t1394_hdl != NULL); 384 385 target = (s1394_target_t *)t1394_hdl; 386 387 /* Find the HAL this target resides on */ 388 hal = target->on_hal; 389 390 rw_enter(&hal->target_list_rwlock, RW_WRITER); 391 392 /* How many cmds has this target allocated? */ 393 num_cmds = target->target_num_cmds; 394 395 if (num_cmds == 0) { 396 rw_exit(&hal->target_list_rwlock); 397 TNF_PROBE_2(t1394_free_cmd_error, S1394_TNF_SL_ATREQ_ERROR, "", 398 tnf_string, msg, "No commands left to be freed " 399 "(num_cmds <= 0)", tnf_uint, num_cmds, num_cmds); 400 TNF_PROBE_0_DEBUG(t1394_free_cmd_exit, 401 S1394_TNF_SL_ATREQ_STACK, ""); 402 ASSERT(num_cmds != 0); 403 return (DDI_FAILURE); 404 } 405 406 /* Get the Services Layer private area */ 407 s_priv = S1394_GET_CMD_PRIV(*cmdp); 408 409 /* Check that command isn't in use */ 410 if (s_priv->cmd_in_use == B_TRUE) { 411 rw_exit(&hal->target_list_rwlock); 412 TNF_PROBE_1(t1394_free_cmd_error, S1394_TNF_SL_ATREQ_ERROR, "", 413 tnf_string, msg, "Attempted to free an in-use command"); 414 TNF_PROBE_0_DEBUG(t1394_free_cmd_exit, 415 S1394_TNF_SL_ATREQ_STACK, ""); 416 ASSERT(s_priv->cmd_in_use == B_FALSE); 417 return (DDI_FAILURE); 418 } 419 420 /* Decrement the number of cmds this target has allocated */ 421 target->target_num_cmds--; 422 423 rw_exit(&hal->target_list_rwlock); 424 425 /* Destroy the command's blocking condition variable */ 426 cv_destroy(&s_priv->blocking_cv); 427 428 /* Destroy the command's blocking mutex */ 429 mutex_destroy(&s_priv->blocking_mutex); 430 431 kmem_cache_free(hal->hal_kmem_cachep, *cmdp); 432 433 /* Command pointer is set to NULL before returning */ 434 *cmdp = NULL; 435 436 /* kstats - number of cmd frees */ 437 hal->hal_kstats->cmd_free++; 438 439 TNF_PROBE_0_DEBUG(t1394_free_cmd_exit, S1394_TNF_SL_ATREQ_STACK, ""); 440 return (DDI_SUCCESS); 441 } 442 443 /* 444 * Function: t1394_read() 445 * Input(s): t1394_hdl The target "handle" returned by 446 * t1394_attach() 447 * cmd Pointer to the command to send 448 * 449 * Output(s): DDI_SUCCESS Target successful sent the command 450 * DDI_FAILURE Target failed to send command 451 * 452 * Description: t1394_read() attempts to send an asynchronous read request 453 * onto the 1394 bus. 454 */ 455 int 456 t1394_read(t1394_handle_t t1394_hdl, cmd1394_cmd_t *cmd) 457 { 458 s1394_hal_t *to_hal; 459 s1394_target_t *target; 460 s1394_cmd_priv_t *s_priv; 461 s1394_hal_state_t state; 462 int ret; 463 int err; 464 465 TNF_PROBE_0_DEBUG(t1394_read_enter, S1394_TNF_SL_ATREQ_STACK, ""); 466 467 ASSERT(t1394_hdl != NULL); 468 ASSERT(cmd != NULL); 469 470 /* Get the Services Layer private area */ 471 s_priv = S1394_GET_CMD_PRIV(cmd); 472 473 /* Is this command currently in use? */ 474 if (s_priv->cmd_in_use == B_TRUE) { 475 TNF_PROBE_1(t1394_read_error, S1394_TNF_SL_ATREQ_ERROR, "", 476 tnf_string, msg, "Attempted to resend an in-use command"); 477 TNF_PROBE_0_DEBUG(t1394_read_exit, S1394_TNF_SL_ATREQ_STACK, 478 ""); 479 ASSERT(s_priv->cmd_in_use == B_FALSE); 480 return (DDI_FAILURE); 481 } 482 483 target = (s1394_target_t *)t1394_hdl; 484 485 /* Set-up the destination of the command */ 486 to_hal = target->on_hal; 487 488 /* No status (default) */ 489 cmd->cmd_result = CMD1394_NOSTATUS; 490 491 /* Check for proper command type */ 492 if ((cmd->cmd_type != CMD1394_ASYNCH_RD_QUAD) && 493 (cmd->cmd_type != CMD1394_ASYNCH_RD_BLOCK)) { 494 cmd->cmd_result = CMD1394_EINVALID_COMMAND; 495 TNF_PROBE_1(t1394_read_error, S1394_TNF_SL_ATREQ_ERROR, "", 496 tnf_string, msg, "Invalid command type specified"); 497 TNF_PROBE_0_DEBUG(t1394_read_exit, 498 S1394_TNF_SL_ATREQ_STACK, ""); 499 return (DDI_FAILURE); 500 } 501 502 /* Is this a blocking command on interrupt stack? */ 503 if ((cmd->cmd_options & CMD1394_BLOCKING) && 504 (curthread->t_flag == T_INTR_THREAD)) { 505 cmd->cmd_result = CMD1394_EINVALID_CONTEXT; 506 TNF_PROBE_1(t1394_read_error, S1394_TNF_SL_ATREQ_ERROR, "", 507 tnf_string, msg, "Tried to use CMD1394_BLOCKING in " 508 "intr context"); 509 TNF_PROBE_0_DEBUG(t1394_read_exit, 510 S1394_TNF_SL_ATREQ_STACK, ""); 511 return (DDI_FAILURE); 512 } 513 514 mutex_enter(&to_hal->topology_tree_mutex); 515 state = to_hal->hal_state; 516 if (state != S1394_HAL_NORMAL) { 517 ret = s1394_HAL_asynch_error(to_hal, cmd, state); 518 if (ret != CMD1394_CMDSUCCESS) { 519 cmd->cmd_result = ret; 520 mutex_exit(&to_hal->topology_tree_mutex); 521 return (DDI_FAILURE); 522 } 523 } 524 525 ret = s1394_setup_asynch_command(to_hal, target, cmd, 526 S1394_CMD_READ, &err); 527 528 /* Command has now been put onto the queue! */ 529 if (ret != DDI_SUCCESS) { 530 /* Copy error code into result */ 531 cmd->cmd_result = err; 532 mutex_exit(&to_hal->topology_tree_mutex); 533 TNF_PROBE_1(t1394_read_error, S1394_TNF_SL_ATREQ_ERROR, "", 534 tnf_string, msg, "Failed in s1394_setup_asynch_command()"); 535 TNF_PROBE_0_DEBUG(t1394_read_exit, 536 S1394_TNF_SL_ATREQ_STACK, ""); 537 return (DDI_FAILURE); 538 } 539 540 /* 541 * If this command was sent during a bus reset, 542 * then put it onto the pending Q. 543 */ 544 if (state == S1394_HAL_RESET) { 545 /* Remove cmd from outstanding request Q */ 546 s1394_remove_q_asynch_cmd(to_hal, cmd); 547 /* Are we on the bus reset event stack? */ 548 if (s1394_on_br_thread(to_hal) == B_TRUE) { 549 /* Blocking commands are not allowed */ 550 if (cmd->cmd_options & CMD1394_BLOCKING) { 551 mutex_exit(&to_hal->topology_tree_mutex); 552 s_priv->cmd_in_use = B_FALSE; 553 cmd->cmd_result = CMD1394_EINVALID_CONTEXT; 554 TNF_PROBE_1(t1394_read_error, 555 S1394_TNF_SL_ATREQ_ERROR, "", tnf_string, 556 msg, "CMD1394_BLOCKING in bus reset " 557 "context"); 558 TNF_PROBE_0_DEBUG(t1394_read_exit, 559 S1394_TNF_SL_ATREQ_STACK, ""); 560 return (DDI_FAILURE); 561 } 562 } 563 564 s1394_pending_q_insert(to_hal, cmd, S1394_PENDING_Q_FRONT); 565 mutex_exit(&to_hal->topology_tree_mutex); 566 567 /* Block (if necessary) */ 568 goto block_on_asynch_cmd; 569 } 570 mutex_exit(&to_hal->topology_tree_mutex); 571 572 /* Send the command out */ 573 ret = s1394_xfer_asynch_command(to_hal, cmd, &err); 574 575 if (ret != DDI_SUCCESS) { 576 if (err == CMD1394_ESTALE_GENERATION) { 577 /* Remove cmd from outstanding request Q */ 578 s1394_remove_q_asynch_cmd(to_hal, cmd); 579 s1394_pending_q_insert(to_hal, cmd, 580 S1394_PENDING_Q_FRONT); 581 582 /* Block (if necessary) */ 583 goto block_on_asynch_cmd; 584 585 } else { 586 /* Remove cmd from outstanding request Q */ 587 s1394_remove_q_asynch_cmd(to_hal, cmd); 588 589 s_priv->cmd_in_use = B_FALSE; 590 591 /* Copy error code into result */ 592 cmd->cmd_result = err; 593 594 TNF_PROBE_1(t1394_read_error, S1394_TNF_SL_ATREQ_ERROR, 595 "", tnf_string, msg, "Failed in " 596 "s1394_xfer_asynch_command()"); 597 TNF_PROBE_0_DEBUG(t1394_read_exit, 598 S1394_TNF_SL_ATREQ_STACK, ""); 599 return (DDI_FAILURE); 600 } 601 } else { 602 /* Block (if necessary) */ 603 goto block_on_asynch_cmd; 604 } 605 606 block_on_asynch_cmd: 607 s1394_block_on_asynch_cmd(cmd); 608 609 TNF_PROBE_0_DEBUG(t1394_read_exit, 610 S1394_TNF_SL_ATREQ_STACK, ""); 611 return (DDI_SUCCESS); 612 } 613 614 /* 615 * Function: t1394_write() 616 * Input(s): t1394_hdl The target "handle" returned by 617 * t1394_attach() 618 * cmd Pointer to the command to send 619 * 620 * Output(s): DDI_SUCCESS Target successful sent the command 621 * DDI_FAILURE Target failed to send command 622 * 623 * Description: t1394_write() attempts to send an asynchronous write request 624 * onto the 1394 bus. 625 */ 626 int 627 t1394_write(t1394_handle_t t1394_hdl, cmd1394_cmd_t *cmd) 628 { 629 s1394_hal_t *to_hal; 630 s1394_target_t *target; 631 s1394_cmd_priv_t *s_priv; 632 s1394_hal_state_t state; 633 int ret; 634 int err; 635 636 TNF_PROBE_0_DEBUG(t1394_write_enter, S1394_TNF_SL_ATREQ_STACK, ""); 637 638 ASSERT(t1394_hdl != NULL); 639 ASSERT(cmd != NULL); 640 641 /* Get the Services Layer private area */ 642 s_priv = S1394_GET_CMD_PRIV(cmd); 643 644 /* Is this command currently in use? */ 645 if (s_priv->cmd_in_use == B_TRUE) { 646 TNF_PROBE_1(t1394_write_error, S1394_TNF_SL_ATREQ_ERROR, "", 647 tnf_string, msg, "Attempted to resend an in-use command"); 648 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 649 ""); 650 ASSERT(s_priv->cmd_in_use == B_FALSE); 651 return (DDI_FAILURE); 652 } 653 654 target = (s1394_target_t *)t1394_hdl; 655 656 /* Set-up the destination of the command */ 657 to_hal = target->on_hal; 658 659 /* Is this an FA request? */ 660 if (s_priv->cmd_ext_type == S1394_CMD_EXT_FA) { 661 if (S1394_IS_CMD_FCP(s_priv) && 662 (s1394_fcp_write_check_cmd(cmd) != DDI_SUCCESS)) { 663 TNF_PROBE_0_DEBUG(t1394_write_exit, 664 S1394_TNF_SL_ATREQ_STACK, ""); 665 return (DDI_FAILURE); 666 } 667 s1394_fa_convert_cmd(to_hal, cmd); 668 } 669 670 /* No status (default) */ 671 cmd->cmd_result = CMD1394_NOSTATUS; 672 673 /* Check for proper command type */ 674 if ((cmd->cmd_type != CMD1394_ASYNCH_WR_QUAD) && 675 (cmd->cmd_type != CMD1394_ASYNCH_WR_BLOCK)) { 676 cmd->cmd_result = CMD1394_EINVALID_COMMAND; 677 s1394_fa_check_restore_cmd(to_hal, cmd); 678 TNF_PROBE_1(t1394_write_error, S1394_TNF_SL_ATREQ_ERROR, "", 679 tnf_string, msg, "Invalid command type specified"); 680 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 681 ""); 682 return (DDI_FAILURE); 683 } 684 685 /* Is this a blocking command on interrupt stack? */ 686 if ((cmd->cmd_options & CMD1394_BLOCKING) && 687 (curthread->t_flag == T_INTR_THREAD)) { 688 cmd->cmd_result = CMD1394_EINVALID_CONTEXT; 689 s1394_fa_check_restore_cmd(to_hal, cmd); 690 TNF_PROBE_1(t1394_write_error, S1394_TNF_SL_ATREQ_ERROR, "", 691 tnf_string, msg, "Tried to use CMD1394_BLOCKING in intr " 692 "context"); 693 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 694 ""); 695 return (DDI_FAILURE); 696 } 697 698 mutex_enter(&to_hal->topology_tree_mutex); 699 state = to_hal->hal_state; 700 if (state != S1394_HAL_NORMAL) { 701 ret = s1394_HAL_asynch_error(to_hal, cmd, state); 702 if (ret != CMD1394_CMDSUCCESS) { 703 cmd->cmd_result = ret; 704 mutex_exit(&to_hal->topology_tree_mutex); 705 s1394_fa_check_restore_cmd(to_hal, cmd); 706 return (DDI_FAILURE); 707 } 708 } 709 710 ret = s1394_setup_asynch_command(to_hal, target, cmd, 711 S1394_CMD_WRITE, &err); 712 713 /* Command has now been put onto the queue! */ 714 if (ret != DDI_SUCCESS) { 715 /* Copy error code into result */ 716 cmd->cmd_result = err; 717 mutex_exit(&to_hal->topology_tree_mutex); 718 s1394_fa_check_restore_cmd(to_hal, cmd); 719 TNF_PROBE_1(t1394_write_error, S1394_TNF_SL_ATREQ_ERROR, "", 720 tnf_string, msg, "Failed in s1394_setup_asynch_command()"); 721 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 722 ""); 723 return (DDI_FAILURE); 724 } 725 726 /* 727 * If this command was sent during a bus reset, 728 * then put it onto the pending Q. 729 */ 730 if (state == S1394_HAL_RESET) { 731 /* Remove cmd from outstanding request Q */ 732 s1394_remove_q_asynch_cmd(to_hal, cmd); 733 /* Are we on the bus reset event stack? */ 734 if (s1394_on_br_thread(to_hal) == B_TRUE) { 735 /* Blocking commands are not allowed */ 736 if (cmd->cmd_options & CMD1394_BLOCKING) { 737 mutex_exit(&to_hal->topology_tree_mutex); 738 s_priv->cmd_in_use = B_FALSE; 739 cmd->cmd_result = CMD1394_EINVALID_CONTEXT; 740 s1394_fa_check_restore_cmd(to_hal, cmd); 741 TNF_PROBE_1(t1394_write_error, 742 S1394_TNF_SL_ATREQ_ERROR, "", tnf_string, 743 msg, "CMD1394_BLOCKING in bus reset cntxt"); 744 TNF_PROBE_0_DEBUG(t1394_write_exit, 745 S1394_TNF_SL_ATREQ_STACK, ""); 746 return (DDI_FAILURE); 747 } 748 } 749 750 s1394_pending_q_insert(to_hal, cmd, S1394_PENDING_Q_FRONT); 751 mutex_exit(&to_hal->topology_tree_mutex); 752 753 /* Block (if necessary) */ 754 s1394_block_on_asynch_cmd(cmd); 755 756 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 757 ""); 758 return (DDI_SUCCESS); 759 } 760 mutex_exit(&to_hal->topology_tree_mutex); 761 762 /* Send the command out */ 763 ret = s1394_xfer_asynch_command(to_hal, cmd, &err); 764 765 if (ret != DDI_SUCCESS) { 766 if (err == CMD1394_ESTALE_GENERATION) { 767 /* Remove cmd from outstanding request Q */ 768 s1394_remove_q_asynch_cmd(to_hal, cmd); 769 s1394_pending_q_insert(to_hal, cmd, 770 S1394_PENDING_Q_FRONT); 771 772 /* Block (if necessary) */ 773 s1394_block_on_asynch_cmd(cmd); 774 775 TNF_PROBE_0_DEBUG(t1394_write_exit, 776 S1394_TNF_SL_ATREQ_STACK, ""); 777 return (DDI_SUCCESS); 778 } else { 779 /* Remove cmd from outstanding request Q */ 780 s1394_remove_q_asynch_cmd(to_hal, cmd); 781 782 s_priv->cmd_in_use = B_FALSE; 783 784 /* Copy error code into result */ 785 cmd->cmd_result = err; 786 787 s1394_fa_check_restore_cmd(to_hal, cmd); 788 TNF_PROBE_1(t1394_write_error, 789 S1394_TNF_SL_ATREQ_ERROR, "", tnf_string, msg, 790 "Failed in s1394_xfer_asynch_command()"); 791 TNF_PROBE_0_DEBUG(t1394_write_exit, 792 S1394_TNF_SL_ATREQ_STACK, ""); 793 return (DDI_FAILURE); 794 } 795 } else { 796 /* Block (if necessary) */ 797 s1394_block_on_asynch_cmd(cmd); 798 799 TNF_PROBE_0_DEBUG(t1394_write_exit, S1394_TNF_SL_ATREQ_STACK, 800 ""); 801 return (DDI_SUCCESS); 802 } 803 } 804 805 /* 806 * Function: t1394_lock() 807 * Input(s): t1394_hdl The target "handle" returned by 808 * t1394_attach() 809 * cmd Pointer to the command to send 810 * 811 * Output(s): DDI_SUCCESS Target successful sent the command 812 * DDI_FAILURE Target failed to send command 813 * 814 * Description: t1394_lock() attempts to send an asynchronous lock request 815 * onto the 1394 bus. 816 */ 817 int 818 t1394_lock(t1394_handle_t t1394_hdl, cmd1394_cmd_t *cmd) 819 { 820 s1394_hal_t *to_hal; 821 s1394_target_t *target; 822 s1394_cmd_priv_t *s_priv; 823 s1394_hal_state_t state; 824 cmd1394_lock_type_t lock_type; 825 uint_t num_retries; 826 int ret; 827 828 TNF_PROBE_0_DEBUG(t1394_lock_enter, S1394_TNF_SL_ATREQ_STACK, ""); 829 830 ASSERT(t1394_hdl != NULL); 831 ASSERT(cmd != NULL); 832 833 /* Get the Services Layer private area */ 834 s_priv = S1394_GET_CMD_PRIV(cmd); 835 836 /* Is this command currently in use? */ 837 if (s_priv->cmd_in_use == B_TRUE) { 838 TNF_PROBE_1(t1394_lock_error, S1394_TNF_SL_ATREQ_ERROR, "", 839 tnf_string, msg, "Attempted to resend an in-use command"); 840 TNF_PROBE_0_DEBUG(t1394_lock_exit, S1394_TNF_SL_ATREQ_STACK, 841 ""); 842 ASSERT(s_priv->cmd_in_use == B_FALSE); 843 return (DDI_FAILURE); 844 } 845 846 target = (s1394_target_t *)t1394_hdl; 847 848 /* Set-up the destination of the command */ 849 to_hal = target->on_hal; 850 851 mutex_enter(&to_hal->topology_tree_mutex); 852 state = to_hal->hal_state; 853 if (state != S1394_HAL_NORMAL) { 854 ret = s1394_HAL_asynch_error(to_hal, cmd, state); 855 if (ret != CMD1394_CMDSUCCESS) { 856 cmd->cmd_result = ret; 857 mutex_exit(&to_hal->topology_tree_mutex); 858 return (DDI_FAILURE); 859 } 860 } 861 mutex_exit(&to_hal->topology_tree_mutex); 862 863 /* Check for proper command type */ 864 if ((cmd->cmd_type != CMD1394_ASYNCH_LOCK_32) && 865 (cmd->cmd_type != CMD1394_ASYNCH_LOCK_64)) { 866 cmd->cmd_result = CMD1394_EINVALID_COMMAND; 867 TNF_PROBE_1(t1394_lock_error, S1394_TNF_SL_ATREQ_ERROR, "", 868 tnf_string, msg, "Invalid command type sent to " 869 "t1394_lock()"); 870 TNF_PROBE_0_DEBUG(t1394_lock_exit, S1394_TNF_SL_ATREQ_STACK, 871 ""); 872 return (DDI_FAILURE); 873 } 874 875 /* No status (default) */ 876 cmd->cmd_result = CMD1394_NOSTATUS; 877 878 /* Is this a blocking command on interrupt stack? */ 879 if ((cmd->cmd_options & CMD1394_BLOCKING) && 880 (curthread->t_flag == T_INTR_THREAD)) { 881 cmd->cmd_result = CMD1394_EINVALID_CONTEXT; 882 TNF_PROBE_1(t1394_lock_error, S1394_TNF_SL_ATREQ_ERROR, "", 883 tnf_string, msg, "Tried to use CMD1394_BLOCKING in intr " 884 "context"); 885 TNF_PROBE_0_DEBUG(t1394_lock_exit, S1394_TNF_SL_ATREQ_STACK, 886 ""); 887 return (DDI_FAILURE); 888 } 889 890 if (cmd->cmd_type == CMD1394_ASYNCH_LOCK_32) { 891 lock_type = cmd->cmd_u.l32.lock_type; 892 num_retries = cmd->cmd_u.l32.num_retries; 893 } else { /* (cmd->cmd_type == CMD1394_ASYNCH_LOCK_64) */ 894 lock_type = cmd->cmd_u.l64.lock_type; 895 num_retries = cmd->cmd_u.l64.num_retries; 896 } 897 898 /* Make sure num_retries is reasonable */ 899 ASSERT(num_retries <= MAX_NUMBER_OF_LOCK_RETRIES); 900 901 switch (lock_type) { 902 case CMD1394_LOCK_MASK_SWAP: 903 case CMD1394_LOCK_FETCH_ADD: 904 case CMD1394_LOCK_LITTLE_ADD: 905 case CMD1394_LOCK_BOUNDED_ADD: 906 case CMD1394_LOCK_WRAP_ADD: 907 case CMD1394_LOCK_COMPARE_SWAP: 908 ret = s1394_compare_swap(to_hal, target, cmd); 909 break; 910 911 case CMD1394_LOCK_BIT_AND: 912 case CMD1394_LOCK_BIT_OR: 913 case CMD1394_LOCK_BIT_XOR: 914 case CMD1394_LOCK_INCREMENT: 915 case CMD1394_LOCK_DECREMENT: 916 case CMD1394_LOCK_ADD: 917 case CMD1394_LOCK_SUBTRACT: 918 case CMD1394_LOCK_THRESH_ADD: 919 case CMD1394_LOCK_THRESH_SUBTRACT: 920 case CMD1394_LOCK_CLIP_ADD: 921 case CMD1394_LOCK_CLIP_SUBTRACT: 922 ret = s1394_split_lock_req(to_hal, target, cmd); 923 break; 924 925 default: 926 TNF_PROBE_1(t1394_lock_error, S1394_TNF_SL_ATREQ_ERROR, "", 927 tnf_string, msg, "Invalid lock_type in command"); 928 cmd->cmd_result = CMD1394_EINVALID_COMMAND; 929 ret = DDI_FAILURE; 930 break; 931 } 932 933 TNF_PROBE_0_DEBUG(t1394_lock_exit, S1394_TNF_SL_ATREQ_STACK, ""); 934 return (ret); 935 } 936 937 /* 938 * Function: t1394_alloc_addr() 939 * Input(s): t1394_hdl The target "handle" returned by 940 * t1394_attach() 941 * addr_allocp The structure used to specify the type, 942 * size, permissions, and callbacks 943 * (if any) for the requested block 944 * of 1394 address space 945 * flags The flags parameter is unused (for now) 946 * 947 * Output(s): result Used to pass more specific info back 948 * to target 949 * 950 * Description: t1394_alloc_addr() requests that part of the 1394 Address Space 951 * on the local node be set aside for this target driver, and 952 * associated with this address space should be some permissions 953 * and callbacks. If the request is unable to be fulfilled, 954 * t1394_alloc_addr() will return DDI_FAILURE and result will 955 * indicate the reason. T1394_EINVALID_PARAM indicates that the 956 * combination of flags given is invalid, and T1394_EALLOC_ADDR 957 * indicates that the requested type of address space is 958 * unavailable. 959 */ 960 /* ARGSUSED */ 961 int 962 t1394_alloc_addr(t1394_handle_t t1394_hdl, t1394_alloc_addr_t *addr_allocp, 963 uint_t flags, int *result) 964 { 965 s1394_hal_t *hal; 966 s1394_target_t *target; 967 uint64_t addr_lo; 968 uint64_t addr_hi; 969 int err; 970 971 TNF_PROBE_0_DEBUG(t1394_alloc_addr_enter, S1394_TNF_SL_ARREQ_STACK, 972 ""); 973 974 ASSERT(t1394_hdl != NULL); 975 ASSERT(addr_allocp != NULL); 976 977 target = (s1394_target_t *)t1394_hdl; 978 979 /* Find the HAL this target resides on */ 980 hal = target->on_hal; 981 982 /* Get the bounds of the request */ 983 addr_lo = addr_allocp->aa_address; 984 addr_hi = addr_lo + addr_allocp->aa_length; 985 986 /* Check combination of flags */ 987 if ((addr_allocp->aa_enable & T1394_ADDR_RDENBL) && 988 (addr_allocp->aa_evts.recv_read_request == NULL) && 989 (addr_allocp->aa_kmem_bufp == NULL)) { 990 if ((addr_allocp->aa_type != T1394_ADDR_FIXED) || 991 (addr_lo < hal->physical_addr_lo) || 992 (addr_hi > hal->physical_addr_hi)) { 993 994 /* 995 * Reads are enabled, but target doesn't want to 996 * be notified and hasn't given backing store 997 */ 998 *result = T1394_EINVALID_PARAM; 999 1000 TNF_PROBE_1(t1394_alloc_addr_error, 1001 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, msg, 1002 "Invalid flags " 1003 "(RDs on, notify off, no backing store)"); 1004 TNF_PROBE_0_DEBUG(t1394_alloc_addr_exit, 1005 S1394_TNF_SL_ARREQ_STACK, ""); 1006 1007 /* kstats - addr alloc failures */ 1008 hal->hal_kstats->addr_alloc_fail++; 1009 return (DDI_FAILURE); 1010 } else { 1011 addr_allocp->aa_enable &= ~T1394_ADDR_RDENBL; 1012 } 1013 } 1014 1015 if ((addr_allocp->aa_enable & T1394_ADDR_WRENBL) && 1016 (addr_allocp->aa_evts.recv_write_request == NULL) && 1017 (addr_allocp->aa_kmem_bufp == NULL)) { 1018 if ((addr_allocp->aa_type != T1394_ADDR_FIXED) || 1019 (addr_lo < hal->physical_addr_lo) || 1020 (addr_hi > hal->physical_addr_hi)) { 1021 1022 /* 1023 * Writes are enabled, but target doesn't want to 1024 * be notified and hasn't given backing store 1025 */ 1026 *result = T1394_EINVALID_PARAM; 1027 1028 TNF_PROBE_1(t1394_alloc_addr_error, 1029 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, msg, 1030 "Invalid flags " 1031 "(WRs on, notify off, no backing store)"); 1032 TNF_PROBE_0_DEBUG(t1394_alloc_addr_exit, 1033 S1394_TNF_SL_ARREQ_STACK, ""); 1034 1035 /* kstats - addr alloc failures */ 1036 hal->hal_kstats->addr_alloc_fail++; 1037 return (DDI_FAILURE); 1038 } else { 1039 addr_allocp->aa_enable &= ~T1394_ADDR_WRENBL; 1040 } 1041 } 1042 1043 if ((addr_allocp->aa_enable & T1394_ADDR_LKENBL) && 1044 (addr_allocp->aa_evts.recv_lock_request == NULL) && 1045 (addr_allocp->aa_kmem_bufp == NULL)) { 1046 if ((addr_allocp->aa_type != T1394_ADDR_FIXED) || 1047 (addr_lo < hal->physical_addr_lo) || 1048 (addr_hi > hal->physical_addr_hi)) { 1049 1050 /* 1051 * Locks are enabled, but target doesn't want to 1052 * be notified and hasn't given backing store 1053 */ 1054 *result = T1394_EINVALID_PARAM; 1055 1056 TNF_PROBE_1(t1394_alloc_addr_error, 1057 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, msg, 1058 "Invalid flags " 1059 "(LKs on, notify off, no backing store)"); 1060 TNF_PROBE_0_DEBUG(t1394_alloc_addr_exit, 1061 S1394_TNF_SL_ARREQ_STACK, ""); 1062 1063 /* kstats - addr alloc failures */ 1064 hal->hal_kstats->addr_alloc_fail++; 1065 return (DDI_FAILURE); 1066 } else { 1067 addr_allocp->aa_enable &= ~T1394_ADDR_LKENBL; 1068 } 1069 } 1070 1071 /* If not T1394_ADDR_FIXED, then allocate a block */ 1072 if (addr_allocp->aa_type != T1394_ADDR_FIXED) { 1073 err = s1394_request_addr_blk((s1394_hal_t *)target->on_hal, 1074 addr_allocp); 1075 if (err != DDI_SUCCESS) { 1076 *result = T1394_EALLOC_ADDR; 1077 /* kstats - addr alloc failures */ 1078 hal->hal_kstats->addr_alloc_fail++; 1079 } else { 1080 *result = T1394_NOERROR; 1081 } 1082 TNF_PROBE_0_DEBUG(t1394_alloc_addr_exit, 1083 S1394_TNF_SL_ARREQ_STACK, ""); 1084 return (err); 1085 } else { 1086 err = s1394_claim_addr_blk((s1394_hal_t *)target->on_hal, 1087 addr_allocp); 1088 if (err != DDI_SUCCESS) { 1089 *result = T1394_EALLOC_ADDR; 1090 /* kstats - addr alloc failures */ 1091 hal->hal_kstats->addr_alloc_fail++; 1092 } else { 1093 *result = T1394_NOERROR; 1094 /* If physical, update the AR request counter */ 1095 if ((addr_lo >= hal->physical_addr_lo) && 1096 (addr_hi <= hal->physical_addr_hi)) { 1097 rw_enter(&hal->target_list_rwlock, RW_WRITER); 1098 target->physical_arreq_enabled++; 1099 rw_exit(&hal->target_list_rwlock); 1100 1101 s1394_physical_arreq_set_one(target); 1102 } 1103 } 1104 TNF_PROBE_0_DEBUG(t1394_alloc_addr_exit, 1105 S1394_TNF_SL_ARREQ_STACK, ""); 1106 return (err); 1107 } 1108 } 1109 1110 /* 1111 * Function: t1394_free_addr() 1112 * Input(s): t1394_hdl The target "handle" returned by 1113 * t1394_attach() 1114 * addr_hdl The address "handle" returned by the 1115 * the t1394_alloc_addr() routine 1116 * flags The flags parameter is unused (for now) 1117 * 1118 * Output(s): DDI_SUCCESS Target successfully freed memory 1119 * DDI_FAILURE Target failed to free the memory block 1120 * 1121 * Description: t1394_free_addr() attempts to free up memory that has been 1122 * allocated by the target using t1394_alloc_addr(). 1123 */ 1124 /* ARGSUSED */ 1125 int 1126 t1394_free_addr(t1394_handle_t t1394_hdl, t1394_addr_handle_t *addr_hdl, 1127 uint_t flags) 1128 { 1129 s1394_addr_space_blk_t *curr_blk; 1130 s1394_hal_t *hal; 1131 s1394_target_t *target; 1132 1133 TNF_PROBE_0_DEBUG(t1394_free_addr_enter, S1394_TNF_SL_ARREQ_STACK, ""); 1134 1135 ASSERT(t1394_hdl != NULL); 1136 ASSERT(addr_hdl != NULL); 1137 1138 target = (s1394_target_t *)t1394_hdl; 1139 1140 /* Find the HAL this target resides on */ 1141 hal = target->on_hal; 1142 1143 curr_blk = (s1394_addr_space_blk_t *)(*addr_hdl); 1144 1145 if (s1394_free_addr_blk(hal, curr_blk) != DDI_SUCCESS) { 1146 TNF_PROBE_0_DEBUG(t1394_free_addr_exit, 1147 S1394_TNF_SL_ARREQ_STACK, ""); 1148 return (DDI_FAILURE); 1149 } 1150 1151 /* If physical, update the AR request counter */ 1152 if (curr_blk->addr_type == T1394_ADDR_FIXED) { 1153 target->physical_arreq_enabled--; 1154 s1394_physical_arreq_clear_one(target); 1155 } 1156 1157 *addr_hdl = NULL; 1158 1159 /* kstats - number of addr frees */ 1160 hal->hal_kstats->addr_space_free++; 1161 1162 TNF_PROBE_0_DEBUG(t1394_free_addr_exit, S1394_TNF_SL_ARREQ_STACK, ""); 1163 return (DDI_SUCCESS); 1164 } 1165 1166 /* 1167 * Function: t1394_recv_request_done() 1168 * Input(s): t1394_hdl The target "handle" returned by 1169 * t1394_attach() 1170 * resp Pointer to the command which the 1171 * target received in it's callback 1172 * flags The flags parameter is unused (for now) 1173 * 1174 * Output(s): DDI_SUCCESS Target successfully returned command 1175 * to the 1394 Software Framework, 1176 * and, if necessary, sent response 1177 * DDI_FAILURE Target failed to return the command to 1178 * the 1394 Software Framework 1179 * 1180 * Description: t1394_recv_request_done() takes the command that is given and 1181 * determines whether that command requires a response to be 1182 * sent on the 1394 bus. If it is necessary and it's response 1183 * code (cmd_result) has been set appropriately, then a response 1184 * will be sent. If no response is necessary (broadcast or 1185 * posted write), then the command resources are reclaimed. 1186 */ 1187 /* ARGSUSED */ 1188 int 1189 t1394_recv_request_done(t1394_handle_t t1394_hdl, cmd1394_cmd_t *resp, 1190 uint_t flags) 1191 { 1192 s1394_hal_t *hal; 1193 s1394_cmd_priv_t *s_priv; 1194 h1394_cmd_priv_t *h_priv; 1195 mblk_t *curr_blk; 1196 size_t msgb_len; 1197 size_t size; 1198 int ret; 1199 boolean_t response = B_TRUE; 1200 boolean_t posted_write = B_FALSE; 1201 boolean_t write_cmd = B_FALSE; 1202 boolean_t mblk_too_small; 1203 1204 TNF_PROBE_0_DEBUG(t1394_recv_request_done_enter, 1205 S1394_TNF_SL_ARREQ_STACK, ""); 1206 1207 ASSERT(t1394_hdl != NULL); 1208 ASSERT(resp != NULL); 1209 1210 /* Find the HAL this target resides on */ 1211 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 1212 1213 /* Get the Services Layer private area */ 1214 s_priv = S1394_GET_CMD_PRIV(resp); 1215 1216 /* Get a pointer to the HAL private struct */ 1217 h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private; 1218 1219 /* Is this an FA request? */ 1220 if (s_priv->cmd_ext_type == S1394_CMD_EXT_FA) { 1221 s1394_fa_convert_cmd(hal, resp); 1222 } 1223 1224 /* Is this a write request? */ 1225 if ((resp->cmd_type == CMD1394_ASYNCH_WR_QUAD) || 1226 (resp->cmd_type == CMD1394_ASYNCH_WR_BLOCK)) { 1227 write_cmd = B_TRUE; 1228 /* Is this a posted write request? */ 1229 posted_write = s_priv->posted_write; 1230 } 1231 1232 /* If broadcast or posted write cmd, don't send response */ 1233 if ((resp->broadcast == 1) || 1234 ((write_cmd == B_TRUE) && (posted_write == B_TRUE))) 1235 response = B_FALSE; 1236 1237 if (response == B_FALSE) { 1238 if ((write_cmd == B_TRUE) && (posted_write == B_TRUE)) { 1239 /* kstats - Posted Write error */ 1240 hal->hal_kstats->arreq_posted_write_error++; 1241 } 1242 1243 /* Free the command - Pass it back to the HAL */ 1244 HAL_CALL(hal).response_complete(hal->halinfo.hal_private, resp, 1245 h_priv); 1246 TNF_PROBE_0_DEBUG(t1394_recv_request_done_exit, 1247 S1394_TNF_SL_ARREQ_STACK, ""); 1248 return (DDI_SUCCESS); 1249 } 1250 1251 ASSERT(response == B_TRUE); 1252 1253 /* Verify valid response code */ 1254 switch (resp->cmd_result) { 1255 case IEEE1394_RESP_COMPLETE: 1256 /* Is the mblk_t too small? */ 1257 if (resp->cmd_type == CMD1394_ASYNCH_RD_BLOCK) { 1258 curr_blk = resp->cmd_u.b.data_block; 1259 size = resp->cmd_u.b.blk_length; 1260 msgb_len = 0; 1261 mblk_too_small = B_TRUE; 1262 1263 if (curr_blk == NULL) { 1264 TNF_PROBE_1(t1394_recv_request_done_error, 1265 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, 1266 msg, "mblk_t is NULL in response"); 1267 TNF_PROBE_0_DEBUG(t1394_recv_request_done_exit, 1268 S1394_TNF_SL_ARREQ_STACK, ""); 1269 /* 1270 * Free the command - Pass it back 1271 * to the HAL 1272 */ 1273 HAL_CALL(hal).response_complete( 1274 hal->halinfo.hal_private, resp, h_priv); 1275 ASSERT(curr_blk != NULL); 1276 return (DDI_FAILURE); 1277 } 1278 1279 while (curr_blk != NULL) { 1280 msgb_len += 1281 (curr_blk->b_wptr - curr_blk->b_rptr); 1282 1283 if (msgb_len >= size) { 1284 mblk_too_small = B_FALSE; 1285 break; 1286 } 1287 curr_blk = curr_blk->b_cont; 1288 } 1289 1290 if (mblk_too_small == B_TRUE) { 1291 TNF_PROBE_1(t1394_recv_request_done_error, 1292 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, 1293 msg, "mblk_t too small in response"); 1294 TNF_PROBE_0_DEBUG(t1394_recv_request_done_exit, 1295 S1394_TNF_SL_ARREQ_STACK, ""); 1296 /* 1297 * Free the command - Pass it back 1298 * to the HAL 1299 */ 1300 HAL_CALL(hal).response_complete( 1301 hal->halinfo.hal_private, resp, h_priv); 1302 ASSERT(mblk_too_small != B_TRUE); 1303 return (DDI_FAILURE); 1304 } 1305 } 1306 /* FALLTHROUGH */ 1307 case IEEE1394_RESP_CONFLICT_ERROR: 1308 case IEEE1394_RESP_DATA_ERROR: 1309 case IEEE1394_RESP_TYPE_ERROR: 1310 case IEEE1394_RESP_ADDRESS_ERROR: 1311 ret = s1394_send_response(hal, resp); 1312 TNF_PROBE_0_DEBUG(t1394_recv_request_done_exit, 1313 S1394_TNF_SL_ARREQ_STACK, ""); 1314 return (ret); 1315 1316 default: 1317 TNF_PROBE_1(t1394_recv_request_done_error, 1318 S1394_TNF_SL_ARREQ_ERROR, "", tnf_string, msg, 1319 "Invalid response code"); 1320 TNF_PROBE_0_DEBUG(t1394_recv_request_done_exit, 1321 S1394_TNF_SL_ARREQ_STACK, ""); 1322 return (DDI_FAILURE); 1323 } 1324 } 1325 1326 1327 /* 1328 * Function: t1394_fcp_register_controller() 1329 * Input(s): t1394_hdl The target "handle" returned by 1330 * t1394_attach() 1331 * evts The structure in which the target 1332 * specifies its callback routines 1333 * 1334 * flags The flags parameter is unused (for now) 1335 * 1336 * Output(s): DDI_SUCCESS Successfully registered. 1337 * 1338 * DDI_FAILURE Not registered due to failure. 1339 * 1340 * Description: Used to register the target within the Framework as an FCP 1341 * controller. 1342 */ 1343 /* ARGSUSED */ 1344 int 1345 t1394_fcp_register_controller(t1394_handle_t t1394_hdl, t1394_fcp_evts_t *evts, 1346 uint_t flags) 1347 { 1348 int result; 1349 1350 TNF_PROBE_0_DEBUG(t1394_fcp_register_controller_enter, 1351 S1394_TNF_SL_FCP_STACK, ""); 1352 1353 ASSERT(t1394_hdl != NULL); 1354 1355 result = s1394_fcp_register_ctl((s1394_target_t *)t1394_hdl, evts); 1356 1357 TNF_PROBE_0_DEBUG(t1394_fcp_register_controller_exit, 1358 S1394_TNF_SL_FCP_STACK, ""); 1359 return (result); 1360 } 1361 1362 /* 1363 * Function: t1394_fcp_unregister_controller() 1364 * Input(s): t1394_hdl The target "handle" returned by 1365 * t1394_attach() 1366 * 1367 * Output(s): DDI_SUCCESS Successfully unregistered. 1368 * 1369 * DDI_FAILURE Not unregistered due to failure. 1370 * 1371 * Description: Used to unregister the target within the Framework as an FCP 1372 * controller. 1373 */ 1374 int 1375 t1394_fcp_unregister_controller(t1394_handle_t t1394_hdl) 1376 { 1377 int result; 1378 1379 TNF_PROBE_0_DEBUG(t1394_fcp_unregister_controller_enter, 1380 S1394_TNF_SL_FCP_STACK, ""); 1381 1382 ASSERT(t1394_hdl != NULL); 1383 1384 result = s1394_fcp_unregister_ctl((s1394_target_t *)t1394_hdl); 1385 1386 TNF_PROBE_0_DEBUG(t1394_fcp_unregister_controller_exit, 1387 S1394_TNF_SL_FCP_STACK, ""); 1388 return (result); 1389 } 1390 1391 /* 1392 * Function: t1394_fcp_register_target() 1393 * Input(s): t1394_hdl The target "handle" returned by 1394 * t1394_attach() 1395 * evts The structure in which the target 1396 * specifies its callback routines 1397 * 1398 * flags The flags parameter is unused (for now) 1399 * 1400 * Output(s): DDI_SUCCESS Successfully registered. 1401 * 1402 * DDI_FAILURE Not registered due to failure. 1403 * 1404 * Description: Used to register the target within the Framework as an FCP 1405 * target. 1406 */ 1407 /* ARGSUSED */ 1408 int 1409 t1394_fcp_register_target(t1394_handle_t t1394_hdl, t1394_fcp_evts_t *evts, 1410 uint_t flags) 1411 { 1412 int result; 1413 1414 TNF_PROBE_0_DEBUG(t1394_fcp_register_target_enter, 1415 S1394_TNF_SL_FCP_STACK, ""); 1416 1417 ASSERT(t1394_hdl != NULL); 1418 1419 result = s1394_fcp_register_tgt((s1394_target_t *)t1394_hdl, evts); 1420 1421 TNF_PROBE_0_DEBUG(t1394_fcp_register_target_exit, 1422 S1394_TNF_SL_FCP_STACK, ""); 1423 return (result); 1424 } 1425 1426 /* 1427 * Function: t1394_fcp_unregister_target() 1428 * Input(s): t1394_hdl The target "handle" returned by 1429 * t1394_attach() 1430 * 1431 * Output(s): DDI_SUCCESS Successfully unregistered. 1432 * 1433 * DDI_FAILURE Not unregistered due to failure. 1434 * 1435 * Description: Used to unregister the target within the Framework as an FCP 1436 * target. 1437 */ 1438 int 1439 t1394_fcp_unregister_target(t1394_handle_t t1394_hdl) 1440 { 1441 int result; 1442 1443 TNF_PROBE_0_DEBUG(t1394_fcp_unregister_target_enter, 1444 S1394_TNF_SL_FCP_STACK, ""); 1445 1446 ASSERT(t1394_hdl != NULL); 1447 1448 result = s1394_fcp_unregister_tgt((s1394_target_t *)t1394_hdl); 1449 1450 TNF_PROBE_0_DEBUG(t1394_fcp_unregister_target_exit, 1451 S1394_TNF_SL_FCP_STACK, ""); 1452 return (result); 1453 } 1454 1455 /* 1456 * Function: t1394_cmp_register() 1457 * Input(s): t1394_hdl The target "handle" returned by 1458 * t1394_attach() 1459 * evts The structure in which the target 1460 * specifies its callback routines 1461 * 1462 * Output(s): DDI_SUCCESS Successfully registered. 1463 * 1464 * DDI_FAILURE Not registered due to failure. 1465 * 1466 * Description: Used to register the target within the Framework as a CMP 1467 * device. 1468 */ 1469 /* ARGSUSED */ 1470 int 1471 t1394_cmp_register(t1394_handle_t t1394_hdl, t1394_cmp_evts_t *evts, 1472 uint_t flags) 1473 { 1474 int result; 1475 1476 TNF_PROBE_0_DEBUG(t1394_cmp_register_enter, S1394_TNF_SL_CMP_STACK, ""); 1477 1478 ASSERT(t1394_hdl != NULL); 1479 1480 result = s1394_cmp_register((s1394_target_t *)t1394_hdl, evts); 1481 1482 TNF_PROBE_0_DEBUG(t1394_cmp_register_exit, S1394_TNF_SL_CMP_STACK, ""); 1483 return (result); 1484 } 1485 1486 /* 1487 * Function: t1394_cmp_unregister() 1488 * Input(s): t1394_hdl The target "handle" returned by 1489 * t1394_attach() 1490 * evts The structure in which the target 1491 * specifies its callback routines 1492 * 1493 * Output(s): DDI_SUCCESS Successfully registered. 1494 * 1495 * DDI_FAILURE Not registered due to failure. 1496 * 1497 * Description: Used to unregister the target within the Framework as a CMP 1498 * device. 1499 */ 1500 int 1501 t1394_cmp_unregister(t1394_handle_t t1394_hdl) 1502 { 1503 int result; 1504 1505 TNF_PROBE_0_DEBUG(t1394_cmp_unregister_enter, S1394_TNF_SL_CMP_STACK, 1506 ""); 1507 1508 ASSERT(t1394_hdl != NULL); 1509 1510 result = s1394_cmp_unregister((s1394_target_t *)t1394_hdl); 1511 1512 TNF_PROBE_0_DEBUG(t1394_cmp_unregister_exit, S1394_TNF_SL_CMP_STACK, 1513 ""); 1514 return (result); 1515 } 1516 1517 /* 1518 * Function: t1394_cmp_read() 1519 * Input(s): t1394_hdl The target "handle" returned by 1520 * t1394_attach() 1521 * reg Register type. 1522 * valp Returned register value. 1523 * 1524 * Output(s): DDI_SUCCESS Successfully registered. 1525 * 1526 * DDI_FAILURE Not registered due to failure. 1527 * 1528 * Description: Used to read a CMP register value. 1529 */ 1530 int 1531 t1394_cmp_read(t1394_handle_t t1394_hdl, t1394_cmp_reg_t reg, uint32_t *valp) 1532 { 1533 int result; 1534 1535 TNF_PROBE_0_DEBUG(t1394_cmp_read_enter, S1394_TNF_SL_CMP_STACK, ""); 1536 1537 ASSERT(t1394_hdl != NULL); 1538 1539 result = s1394_cmp_read((s1394_target_t *)t1394_hdl, reg, valp); 1540 1541 TNF_PROBE_0_DEBUG(t1394_cmp_read_exit, S1394_TNF_SL_CMP_STACK, ""); 1542 return (result); 1543 } 1544 1545 /* 1546 * Function: t1394_cmp_cas() 1547 * Input(s): t1394_hdl The target "handle" returned by 1548 * t1394_attach() 1549 * reg Register type. 1550 * arg_val Compare argument. 1551 * new_val New register value. 1552 * old_valp Returned original register value. 1553 * 1554 * Output(s): DDI_SUCCESS Successfully registered. 1555 * 1556 * DDI_FAILURE Not registered due to failure. 1557 * 1558 * Description: Used to compare-swap a CMP register value. 1559 */ 1560 int 1561 t1394_cmp_cas(t1394_handle_t t1394_hdl, t1394_cmp_reg_t reg, uint32_t arg_val, 1562 uint32_t new_val, uint32_t *old_valp) 1563 { 1564 int result; 1565 1566 TNF_PROBE_0_DEBUG(t1394_cmp_read_enter, S1394_TNF_SL_CMP_STACK, ""); 1567 1568 ASSERT(t1394_hdl != NULL); 1569 1570 result = s1394_cmp_cas((s1394_target_t *)t1394_hdl, reg, arg_val, 1571 new_val, old_valp); 1572 1573 TNF_PROBE_0_DEBUG(t1394_cmp_read_exit, S1394_TNF_SL_CMP_STACK, ""); 1574 return (result); 1575 } 1576 1577 /* 1578 * Function: t1394_alloc_isoch_single() 1579 * Input(s): t1394_hdl The target "handle" returned by 1580 * t1394_attach() 1581 * sii The structure used to set up the 1582 * overall characteristics of the 1583 * isochronous stream 1584 * flags The flags parameter is unused (for now) 1585 * 1586 * Output(s): setup_args Contains the channel number that was 1587 * allocated 1588 * t1394_single_hdl This in the isoch "handle" used in 1589 * t1394_free_isoch_single() 1590 * result Used to pass more specific info back 1591 * to target 1592 * 1593 * Description: t1394_alloc_isoch_single() is used to direct the 1394 Software 1594 * Framework to allocate an isochronous channel and bandwidth 1595 * from the Isochronous Resource Manager (IRM). If a bus reset 1596 * occurs, the 1394 Software Framework attempts to reallocate the 1597 * same resources, calling the rsrc_fail_target() callback if 1598 * it is unsuccessful. 1599 */ 1600 /* ARGSUSED */ 1601 int 1602 t1394_alloc_isoch_single(t1394_handle_t t1394_hdl, 1603 t1394_isoch_singleinfo_t *sii, uint_t flags, 1604 t1394_isoch_single_out_t *output_args, 1605 t1394_isoch_single_handle_t *t1394_single_hdl, int *result) 1606 { 1607 s1394_hal_t *hal; 1608 s1394_isoch_cec_t *cec_new; 1609 t1394_join_isochinfo_t jii; 1610 int ret; 1611 int err; 1612 1613 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_enter, 1614 S1394_TNF_SL_ISOCH_STACK, ""); 1615 1616 ASSERT(t1394_hdl != NULL); 1617 ASSERT(t1394_single_hdl != NULL); 1618 ASSERT(sii != NULL); 1619 1620 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 1621 1622 /* Check for invalid channel_mask */ 1623 if (sii->si_channel_mask == 0) { 1624 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1625 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1626 "Invalid channel mask"); 1627 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1628 S1394_TNF_SL_ISOCH_STACK, ""); 1629 return (DDI_FAILURE); 1630 } 1631 1632 /* Check for invalid bandwidth */ 1633 if ((sii->si_bandwidth <= IEEE1394_BANDWIDTH_MIN) || 1634 (sii->si_bandwidth > IEEE1394_BANDWIDTH_MAX)) { 1635 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1636 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1637 "Invalid bandwidth requirements"); 1638 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1639 S1394_TNF_SL_ISOCH_STACK, ""); 1640 return (DDI_FAILURE); 1641 } 1642 1643 /* Verify that rsrc_fail_target() callback is non-NULL */ 1644 if (sii->rsrc_fail_target == NULL) { 1645 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1646 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1647 "Invalid callback specified"); 1648 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1649 S1394_TNF_SL_ISOCH_STACK, ""); 1650 return (DDI_FAILURE); 1651 } 1652 1653 /* 1654 * Allocate an Isoch CEC of type S1394_SINGLE 1655 */ 1656 1657 /* Allocate the Isoch CEC structure */ 1658 cec_new = kmem_zalloc(sizeof (s1394_isoch_cec_t), KM_SLEEP); 1659 1660 /* Initialize the structure type */ 1661 cec_new->cec_type = S1394_SINGLE; 1662 1663 /* Create the mutex and "in_callbacks" cv */ 1664 mutex_init(&cec_new->isoch_cec_mutex, NULL, MUTEX_DRIVER, 1665 hal->halinfo.hw_interrupt); 1666 cv_init(&cec_new->in_callbacks_cv, NULL, CV_DRIVER, 1667 hal->halinfo.hw_interrupt); 1668 1669 /* Initialize the Isoch CEC's member list */ 1670 cec_new->cec_member_list_head = NULL; 1671 cec_new->cec_member_list_tail = NULL; 1672 1673 /* Initialize the filters */ 1674 cec_new->filter_min_speed = sii->si_speed; 1675 cec_new->filter_max_speed = sii->si_speed; 1676 cec_new->filter_current_speed = cec_new->filter_max_speed; 1677 cec_new->filter_channel_mask = sii->si_channel_mask; 1678 cec_new->bandwidth = sii->si_bandwidth; 1679 cec_new->state_transitions = ISOCH_CEC_FREE | ISOCH_CEC_JOIN | 1680 ISOCH_CEC_SETUP; 1681 1682 mutex_enter(&hal->isoch_cec_list_mutex); 1683 1684 /* Insert Isoch CEC into the HAL's list */ 1685 s1394_isoch_cec_list_insert(hal, cec_new); 1686 1687 mutex_exit(&hal->isoch_cec_list_mutex); 1688 1689 /* 1690 * Join the newly created Isoch CEC 1691 */ 1692 jii.req_channel_mask = sii->si_channel_mask; 1693 jii.req_max_speed = sii->si_speed; 1694 jii.jii_options = T1394_TALKER; 1695 jii.isoch_cec_evts_arg = sii->single_evt_arg; 1696 1697 /* All events are NULL except rsrc_fail_target() */ 1698 jii.isoch_cec_evts.setup_target = NULL; 1699 jii.isoch_cec_evts.start_target = NULL; 1700 jii.isoch_cec_evts.stop_target = NULL; 1701 jii.isoch_cec_evts.stop_target = NULL; 1702 jii.isoch_cec_evts.teardown_target = NULL; 1703 jii.isoch_cec_evts.rsrc_fail_target = sii->rsrc_fail_target; 1704 1705 ret = t1394_join_isoch_cec(t1394_hdl, 1706 (t1394_isoch_cec_handle_t)cec_new, 0, &jii); 1707 1708 if (ret != DDI_SUCCESS) { 1709 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1710 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1711 "Unexpected error from t1394_join_isoch_cec()"); 1712 1713 ret = t1394_free_isoch_cec(t1394_hdl, flags, 1714 (t1394_isoch_cec_handle_t *)&cec_new); 1715 if (ret != DDI_SUCCESS) { 1716 /* Unable to free the Isoch CEC */ 1717 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1718 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1719 "Unexpected error from t1394_free_isoch_cec()"); 1720 ASSERT(0); 1721 } 1722 1723 /* Handle is nulled out before returning */ 1724 *t1394_single_hdl = NULL; 1725 1726 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1727 S1394_TNF_SL_ISOCH_STACK, ""); 1728 return (DDI_FAILURE); 1729 } 1730 1731 /* 1732 * Setup the isoch resources, etc. 1733 */ 1734 ret = t1394_setup_isoch_cec(t1394_hdl, 1735 (t1394_isoch_cec_handle_t)cec_new, 0, &err); 1736 1737 if (ret != DDI_SUCCESS) { 1738 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1739 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1740 "Unexpected error from t1394_setup_isoch_cec()"); 1741 1742 *result = err; 1743 1744 /* Leave the Isoch CEC */ 1745 ret = t1394_leave_isoch_cec(t1394_hdl, 1746 (t1394_isoch_cec_handle_t)cec_new, 0); 1747 if (ret != DDI_SUCCESS) { 1748 /* Unable to leave the Isoch CEC */ 1749 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1750 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1751 "Unexpected error from t1394_leave_isoch_cec()"); 1752 ASSERT(0); 1753 } 1754 1755 /* Free up the Isoch CEC */ 1756 ret = t1394_free_isoch_cec(t1394_hdl, flags, 1757 (t1394_isoch_cec_handle_t *)&cec_new); 1758 if (ret != DDI_SUCCESS) { 1759 /* Unable to free the Isoch CEC */ 1760 TNF_PROBE_1(t1394_alloc_isoch_single_error, 1761 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1762 "Unexpected error from t1394_free_isoch_cec()"); 1763 ASSERT(0); 1764 } 1765 1766 /* Handle is nulled out before returning */ 1767 *t1394_single_hdl = NULL; 1768 1769 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1770 S1394_TNF_SL_ISOCH_STACK, ""); 1771 return (DDI_FAILURE); 1772 } 1773 1774 /* Return the setup_args - channel num and speed */ 1775 mutex_enter(&cec_new->isoch_cec_mutex); 1776 output_args->channel_num = cec_new->realloc_chnl_num; 1777 mutex_exit(&cec_new->isoch_cec_mutex); 1778 1779 /* Update the handle */ 1780 *t1394_single_hdl = (t1394_isoch_single_handle_t)cec_new; 1781 1782 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_single_exit, 1783 S1394_TNF_SL_ISOCH_STACK, ""); 1784 return (DDI_SUCCESS); 1785 } 1786 1787 /* 1788 * Function: t1394_free_isoch_single() 1789 * Input(s): t1394_hdl The target "handle" returned by 1790 * t1394_attach() 1791 * t1394_single_hdl The isoch "handle" return by 1792 * t1394_alloc_isoch_single() 1793 * flags The flags parameter is unused (for now) 1794 * 1795 * Output(s): None 1796 * 1797 * Description: t1394_free_isoch_single() frees the isochronous resources 1798 * and the handle that were allocated during the call to 1799 * t1394_alloc_isoch_single(). 1800 */ 1801 /* ARGSUSED */ 1802 void 1803 t1394_free_isoch_single(t1394_handle_t t1394_hdl, 1804 t1394_isoch_single_handle_t *t1394_single_hdl, uint_t flags) 1805 { 1806 s1394_isoch_cec_t *cec_curr; 1807 int ret; 1808 1809 TNF_PROBE_0_DEBUG(t1394_free_isoch_single_enter, 1810 S1394_TNF_SL_ISOCH_STACK, ""); 1811 1812 ASSERT(t1394_hdl != NULL); 1813 ASSERT(t1394_single_hdl != NULL); 1814 1815 /* Convert the handle to an Isoch CEC pointer */ 1816 cec_curr = (s1394_isoch_cec_t *)(*t1394_single_hdl); 1817 1818 /* 1819 * Teardown the isoch resources, etc. 1820 */ 1821 ret = t1394_teardown_isoch_cec(t1394_hdl, 1822 (t1394_isoch_cec_handle_t)cec_curr, 0); 1823 if (ret != DDI_SUCCESS) { 1824 /* Unable to teardown the Isoch CEC */ 1825 TNF_PROBE_1(t1394_free_isoch_single_error, 1826 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1827 "Unexpected error from t1394_teardown_isoch_cec()"); 1828 ASSERT(0); 1829 } 1830 1831 /* 1832 * Leave the Isoch CEC 1833 */ 1834 ret = t1394_leave_isoch_cec(t1394_hdl, 1835 (t1394_isoch_cec_handle_t)cec_curr, 0); 1836 if (ret != DDI_SUCCESS) { 1837 /* Unable to leave the Isoch CEC */ 1838 TNF_PROBE_1(t1394_free_isoch_single_error, 1839 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1840 "Unexpected error from t1394_leave_isoch_cec()"); 1841 ASSERT(0); 1842 } 1843 1844 /* 1845 * Free the Isoch CEC 1846 */ 1847 ret = t1394_free_isoch_cec(t1394_hdl, flags, 1848 (t1394_isoch_cec_handle_t *)&cec_curr); 1849 if (ret != DDI_SUCCESS) { 1850 /* Unable to free the Isoch CEC */ 1851 TNF_PROBE_1(t1394_free_isoch_single_error, 1852 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1853 "Unexpected error from t1394_free_isoch_cec()"); 1854 ASSERT(0); 1855 } 1856 1857 /* Handle is nulled out before returning */ 1858 *t1394_single_hdl = NULL; 1859 1860 TNF_PROBE_0_DEBUG(t1394_free_isoch_single_exit, 1861 S1394_TNF_SL_ISOCH_STACK, ""); 1862 } 1863 1864 /* 1865 * Function: t1394_alloc_isoch_cec() 1866 * Input(s): t1394_hdl The target "handle" returned by 1867 * t1394_attach() 1868 * props The structure used to set up the 1869 * overall characteristics of for 1870 * the Isoch CEC. 1871 * flags The flags parameter is unused (for now) 1872 * 1873 * Output(s): t1394_isoch_cec_hdl The Isoch CEC "handle" used in all 1874 * subsequent isoch_cec() calls 1875 * 1876 * Description: t1394_alloc_isoch_cec() allocates and initializes an 1877 * isochronous channel event coordinator (Isoch CEC) for use 1878 * in managing and coordinating activity for an isoch channel 1879 */ 1880 /* ARGSUSED */ 1881 int 1882 t1394_alloc_isoch_cec(t1394_handle_t t1394_hdl, t1394_isoch_cec_props_t *props, 1883 uint_t flags, t1394_isoch_cec_handle_t *t1394_isoch_cec_hdl) 1884 { 1885 s1394_hal_t *hal; 1886 s1394_isoch_cec_t *cec_new; 1887 uint64_t temp; 1888 1889 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_enter, 1890 S1394_TNF_SL_ISOCH_STACK, ""); 1891 1892 ASSERT(t1394_hdl != NULL); 1893 ASSERT(t1394_isoch_cec_hdl != NULL); 1894 ASSERT(props != NULL); 1895 1896 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 1897 1898 /* Check for invalid channel_mask */ 1899 if (props->cec_channel_mask == 0) { 1900 TNF_PROBE_1(t1394_alloc_isoch_cec_error, 1901 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1902 "Invalid channel mask"); 1903 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_exit, 1904 S1394_TNF_SL_ISOCH_STACK, ""); 1905 return (DDI_FAILURE); 1906 } 1907 1908 /* Test conditions specific to T1394_NO_IRM_ALLOC */ 1909 temp = props->cec_channel_mask; 1910 if (props->cec_options & T1394_NO_IRM_ALLOC) { 1911 /* If T1394_NO_IRM_ALLOC, then only one bit should be set */ 1912 if ((temp & (temp - 1)) != 0) { 1913 TNF_PROBE_1(t1394_alloc_isoch_cec_error, 1914 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1915 "Invalid channel mask"); 1916 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_exit, 1917 S1394_TNF_SL_ISOCH_STACK, ""); 1918 return (DDI_FAILURE); 1919 } 1920 1921 /* If T1394_NO_IRM_ALLOC, then speeds should be equal */ 1922 if (props->cec_min_speed != props->cec_max_speed) { 1923 TNF_PROBE_1(t1394_alloc_isoch_cec_error, 1924 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1925 "Invalid speeds (min != max)"); 1926 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_exit, 1927 S1394_TNF_SL_ISOCH_STACK, ""); 1928 return (DDI_FAILURE); 1929 } 1930 } 1931 1932 /* Check for invalid bandwidth */ 1933 if ((props->cec_bandwidth <= IEEE1394_BANDWIDTH_MIN) || 1934 (props->cec_bandwidth > IEEE1394_BANDWIDTH_MAX)) { 1935 TNF_PROBE_1(t1394_alloc_isoch_cec_error, 1936 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 1937 "Invalid bandwidth requirements"); 1938 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_exit, 1939 S1394_TNF_SL_ISOCH_STACK, ""); 1940 return (DDI_FAILURE); 1941 } 1942 1943 /* Allocate the Isoch CEC structure */ 1944 cec_new = kmem_zalloc(sizeof (s1394_isoch_cec_t), KM_SLEEP); 1945 1946 /* Initialize the structure type */ 1947 cec_new->cec_type = S1394_PEER_TO_PEER; 1948 1949 /* Create the mutex and "in_callbacks" cv */ 1950 mutex_init(&cec_new->isoch_cec_mutex, NULL, MUTEX_DRIVER, 1951 hal->halinfo.hw_interrupt); 1952 cv_init(&cec_new->in_callbacks_cv, NULL, CV_DRIVER, 1953 hal->halinfo.hw_interrupt); 1954 1955 /* Initialize the Isoch CEC's member list */ 1956 cec_new->cec_member_list_head = NULL; 1957 cec_new->cec_member_list_tail = NULL; 1958 1959 /* Initialize the filters */ 1960 cec_new->filter_min_speed = props->cec_min_speed; 1961 cec_new->filter_max_speed = props->cec_max_speed; 1962 cec_new->filter_current_speed = cec_new->filter_max_speed; 1963 cec_new->filter_channel_mask = props->cec_channel_mask; 1964 cec_new->bandwidth = props->cec_bandwidth; 1965 cec_new->cec_options = props->cec_options; 1966 cec_new->state_transitions = ISOCH_CEC_FREE | ISOCH_CEC_JOIN | 1967 ISOCH_CEC_SETUP; 1968 1969 mutex_enter(&hal->isoch_cec_list_mutex); 1970 1971 /* Insert Isoch CEC into the HAL's list */ 1972 s1394_isoch_cec_list_insert(hal, cec_new); 1973 1974 mutex_exit(&hal->isoch_cec_list_mutex); 1975 1976 /* Update the handle and return */ 1977 *t1394_isoch_cec_hdl = (t1394_isoch_cec_handle_t)cec_new; 1978 1979 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_cec_exit, 1980 S1394_TNF_SL_ISOCH_STACK, ""); 1981 return (DDI_SUCCESS); 1982 } 1983 1984 /* 1985 * Function: t1394_free_isoch_cec() 1986 * Input(s): t1394_hdl The target "handle" returned by 1987 * t1394_attach() 1988 * flags The flags parameter is unused (for now) 1989 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 1990 * t1394_alloc_isoch_cec() 1991 * 1992 * Output(s): DDI_SUCCESS Target successfully freed the Isoch CEC 1993 * DDI_FAILURE Target failed to free the Isoch CEC 1994 * 1995 * Description: t1394_free_isoch_cec() attempts to free the Isoch CEC 1996 * structure. It will fail (DDI_FAILURE) if there are any 1997 * remaining members who have not yet left. 1998 */ 1999 /* ARGSUSED */ 2000 int 2001 t1394_free_isoch_cec(t1394_handle_t t1394_hdl, uint_t flags, 2002 t1394_isoch_cec_handle_t *t1394_isoch_cec_hdl) 2003 { 2004 s1394_hal_t *hal; 2005 s1394_isoch_cec_t *cec_curr; 2006 2007 TNF_PROBE_0_DEBUG(t1394_free_isoch_cec_enter, 2008 S1394_TNF_SL_ISOCH_STACK, ""); 2009 2010 ASSERT(t1394_hdl != NULL); 2011 ASSERT(t1394_isoch_cec_hdl != NULL); 2012 2013 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 2014 2015 /* Convert the handle to an Isoch CEC pointer */ 2016 cec_curr = (s1394_isoch_cec_t *)(*t1394_isoch_cec_hdl); 2017 2018 /* Lock the Isoch CEC member list */ 2019 mutex_enter(&cec_curr->isoch_cec_mutex); 2020 2021 /* Are we in any callbacks? */ 2022 if (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2023 /* Unlock the Isoch CEC member list */ 2024 mutex_exit(&cec_curr->isoch_cec_mutex); 2025 TNF_PROBE_1(t1394_free_isoch_cec_error, 2026 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2027 "Not allowed to free Isoch CEC (in callbacks)"); 2028 TNF_PROBE_0_DEBUG(t1394_free_isoch_cec_exit, 2029 S1394_TNF_SL_ISOCH_STACK, ""); 2030 return (DDI_FAILURE); 2031 } 2032 2033 /* Is "free" a legal state transition? */ 2034 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_FREE) == 0) { 2035 /* Unlock the Isoch CEC member list */ 2036 mutex_exit(&cec_curr->isoch_cec_mutex); 2037 TNF_PROBE_1(t1394_free_isoch_cec_error, 2038 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2039 "Not allowed to free Isoch CEC"); 2040 TNF_PROBE_0_DEBUG(t1394_free_isoch_cec_exit, 2041 S1394_TNF_SL_ISOCH_STACK, ""); 2042 return (DDI_FAILURE); 2043 } 2044 mutex_exit(&cec_curr->isoch_cec_mutex); 2045 2046 mutex_enter(&hal->isoch_cec_list_mutex); 2047 2048 /* Remove Isoch CEC from HAL's list */ 2049 s1394_isoch_cec_list_remove(hal, cec_curr); 2050 2051 mutex_exit(&hal->isoch_cec_list_mutex); 2052 2053 /* Destroy the Isoch CEC's mutex and cv */ 2054 cv_destroy(&cec_curr->in_callbacks_cv); 2055 mutex_destroy(&cec_curr->isoch_cec_mutex); 2056 2057 /* Free up the memory for the Isoch CEC struct */ 2058 kmem_free(cec_curr, sizeof (s1394_isoch_cec_t)); 2059 2060 /* Update the handle and return */ 2061 *t1394_isoch_cec_hdl = NULL; 2062 2063 TNF_PROBE_0_DEBUG(t1394_free_isoch_cec_exit, 2064 S1394_TNF_SL_ISOCH_STACK, ""); 2065 return (DDI_SUCCESS); 2066 } 2067 2068 /* 2069 * Function: t1394_join_isoch_cec() 2070 * Input(s): t1394_hdl The target "handle" returned by 2071 * t1394_attach() 2072 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2073 * t1394_alloc_isoch_cec() 2074 * flags The flags parameter is unused (for now) 2075 * join_isoch_info This structure provides infomation 2076 * about a target that wishes to join 2077 * the given Isoch CEC. It gives 2078 * max_speed, channel_mask, etc. 2079 * 2080 * Output(s): DDI_SUCCESS Target successfully joined the 2081 * Isoch CEC 2082 * DDI_FAILURE Target failed to join the Isoch CEC 2083 * 2084 * Description: t1394_join_isoch_cec() determines, based on the information 2085 * given in the join_isoch_info structure, if the target may 2086 * join the Isoch CEC. If it is determined that the target may 2087 * join, the specified callback routines are stored away for 2088 * later use in the coordination tasks. 2089 */ 2090 /* ARGSUSED */ 2091 int 2092 t1394_join_isoch_cec(t1394_handle_t t1394_hdl, 2093 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags, 2094 t1394_join_isochinfo_t *join_isoch_info) 2095 { 2096 s1394_hal_t *hal; 2097 s1394_isoch_cec_t *cec_curr; 2098 s1394_isoch_cec_member_t *member_new; 2099 uint64_t check_mask; 2100 uint_t curr_max_speed; 2101 2102 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_enter, 2103 S1394_TNF_SL_ISOCH_STACK, ""); 2104 2105 ASSERT(t1394_hdl != NULL); 2106 ASSERT(t1394_isoch_cec_hdl != NULL); 2107 2108 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 2109 2110 /* Convert the handle to an Isoch CEC pointer */ 2111 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2112 2113 /* Allocate a new Isoch CEC member structure */ 2114 member_new = kmem_zalloc(sizeof (s1394_isoch_cec_member_t), KM_SLEEP); 2115 2116 /* Lock the Isoch CEC member list */ 2117 mutex_enter(&cec_curr->isoch_cec_mutex); 2118 2119 /* Are we in any callbacks? (Wait for them to finish) */ 2120 while (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2121 cec_curr->cec_want_wakeup = B_TRUE; 2122 cv_wait(&cec_curr->in_callbacks_cv, 2123 &cec_curr->isoch_cec_mutex); 2124 } 2125 2126 /* Is "join" a legal state transition? */ 2127 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_JOIN) == 0) { 2128 kmem_free(member_new, sizeof (s1394_isoch_cec_member_t)); 2129 /* Unlock the Isoch CEC member list */ 2130 mutex_exit(&cec_curr->isoch_cec_mutex); 2131 TNF_PROBE_1(t1394_join_isoch_cec_error, 2132 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2133 "Not allowed to join Isoch CEC"); 2134 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2135 S1394_TNF_SL_ISOCH_STACK, ""); 2136 return (DDI_FAILURE); 2137 } 2138 2139 /* Check the channel mask for consistency */ 2140 check_mask = join_isoch_info->req_channel_mask & 2141 cec_curr->filter_channel_mask; 2142 if (check_mask == 0) { 2143 kmem_free(member_new, sizeof (s1394_isoch_cec_member_t)); 2144 /* Unlock the Isoch CEC member list */ 2145 mutex_exit(&cec_curr->isoch_cec_mutex); 2146 TNF_PROBE_1(t1394_join_isoch_cec_error, 2147 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2148 "Inconsistent channel mask specified"); 2149 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2150 S1394_TNF_SL_ISOCH_STACK, ""); 2151 return (DDI_FAILURE); 2152 } 2153 2154 /* Check for consistent speeds */ 2155 if (join_isoch_info->req_max_speed < cec_curr->filter_min_speed) { 2156 kmem_free(member_new, sizeof (s1394_isoch_cec_member_t)); 2157 /* Unlock the Isoch CEC member list */ 2158 mutex_exit(&cec_curr->isoch_cec_mutex); 2159 TNF_PROBE_1(t1394_join_isoch_cec_error, 2160 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2161 "Inconsistent speed specified"); 2162 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2163 S1394_TNF_SL_ISOCH_STACK, ""); 2164 return (DDI_FAILURE); 2165 } else if (join_isoch_info->req_max_speed < 2166 cec_curr->filter_current_speed) { 2167 curr_max_speed = join_isoch_info->req_max_speed; 2168 } else { 2169 curr_max_speed = cec_curr->filter_current_speed; 2170 } 2171 2172 /* Check for no more than one talker */ 2173 if ((join_isoch_info->jii_options & T1394_TALKER) && 2174 (cec_curr->cec_member_talker != NULL)) { 2175 kmem_free(member_new, sizeof (s1394_isoch_cec_member_t)); 2176 /* Unlock the Isoch CEC member list */ 2177 mutex_exit(&cec_curr->isoch_cec_mutex); 2178 TNF_PROBE_1(t1394_join_isoch_cec_error, 2179 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2180 "Multiple talkers specified"); 2181 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2182 S1394_TNF_SL_ISOCH_STACK, ""); 2183 return (DDI_FAILURE); 2184 } 2185 2186 /* Verify that all callbacks are non-NULL (for PEER_TO_PEER) */ 2187 if ((cec_curr->cec_type == S1394_PEER_TO_PEER) && 2188 ((join_isoch_info->isoch_cec_evts.setup_target == NULL) || 2189 (join_isoch_info->isoch_cec_evts.start_target == NULL) || 2190 (join_isoch_info->isoch_cec_evts.stop_target == NULL) || 2191 (join_isoch_info->isoch_cec_evts.rsrc_fail_target == NULL) || 2192 (join_isoch_info->isoch_cec_evts.teardown_target == NULL))) { 2193 /* Unlock the Isoch CEC member list */ 2194 mutex_exit(&cec_curr->isoch_cec_mutex); 2195 TNF_PROBE_1(t1394_join_isoch_cec_error, 2196 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2197 "Invalid callbacks specified"); 2198 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2199 S1394_TNF_SL_ISOCH_STACK, ""); 2200 return (DDI_FAILURE); 2201 } 2202 2203 /* Copy the events information into the struct */ 2204 member_new->isoch_cec_evts = join_isoch_info->isoch_cec_evts; 2205 member_new->isoch_cec_evts_arg = join_isoch_info->isoch_cec_evts_arg; 2206 member_new->cec_mem_options = join_isoch_info->jii_options; 2207 member_new->cec_mem_target = (s1394_target_t *)t1394_hdl; 2208 2209 /* Insert new member into Isoch CEC's member list */ 2210 s1394_isoch_cec_member_list_insert(hal, cec_curr, member_new); 2211 2212 /* Update the channel mask filter */ 2213 cec_curr->filter_channel_mask = check_mask; 2214 2215 /* Update the speed filter */ 2216 cec_curr->filter_current_speed = curr_max_speed; 2217 2218 /* Update the talker pointer (if necessary) */ 2219 if (join_isoch_info->jii_options & T1394_TALKER) 2220 cec_curr->cec_member_talker = cec_curr->cec_member_list_head; 2221 2222 /* 2223 * Now "leave" is a legal state transition 2224 * and "free" is an illegal state transition 2225 */ 2226 CEC_SET_LEGAL(cec_curr, ISOCH_CEC_LEAVE); 2227 CEC_SET_ILLEGAL(cec_curr, ISOCH_CEC_FREE); 2228 2229 /* Unlock the Isoch CEC member list */ 2230 mutex_exit(&cec_curr->isoch_cec_mutex); 2231 2232 TNF_PROBE_0_DEBUG(t1394_join_isoch_cec_exit, 2233 S1394_TNF_SL_ISOCH_STACK, ""); 2234 return (DDI_SUCCESS); 2235 } 2236 2237 /* 2238 * Function: t1394_leave_isoch_cec() 2239 * Input(s): t1394_hdl The target "handle" returned by 2240 * t1394_attach() 2241 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2242 * t1394_alloc_isoch_cec() 2243 * flags The flags parameter is unused (for now) 2244 * 2245 * Output(s): DDI_SUCCESS Target successfully left the 2246 * Isoch CEC 2247 * DDI_FAILURE Target failed to leave the Isoch CEC 2248 * 2249 * Description: t1394_leave_isoch_cec() is used by a target driver to remove 2250 * itself from the Isoch CEC's member list. It is possible 2251 * for this call to fail because the target is not found in 2252 * the current member list, or because it is not an appropriate 2253 * time for a target to leave. 2254 */ 2255 /* ARGSUSED */ 2256 int 2257 t1394_leave_isoch_cec(t1394_handle_t t1394_hdl, 2258 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags) 2259 { 2260 s1394_hal_t *hal; 2261 s1394_isoch_cec_t *cec_curr; 2262 s1394_isoch_cec_member_t *member_curr; 2263 s1394_isoch_cec_member_t *member_temp; 2264 boolean_t found; 2265 uint64_t temp_channel_mask; 2266 uint_t temp_max_speed; 2267 2268 TNF_PROBE_0_DEBUG(t1394_leave_isoch_cec_enter, 2269 S1394_TNF_SL_ISOCH_STACK, ""); 2270 2271 ASSERT(t1394_hdl != NULL); 2272 ASSERT(t1394_isoch_cec_hdl != NULL); 2273 2274 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 2275 2276 /* Convert the handle to an Isoch CEC pointer */ 2277 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2278 2279 /* Lock the Isoch CEC member list */ 2280 mutex_enter(&cec_curr->isoch_cec_mutex); 2281 2282 /* Are we in any callbacks? (Wait for them to finish) */ 2283 while (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2284 cec_curr->cec_want_wakeup = B_TRUE; 2285 cv_wait(&cec_curr->in_callbacks_cv, 2286 &cec_curr->isoch_cec_mutex); 2287 } 2288 2289 /* Is "leave" a legal state transition? */ 2290 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_LEAVE) == 0) { 2291 /* Unlock the Isoch CEC member list */ 2292 mutex_exit(&cec_curr->isoch_cec_mutex); 2293 TNF_PROBE_1(t1394_leave_isoch_cec_error, 2294 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2295 "Not allowed to leave Isoch CEC"); 2296 TNF_PROBE_0_DEBUG(t1394_leave_isoch_cec_exit, 2297 S1394_TNF_SL_ISOCH_STACK, ""); 2298 return (DDI_FAILURE); 2299 } 2300 2301 /* Find the Target on the CEC's member list */ 2302 found = B_FALSE; 2303 temp_channel_mask = cec_curr->cec_alloc_props.cec_channel_mask; 2304 temp_max_speed = cec_curr->cec_alloc_props.cec_max_speed; 2305 member_curr = cec_curr->cec_member_list_head; 2306 while (member_curr != NULL) { 2307 if (member_curr->cec_mem_target == 2308 (s1394_target_t *)t1394_hdl) { 2309 member_temp = member_curr; 2310 found = B_TRUE; 2311 } else { 2312 /* Keep track of channel mask and max speed info */ 2313 temp_channel_mask &= member_curr->req_channel_mask; 2314 if (member_curr->req_max_speed < temp_max_speed) 2315 temp_max_speed = member_curr->req_max_speed; 2316 } 2317 member_curr = member_curr->cec_mem_next; 2318 } 2319 2320 /* Target not found on this Isoch CEC */ 2321 if (found == B_FALSE) { 2322 /* Unlock the Isoch CEC member list */ 2323 mutex_exit(&cec_curr->isoch_cec_mutex); 2324 TNF_PROBE_1(t1394_leave_isoch_cec_error, 2325 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2326 "Target not found in Isoch CEC member list"); 2327 TNF_PROBE_0_DEBUG(t1394_leave_isoch_cec_exit, 2328 S1394_TNF_SL_ISOCH_STACK, ""); 2329 return (DDI_FAILURE); 2330 } else { 2331 /* This member's departure may change filter constraints */ 2332 cec_curr->filter_current_speed = temp_max_speed; 2333 cec_curr->filter_channel_mask = temp_channel_mask; 2334 } 2335 2336 /* Remove member from Isoch CEC's member list */ 2337 s1394_isoch_cec_member_list_remove(hal, cec_curr, member_temp); 2338 2339 /* If we are removing the talker, then update the pointer */ 2340 if (cec_curr->cec_member_talker == member_temp) 2341 cec_curr->cec_member_talker = NULL; 2342 2343 /* Is the Isoch CEC's member list empty? */ 2344 if ((cec_curr->cec_member_list_head == NULL) && 2345 (cec_curr->cec_member_list_tail == NULL)) { 2346 /* 2347 * Now "free" _might_ be a legal state transition 2348 * if we aren't in setup or start phases and "leave" 2349 * is definitely an illegal state transition 2350 */ 2351 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_JOIN) != 0) 2352 CEC_SET_LEGAL(cec_curr, ISOCH_CEC_FREE); 2353 CEC_SET_ILLEGAL(cec_curr, ISOCH_CEC_LEAVE); 2354 } 2355 2356 /* Unlock the Isoch CEC member list */ 2357 mutex_exit(&cec_curr->isoch_cec_mutex); 2358 2359 /* Free the Isoch CEC member structure */ 2360 kmem_free(member_temp, sizeof (s1394_isoch_cec_member_t)); 2361 2362 TNF_PROBE_0_DEBUG(t1394_leave_isoch_cec_exit, 2363 S1394_TNF_SL_ISOCH_STACK, ""); 2364 return (DDI_SUCCESS); 2365 } 2366 2367 /* 2368 * Function: t1394_setup_isoch_cec() 2369 * Input(s): t1394_hdl The target "handle" returned by 2370 * t1394_attach() 2371 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2372 * t1394_alloc_isoch_cec() 2373 * flags The flags parameter is unused (for now) 2374 * 2375 * Output(s): result Used to pass more specific info back 2376 * to target 2377 * 2378 * Description: t1394_setup_isoch_cec() directs the 1394 Software Framework 2379 * to allocate isochronous resources and invoke the setup_target() 2380 * callback for each member of the Isoch CEC. This call may 2381 * fail because bandwidth was unavailable (T1394_ENO_BANDWIDTH), 2382 * channels were unavailable (T1394_ENO_CHANNEL), or one of the 2383 * member targets returned failure from its setup_target() 2384 * callback. 2385 */ 2386 /* ARGSUSED */ 2387 int 2388 t1394_setup_isoch_cec(t1394_handle_t t1394_hdl, 2389 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags, int *result) 2390 { 2391 s1394_hal_t *hal; 2392 s1394_isoch_cec_t *cec_curr; 2393 s1394_isoch_cec_member_t *member_curr; 2394 t1394_setup_target_args_t target_args; 2395 uint64_t temp_chnl_mask; 2396 uint32_t old_chnl; 2397 uint32_t try_chnl; 2398 uint_t bw_alloc_units; 2399 uint_t generation; 2400 int chnl_num; 2401 int err; 2402 int ret; 2403 int j; 2404 int (*setup_callback)(t1394_isoch_cec_handle_t, opaque_t, 2405 t1394_setup_target_args_t *); 2406 2407 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_enter, 2408 S1394_TNF_SL_ISOCH_STACK, ""); 2409 2410 ASSERT(t1394_hdl != NULL); 2411 ASSERT(t1394_isoch_cec_hdl != NULL); 2412 2413 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 2414 2415 /* Convert the handle to an Isoch CEC pointer */ 2416 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2417 2418 /* Lock the Isoch CEC member list */ 2419 mutex_enter(&cec_curr->isoch_cec_mutex); 2420 2421 /* Are we in any callbacks? */ 2422 if (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2423 /* Unlock the Isoch CEC member list */ 2424 mutex_exit(&cec_curr->isoch_cec_mutex); 2425 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2426 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2427 "Not allowed to setup Isoch CEC (in callbacks)"); 2428 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2429 S1394_TNF_SL_ISOCH_STACK, ""); 2430 return (DDI_FAILURE); 2431 } 2432 2433 /* Is "setup" a legal state transition? */ 2434 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_SETUP) == 0) { 2435 /* Unlock the Isoch CEC member list */ 2436 mutex_exit(&cec_curr->isoch_cec_mutex); 2437 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2438 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2439 "Not allowed to setup Isoch CEC"); 2440 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2441 S1394_TNF_SL_ISOCH_STACK, ""); 2442 return (DDI_FAILURE); 2443 } 2444 2445 /* If T1394_NO_IRM_ALLOC is set then don't allocate... do callbacks */ 2446 if (cec_curr->cec_options & T1394_NO_IRM_ALLOC) { 2447 goto setup_do_callbacks; 2448 } 2449 2450 /* Allocate bandwidth and channels */ 2451 for (j = 0; j < S1394_ISOCH_ALLOC_RETRIES; j++) { 2452 /* 2453 * Get the current generation number - don't 2454 * need the lock because we are read only here 2455 */ 2456 generation = hal->generation_count; 2457 2458 /* Compute how much bandwidth is needed */ 2459 bw_alloc_units = s1394_compute_bw_alloc_units(hal, 2460 cec_curr->bandwidth, cec_curr->filter_current_speed); 2461 2462 /* Check that the generation has not changed - */ 2463 /* don't need the lock (read only) */ 2464 if (generation != hal->generation_count) 2465 continue; 2466 2467 /* Unlock the Isoch CEC member list */ 2468 mutex_exit(&cec_curr->isoch_cec_mutex); 2469 2470 /* Try to allocate the bandwidth */ 2471 ret = s1394_bandwidth_alloc(hal, bw_alloc_units, generation, 2472 &err); 2473 2474 /* Lock the Isoch CEC member list */ 2475 mutex_enter(&cec_curr->isoch_cec_mutex); 2476 2477 /* If there was a bus reset, start over */ 2478 if (ret == DDI_FAILURE) { 2479 if (err == CMD1394_EBUSRESET) { 2480 continue; /* start over and try again */ 2481 } else { 2482 *result = T1394_ENO_BANDWIDTH; 2483 /* Unlock the Isoch CEC member list */ 2484 mutex_exit(&cec_curr->isoch_cec_mutex); 2485 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2486 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, 2487 msg, "Unable to allocate isoch bandwidth"); 2488 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2489 S1394_TNF_SL_ISOCH_STACK, ""); 2490 return (DDI_FAILURE); 2491 } 2492 } 2493 2494 /* Check that the generation has not changed - */ 2495 /* don't need the lock (read only) */ 2496 if (generation != hal->generation_count) 2497 continue; 2498 2499 /* 2500 * Allocate a channel 2501 * From IEEE 1394-1995, Section 8.3.2.3.8: "Bits 2502 * allocated in the CHANNELS_AVAILABLE_HI field of 2503 * this register shall start at bit zero (channel 2504 * number zero), and additional channel numbers shall 2505 * be represented in a monotonically increasing sequence 2506 * of bit numbers up to a maximum of bit 31 (channel 2507 * number 31). Bits allocated in the CHANNELS_AVAILABLE_LO 2508 * field of this register shall start at bit zero 2509 * (channel number 32), and additional channel numbers 2510 * shall be represented in a monotonically increasing 2511 * sequence of bit numbers up to a maximum of bit 31 2512 * (channel number 63). 2513 */ 2514 temp_chnl_mask = cec_curr->filter_channel_mask; 2515 for (chnl_num = 63; chnl_num >= 0; chnl_num--) { 2516 if ((temp_chnl_mask & 1) == 1) { 2517 try_chnl = (1 << ((63 - chnl_num) % 32)); 2518 2519 /* Unlock the Isoch CEC member list */ 2520 mutex_exit(&cec_curr->isoch_cec_mutex); 2521 if (chnl_num < 32) { 2522 ret = s1394_channel_alloc(hal, 2523 try_chnl, generation, 2524 S1394_CHANNEL_ALLOC_HI, &old_chnl, 2525 &err); 2526 } else { 2527 ret = s1394_channel_alloc(hal, 2528 try_chnl, generation, 2529 S1394_CHANNEL_ALLOC_LO, &old_chnl, 2530 &err); 2531 } 2532 /* Lock the Isoch CEC member list */ 2533 mutex_enter(&cec_curr->isoch_cec_mutex); 2534 2535 /* Did we get a channel? (or a bus reset) */ 2536 if ((ret == DDI_SUCCESS) || 2537 (err == CMD1394_EBUSRESET)) 2538 break; 2539 } 2540 temp_chnl_mask = temp_chnl_mask >> 1; 2541 } 2542 2543 /* If we've tried all the possible channels, then fail */ 2544 if (chnl_num == 0) { 2545 *result = T1394_ENO_CHANNEL; 2546 /* 2547 * If we successfully allocate bandwidth, and 2548 * then fail getting a channel, we need to 2549 * free up the bandwidth 2550 */ 2551 2552 /* Check that the generation has not changed */ 2553 /* lock not needed here (read only) */ 2554 if (generation != hal->generation_count) 2555 continue; 2556 2557 /* Unlock the Isoch CEC member list */ 2558 mutex_exit(&cec_curr->isoch_cec_mutex); 2559 2560 /* Try to free up the bandwidth */ 2561 ret = s1394_bandwidth_free(hal, bw_alloc_units, 2562 generation, &err); 2563 2564 /* Lock the Isoch CEC member list */ 2565 mutex_enter(&cec_curr->isoch_cec_mutex); 2566 2567 if (ret == DDI_FAILURE) { 2568 if (err == CMD1394_EBUSRESET) { 2569 continue; 2570 } else { 2571 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2572 S1394_TNF_SL_ISOCH_ERROR, "", 2573 tnf_string, msg, 2574 "Unable to free isoch bandwidth"); 2575 } 2576 } 2577 2578 /* Unlock the Isoch CEC member list */ 2579 mutex_exit(&cec_curr->isoch_cec_mutex); 2580 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2581 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2582 "Unable to allocate isoch channel"); 2583 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2584 S1394_TNF_SL_ISOCH_STACK, ""); 2585 return (DDI_FAILURE); 2586 } 2587 2588 /* If we got a channel, we're done (else start over) */ 2589 if (ret == DDI_SUCCESS) 2590 break; 2591 else if (err == CMD1394_EBUSRESET) 2592 continue; 2593 } 2594 2595 /* Have we gotten too many bus resets? */ 2596 if (j == S1394_ISOCH_ALLOC_RETRIES) { 2597 *result = T1394_ENO_BANDWIDTH; 2598 /* Unlock the Isoch CEC member list */ 2599 mutex_exit(&cec_curr->isoch_cec_mutex); 2600 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2601 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2602 "Unable to allocate isoch channel"); 2603 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2604 S1394_TNF_SL_ISOCH_STACK, ""); 2605 return (DDI_FAILURE); 2606 } 2607 2608 cec_curr->realloc_valid = B_TRUE; 2609 cec_curr->realloc_chnl_num = chnl_num; 2610 cec_curr->realloc_bandwidth = cec_curr->bandwidth; 2611 cec_curr->realloc_speed = cec_curr->filter_current_speed; 2612 2613 setup_do_callbacks: 2614 /* Call all of the setup_target() callbacks */ 2615 target_args.channel_num = chnl_num; 2616 target_args.channel_speed = cec_curr->filter_current_speed; 2617 2618 /* Now we are going into the callbacks */ 2619 cec_curr->in_callbacks = B_TRUE; 2620 2621 /* Unlock the Isoch CEC member list */ 2622 mutex_exit(&cec_curr->isoch_cec_mutex); 2623 2624 member_curr = cec_curr->cec_member_list_head; 2625 *result = 0; 2626 while (member_curr != NULL) { 2627 if (member_curr->isoch_cec_evts.setup_target != NULL) { 2628 setup_callback = 2629 member_curr->isoch_cec_evts.setup_target; 2630 ret = setup_callback(t1394_isoch_cec_hdl, 2631 member_curr->isoch_cec_evts_arg, &target_args); 2632 if (ret != DDI_SUCCESS) 2633 *result = T1394_ETARGET; 2634 } 2635 member_curr = member_curr->cec_mem_next; 2636 } 2637 2638 /* Lock the Isoch CEC member list */ 2639 mutex_enter(&cec_curr->isoch_cec_mutex); 2640 2641 /* We are finished with the callbacks */ 2642 cec_curr->in_callbacks = B_FALSE; 2643 if (cec_curr->cec_want_wakeup == B_TRUE) { 2644 cec_curr->cec_want_wakeup = B_FALSE; 2645 cv_broadcast(&cec_curr->in_callbacks_cv); 2646 } 2647 2648 /* 2649 * Now "start" and "teardown" are legal state transitions 2650 * and "join", "free", and "setup" are illegal state transitions 2651 */ 2652 CEC_SET_LEGAL(cec_curr, (ISOCH_CEC_START | ISOCH_CEC_TEARDOWN)); 2653 CEC_SET_ILLEGAL(cec_curr, (ISOCH_CEC_JOIN | ISOCH_CEC_FREE | 2654 ISOCH_CEC_SETUP)); 2655 2656 /* Unlock the Isoch CEC member list */ 2657 mutex_exit(&cec_curr->isoch_cec_mutex); 2658 2659 /* Return DDI_FAILURE if any targets failed setup */ 2660 if (*result != 0) { 2661 TNF_PROBE_1(t1394_setup_isoch_cec_error, 2662 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2663 "Target returned error in setup_target()"); 2664 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2665 S1394_TNF_SL_ISOCH_STACK, ""); 2666 return (DDI_FAILURE); 2667 } 2668 2669 TNF_PROBE_0_DEBUG(t1394_setup_isoch_cec_exit, 2670 S1394_TNF_SL_ISOCH_STACK, ""); 2671 return (DDI_SUCCESS); 2672 } 2673 2674 /* 2675 * Function: t1394_start_isoch_cec() 2676 * Input(s): t1394_hdl The target "handle" returned by 2677 * t1394_attach() 2678 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2679 * t1394_alloc_isoch_cec() 2680 * flags The flags parameter is unused (for now) 2681 * 2682 * Output(s): DDI_SUCCESS All start_target() callbacks returned 2683 * successfully 2684 * DDI_FAILURE One or more start_target() callbacks 2685 * returned failure 2686 * 2687 * Description: t1394_start_isoch_cec() directs the 1394 Software Framework 2688 * to invoke each of the start_target() callbacks, first for 2689 * each listener, then for the talker. 2690 */ 2691 /* ARGSUSED */ 2692 int 2693 t1394_start_isoch_cec(t1394_handle_t t1394_hdl, 2694 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags) 2695 { 2696 s1394_isoch_cec_t *cec_curr; 2697 s1394_isoch_cec_member_t *member_curr; 2698 int ret; 2699 boolean_t err; 2700 int (*start_callback)(t1394_isoch_cec_handle_t, opaque_t); 2701 2702 TNF_PROBE_0_DEBUG(t1394_start_isoch_cec_enter, 2703 S1394_TNF_SL_ISOCH_STACK, ""); 2704 2705 ASSERT(t1394_hdl != NULL); 2706 ASSERT(t1394_isoch_cec_hdl != NULL); 2707 2708 /* Convert the handle to an Isoch CEC pointer */ 2709 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2710 2711 /* Lock the Isoch CEC member list */ 2712 mutex_enter(&cec_curr->isoch_cec_mutex); 2713 2714 /* Are we in any callbacks? */ 2715 if (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2716 /* Unlock the Isoch CEC member list */ 2717 mutex_exit(&cec_curr->isoch_cec_mutex); 2718 TNF_PROBE_1(t1394_start_isoch_cec_error, 2719 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2720 "Not allowed to start Isoch CEC (in callbacks)"); 2721 TNF_PROBE_0_DEBUG(t1394_start_isoch_cec_exit, 2722 S1394_TNF_SL_ISOCH_STACK, ""); 2723 return (DDI_FAILURE); 2724 } 2725 2726 /* Is "start" a legal state transition? */ 2727 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_START) == 0) { 2728 /* Unlock the Isoch CEC member list */ 2729 mutex_exit(&cec_curr->isoch_cec_mutex); 2730 TNF_PROBE_1(t1394_start_isoch_cec_error, 2731 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2732 "Not allowed to start Isoch CEC"); 2733 TNF_PROBE_0_DEBUG(t1394_start_isoch_cec_exit, 2734 S1394_TNF_SL_ISOCH_STACK, ""); 2735 return (DDI_FAILURE); 2736 } 2737 2738 /* Now we are going into the callbacks */ 2739 cec_curr->in_callbacks = B_TRUE; 2740 2741 /* Unlock the Isoch CEC member list */ 2742 mutex_exit(&cec_curr->isoch_cec_mutex); 2743 2744 /* 2745 * Call all of the start_target() callbacks 2746 * Start at the tail (listeners first) and 2747 * go toward the head (talker last) 2748 */ 2749 member_curr = cec_curr->cec_member_list_tail; 2750 err = B_FALSE; 2751 while (member_curr != NULL) { 2752 if (member_curr->isoch_cec_evts.start_target != NULL) { 2753 start_callback = 2754 member_curr->isoch_cec_evts.start_target; 2755 ret = start_callback(t1394_isoch_cec_hdl, 2756 member_curr->isoch_cec_evts_arg); 2757 if (ret != DDI_SUCCESS) 2758 err = B_TRUE; 2759 } 2760 member_curr = member_curr->cec_mem_prev; 2761 } 2762 2763 /* Lock the Isoch CEC member list */ 2764 mutex_enter(&cec_curr->isoch_cec_mutex); 2765 2766 /* We are finished with the callbacks */ 2767 cec_curr->in_callbacks = B_FALSE; 2768 if (cec_curr->cec_want_wakeup == B_TRUE) { 2769 cec_curr->cec_want_wakeup = B_FALSE; 2770 cv_broadcast(&cec_curr->in_callbacks_cv); 2771 } 2772 2773 /* 2774 * Now "stop" is a legal state transitions 2775 * and "start" and "teardown" are illegal state transitions 2776 */ 2777 CEC_SET_LEGAL(cec_curr, ISOCH_CEC_STOP); 2778 CEC_SET_ILLEGAL(cec_curr, (ISOCH_CEC_START | ISOCH_CEC_TEARDOWN)); 2779 2780 /* Unlock the Isoch CEC member list */ 2781 mutex_exit(&cec_curr->isoch_cec_mutex); 2782 2783 /* Return DDI_FAILURE if any targets failed start */ 2784 if (err == B_TRUE) { 2785 TNF_PROBE_1(t1394_start_isoch_cec_error, 2786 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2787 "Target returned error in start_target()"); 2788 TNF_PROBE_0_DEBUG(t1394_start_isoch_cec_exit, 2789 S1394_TNF_SL_ISOCH_STACK, ""); 2790 return (DDI_FAILURE); 2791 } 2792 2793 TNF_PROBE_0_DEBUG(t1394_start_isoch_cec_exit, 2794 S1394_TNF_SL_ISOCH_STACK, ""); 2795 return (DDI_SUCCESS); 2796 } 2797 2798 /* 2799 * Function: t1394_stop_isoch_cec() 2800 * Input(s): t1394_hdl The target "handle" returned by 2801 * t1394_attach() 2802 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2803 * t1394_alloc_isoch_cec() 2804 * flags The flags parameter is unused (for now) 2805 * 2806 * Output(s): DDI_SUCCESS Target successfully stopped the 2807 * Isoch CEC 2808 * DDI_FAILURE Target failed to stop the Isoch CEC 2809 * 2810 * Description: t1394_stop_isoch_cec() directs the 1394 Software Framework 2811 * to invoke each of the stop_target() callbacks, first for 2812 * the talker, then for each listener. 2813 * (This call will fail if it is called at an 2814 * inappropriate time, i.e. before the t1394_start_isoch_cec() 2815 * call, etc.) 2816 */ 2817 /* ARGSUSED */ 2818 int 2819 t1394_stop_isoch_cec(t1394_handle_t t1394_hdl, 2820 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags) 2821 { 2822 s1394_isoch_cec_t *cec_curr; 2823 s1394_isoch_cec_member_t *member_curr; 2824 void (*stop_callback)(t1394_isoch_cec_handle_t, opaque_t); 2825 2826 TNF_PROBE_0_DEBUG(t1394_stop_isoch_cec_enter, 2827 S1394_TNF_SL_ISOCH_STACK, ""); 2828 2829 ASSERT(t1394_hdl != NULL); 2830 ASSERT(t1394_isoch_cec_hdl != NULL); 2831 2832 /* Convert the handle to an Isoch CEC pointer */ 2833 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2834 2835 /* Lock the Isoch CEC member list */ 2836 mutex_enter(&cec_curr->isoch_cec_mutex); 2837 2838 /* Are we in any callbacks? */ 2839 if (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2840 /* Unlock the Isoch CEC member list */ 2841 mutex_exit(&cec_curr->isoch_cec_mutex); 2842 TNF_PROBE_1(t1394_stop_isoch_cec_error, 2843 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2844 "Not allowed to stop Isoch CEC (in callbacks)"); 2845 TNF_PROBE_0_DEBUG(t1394_stop_isoch_cec_exit, 2846 S1394_TNF_SL_ISOCH_STACK, ""); 2847 return (DDI_FAILURE); 2848 } 2849 2850 /* Is "stop" a legal state transition? */ 2851 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_STOP) == 0) { 2852 /* Unlock the Isoch CEC member list */ 2853 mutex_exit(&cec_curr->isoch_cec_mutex); 2854 TNF_PROBE_1(t1394_stop_isoch_cec_error, 2855 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2856 "Not allowed to stop Isoch CEC"); 2857 TNF_PROBE_0_DEBUG(t1394_stop_isoch_cec_exit, 2858 S1394_TNF_SL_ISOCH_STACK, ""); 2859 return (DDI_FAILURE); 2860 } 2861 2862 /* Now we are going into the callbacks */ 2863 cec_curr->in_callbacks = B_TRUE; 2864 2865 /* Unlock the Isoch CEC member list */ 2866 mutex_exit(&cec_curr->isoch_cec_mutex); 2867 2868 /* 2869 * Call all of the stop_target() callbacks 2870 * Start at the head (talker first) and 2871 * go toward the tail (listeners last) 2872 */ 2873 member_curr = cec_curr->cec_member_list_head; 2874 while (member_curr != NULL) { 2875 if (member_curr->isoch_cec_evts.stop_target != NULL) { 2876 stop_callback = 2877 member_curr->isoch_cec_evts.stop_target; 2878 stop_callback(t1394_isoch_cec_hdl, 2879 member_curr->isoch_cec_evts_arg); 2880 } 2881 member_curr = member_curr->cec_mem_next; 2882 } 2883 2884 /* Lock the Isoch CEC member list */ 2885 mutex_enter(&cec_curr->isoch_cec_mutex); 2886 2887 /* We are finished with the callbacks */ 2888 cec_curr->in_callbacks = B_FALSE; 2889 if (cec_curr->cec_want_wakeup == B_TRUE) { 2890 cec_curr->cec_want_wakeup = B_FALSE; 2891 cv_broadcast(&cec_curr->in_callbacks_cv); 2892 } 2893 2894 /* 2895 * Now "start" and "teardown" are legal state transitions 2896 * and "stop" is an illegal state transitions 2897 */ 2898 CEC_SET_LEGAL(cec_curr, (ISOCH_CEC_START | ISOCH_CEC_TEARDOWN)); 2899 CEC_SET_ILLEGAL(cec_curr, ISOCH_CEC_STOP); 2900 2901 /* Unlock the Isoch CEC member list */ 2902 mutex_exit(&cec_curr->isoch_cec_mutex); 2903 2904 TNF_PROBE_0_DEBUG(t1394_stop_isoch_cec_exit, 2905 S1394_TNF_SL_ISOCH_STACK, ""); 2906 return (DDI_SUCCESS); 2907 } 2908 2909 /* 2910 * Function: t1394_teardown_isoch_cec() 2911 * Input(s): t1394_hdl The target "handle" returned by 2912 * t1394_attach() 2913 * t1394_isoch_cec_hdl The Isoch CEC "handle" returned by 2914 * t1394_alloc_isoch_cec() 2915 * flags The flags parameter is unused (for now) 2916 * 2917 * Output(s): DDI_SUCCESS Target successfully tore down the 2918 * Isoch CEC 2919 * DDI_FAILURE Target failed to tear down the 2920 * Isoch CEC 2921 * 2922 * Description: t1394_teardown_isoch_cec() directs the 1394 Software Framework 2923 * to free up any isochronous resources we might be holding and 2924 * call all of the teardown_target() callbacks. 2925 * (This call will fail if it is called at an 2926 * inappropriate time, i.e. before the t1394_start_isoch_cec() 2927 * call, before the t1394_stop_isoch_cec, etc. 2928 */ 2929 /* ARGSUSED */ 2930 int 2931 t1394_teardown_isoch_cec(t1394_handle_t t1394_hdl, 2932 t1394_isoch_cec_handle_t t1394_isoch_cec_hdl, uint_t flags) 2933 { 2934 s1394_hal_t *hal; 2935 s1394_isoch_cec_t *cec_curr; 2936 s1394_isoch_cec_member_t *member_curr; 2937 uint32_t chnl_mask; 2938 uint32_t old_chnl_mask; 2939 uint_t bw_alloc_units; 2940 uint_t generation; 2941 int ret; 2942 int err; 2943 void (*teardown_callback)(t1394_isoch_cec_handle_t, opaque_t); 2944 2945 TNF_PROBE_0_DEBUG(t1394_teardown_isoch_cec_enter, 2946 S1394_TNF_SL_ISOCH_STACK, ""); 2947 2948 ASSERT(t1394_hdl != NULL); 2949 ASSERT(t1394_isoch_cec_hdl != NULL); 2950 2951 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 2952 2953 /* Convert the handle to an Isoch CEC pointer */ 2954 cec_curr = (s1394_isoch_cec_t *)t1394_isoch_cec_hdl; 2955 2956 /* Lock the Isoch CEC member list */ 2957 mutex_enter(&cec_curr->isoch_cec_mutex); 2958 2959 /* Are we in any callbacks? */ 2960 if (CEC_IN_ANY_CALLBACKS(cec_curr)) { 2961 /* Unlock the Isoch CEC member list */ 2962 mutex_exit(&cec_curr->isoch_cec_mutex); 2963 TNF_PROBE_1(t1394_teardown_isoch_cec_error, 2964 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2965 "Not allowed to teardown Isoch CEC (in callbacks)"); 2966 TNF_PROBE_0_DEBUG(t1394_teardown_isoch_cec_exit, 2967 S1394_TNF_SL_ISOCH_STACK, ""); 2968 return (DDI_FAILURE); 2969 } 2970 2971 /* Is "teardown" a legal state transition? */ 2972 if (CEC_TRANSITION_LEGAL(cec_curr, ISOCH_CEC_TEARDOWN) == 0) { 2973 /* Unlock the Isoch CEC member list */ 2974 mutex_exit(&cec_curr->isoch_cec_mutex); 2975 TNF_PROBE_1(t1394_teardown_isoch_cec_error, 2976 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 2977 "Not allowed to teardown Isoch CEC"); 2978 TNF_PROBE_0_DEBUG(t1394_teardown_isoch_cec_exit, 2979 S1394_TNF_SL_ISOCH_STACK, ""); 2980 return (DDI_FAILURE); 2981 } 2982 2983 /* If T1394_NO_IRM_ALLOC is set then don't free... do callbacks */ 2984 if (cec_curr->cec_options & T1394_NO_IRM_ALLOC) { 2985 goto teardown_do_callbacks; 2986 } 2987 2988 /* If nothing has been allocated or we failed to */ 2989 /* reallocate, then we are done... call the callbacks */ 2990 if ((cec_curr->realloc_valid == B_FALSE) || 2991 (cec_curr->realloc_failed == B_TRUE)) { 2992 goto teardown_do_callbacks; 2993 } 2994 2995 /* 2996 * Get the current generation number - don't need the 2997 * topology tree mutex here because it is read-only, and 2998 * there is a race condition with or without it. 2999 */ 3000 generation = hal->generation_count; 3001 3002 /* Compute the amount bandwidth to free */ 3003 bw_alloc_units = s1394_compute_bw_alloc_units(hal, 3004 cec_curr->bandwidth, cec_curr->realloc_speed); 3005 3006 /* Check that the generation has not changed - */ 3007 /* don't need the lock (read only) */ 3008 if (generation != hal->generation_count) 3009 goto teardown_do_callbacks; 3010 3011 /* Unlock the Isoch CEC member list */ 3012 mutex_exit(&cec_curr->isoch_cec_mutex); 3013 3014 /* Try to free up the bandwidth */ 3015 ret = s1394_bandwidth_free(hal, bw_alloc_units, generation, &err); 3016 3017 /* Lock the Isoch CEC member list */ 3018 mutex_enter(&cec_curr->isoch_cec_mutex); 3019 3020 if (ret == DDI_FAILURE) { 3021 if (err == CMD1394_EBUSRESET) { 3022 goto teardown_do_callbacks; 3023 } else { 3024 TNF_PROBE_1(t1394_teardown_isoch_cec_error, 3025 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 3026 "Unable to free allocated bandwidth"); 3027 } 3028 } 3029 3030 /* Free the allocated channel */ 3031 chnl_mask = (1 << ((63 - cec_curr->realloc_chnl_num) % 32)); 3032 3033 /* Unlock the Isoch CEC member list */ 3034 mutex_exit(&cec_curr->isoch_cec_mutex); 3035 if (cec_curr->realloc_chnl_num < 32) { 3036 ret = s1394_channel_free(hal, chnl_mask, generation, 3037 S1394_CHANNEL_ALLOC_HI, &old_chnl_mask, &err); 3038 } else { 3039 ret = s1394_channel_free(hal, chnl_mask, generation, 3040 S1394_CHANNEL_ALLOC_LO, &old_chnl_mask, &err); 3041 } 3042 /* Lock the Isoch CEC member list */ 3043 mutex_enter(&cec_curr->isoch_cec_mutex); 3044 3045 if (ret == DDI_FAILURE) { 3046 if (err == CMD1394_EBUSRESET) { 3047 goto teardown_do_callbacks; 3048 } else { 3049 TNF_PROBE_1(t1394_teardown_isoch_cec_error, 3050 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 3051 "Unable to free allocated bandwidth"); 3052 } 3053 } 3054 3055 teardown_do_callbacks: 3056 /* From here on reallocation is unnecessary */ 3057 cec_curr->realloc_valid = B_FALSE; 3058 cec_curr->realloc_chnl_num = 0; 3059 cec_curr->realloc_bandwidth = 0; 3060 3061 /* Now we are going into the callbacks */ 3062 cec_curr->in_callbacks = B_TRUE; 3063 3064 /* Unlock the Isoch CEC member list */ 3065 mutex_exit(&cec_curr->isoch_cec_mutex); 3066 3067 /* Call all of the teardown_target() callbacks */ 3068 member_curr = cec_curr->cec_member_list_head; 3069 while (member_curr != NULL) { 3070 if (member_curr->isoch_cec_evts.teardown_target != NULL) { 3071 teardown_callback = 3072 member_curr->isoch_cec_evts.teardown_target; 3073 teardown_callback(t1394_isoch_cec_hdl, 3074 member_curr->isoch_cec_evts_arg); 3075 } 3076 member_curr = member_curr->cec_mem_next; 3077 } 3078 3079 /* Lock the Isoch CEC member list */ 3080 mutex_enter(&cec_curr->isoch_cec_mutex); 3081 3082 /* We are finished with the callbacks */ 3083 cec_curr->in_callbacks = B_FALSE; 3084 if (cec_curr->cec_want_wakeup == B_TRUE) { 3085 cec_curr->cec_want_wakeup = B_FALSE; 3086 cv_broadcast(&cec_curr->in_callbacks_cv); 3087 } 3088 3089 /* 3090 * Now "join" and "setup" are legal state transitions 3091 * and "start" and "teardown" are illegal state transitions 3092 */ 3093 CEC_SET_LEGAL(cec_curr, (ISOCH_CEC_JOIN | ISOCH_CEC_SETUP)); 3094 CEC_SET_ILLEGAL(cec_curr, (ISOCH_CEC_START | ISOCH_CEC_TEARDOWN)); 3095 3096 /* And if the member list is empty, then "free" is legal too */ 3097 if ((cec_curr->cec_member_list_head == NULL) && 3098 (cec_curr->cec_member_list_tail == NULL)) { 3099 CEC_SET_LEGAL(cec_curr, ISOCH_CEC_FREE); 3100 } 3101 3102 /* Unlock the Isoch CEC member list */ 3103 mutex_exit(&cec_curr->isoch_cec_mutex); 3104 TNF_PROBE_0_DEBUG(t1394_teardown_isoch_cec_exit, 3105 S1394_TNF_SL_ISOCH_STACK, ""); 3106 return (DDI_SUCCESS); 3107 } 3108 3109 /* 3110 * Function: t1394_alloc_isoch_dma() 3111 * Input(s): t1394_hdl The target "handle" returned by 3112 * t1394_attach() 3113 * idi This structure contains information 3114 * for configuring the data flow for 3115 * isochronous DMA 3116 * flags The flags parameter is unused (for now) 3117 * 3118 * Output(s): t1394_idma_hdl The IDMA "handle" used in all 3119 * subsequent isoch_dma() calls 3120 * result Used to pass more specific info back 3121 * to target 3122 * 3123 * Description: t1394_alloc_isoch_dma() allocates and initializes an 3124 * isochronous DMA resource for transmitting or receiving 3125 * isochronous data. If it fails, result may hold 3126 * T1394_EIDMA_NO_RESRCS, indicating that no isoch DMA resource 3127 * are available. 3128 */ 3129 /* ARGSUSED */ 3130 int 3131 t1394_alloc_isoch_dma(t1394_handle_t t1394_hdl, 3132 id1394_isoch_dmainfo_t *idi, uint_t flags, 3133 t1394_isoch_dma_handle_t *t1394_idma_hdl, int *result) 3134 { 3135 s1394_hal_t *hal; 3136 int ret; 3137 3138 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_dma_enter, 3139 S1394_TNF_SL_ISOCH_STACK, ""); 3140 3141 ASSERT(t1394_hdl != NULL); 3142 ASSERT(idi != NULL); 3143 ASSERT(t1394_idma_hdl != NULL); 3144 3145 /* Find the HAL this target resides on */ 3146 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3147 3148 /* Sanity check dma options. If talk enabled, listen should be off */ 3149 if ((idi->idma_options & ID1394_TALK) && 3150 (idi->idma_options != ID1394_TALK)) { 3151 TNF_PROBE_1(t1394_alloc_isoch_dma_talk_conflict_error, 3152 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 3153 "conflicting idma options; talker and listener"); 3154 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_dma_exit, 3155 S1394_TNF_SL_ISOCH_STACK, ""); 3156 3157 *result = T1394_EIDMA_CONFLICT; 3158 return (DDI_FAILURE); 3159 } 3160 3161 /* Only one listen mode allowed */ 3162 if ((idi->idma_options & ID1394_LISTEN_PKT_MODE) && 3163 (idi->idma_options & ID1394_LISTEN_BUF_MODE)) { 3164 TNF_PROBE_1(t1394_alloc_isoch_dma_listen_conflict_error, 3165 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 3166 "conflicting idma options; both listener modes set"); 3167 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_dma_exit, 3168 S1394_TNF_SL_ISOCH_STACK, ""); 3169 3170 *result = T1394_EIDMA_CONFLICT; 3171 return (DDI_FAILURE); 3172 } 3173 3174 /* Have HAL alloc a resource and compile ixl */ 3175 ret = HAL_CALL(hal).alloc_isoch_dma(hal->halinfo.hal_private, idi, 3176 (void **)t1394_idma_hdl, result); 3177 3178 if (ret != DDI_SUCCESS) { 3179 TNF_PROBE_1(t1394_alloc_isoch_dma_hal_error, 3180 S1394_TNF_SL_ISOCH_ERROR, "", tnf_string, msg, 3181 "HAL alloc_isoch_dma error, maybe IXL compilation"); 3182 if (*result == IXL1394_ENO_DMA_RESRCS) { 3183 *result = T1394_EIDMA_NO_RESRCS; 3184 } 3185 } 3186 3187 TNF_PROBE_0_DEBUG(t1394_alloc_isoch_dma_exit, 3188 S1394_TNF_SL_ISOCH_STACK, ""); 3189 return (ret); 3190 } 3191 3192 /* 3193 * Function: t1394_free_isoch_dma() 3194 * Input(s): t1394_hdl The target "handle" returned by 3195 * t1394_attach() 3196 * flags The flags parameter is unused (for now) 3197 * t1394_idma_hdl The IDMA "handle" returned by 3198 * t1394_alloc_isoch_dma() 3199 * 3200 * Output(s): None 3201 * 3202 * Description: t1394_free_isoch_dma() is used to free all DMA resources 3203 * allocated for the isoch stream associated with t1394_idma_hdl. 3204 */ 3205 /* ARGSUSED */ 3206 void 3207 t1394_free_isoch_dma(t1394_handle_t t1394_hdl, uint_t flags, 3208 t1394_isoch_dma_handle_t *t1394_idma_hdl) 3209 { 3210 s1394_hal_t *hal; 3211 3212 TNF_PROBE_0_DEBUG(t1394_free_isoch_dma_enter, 3213 S1394_TNF_SL_ISOCH_STACK, ""); 3214 3215 ASSERT(t1394_hdl != NULL); 3216 ASSERT(*t1394_idma_hdl != NULL); 3217 3218 /* Find the HAL this target resides on */ 3219 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3220 3221 /* Tell HAL to release local isoch dma resources */ 3222 HAL_CALL(hal).free_isoch_dma(hal->halinfo.hal_private, *t1394_idma_hdl); 3223 3224 /* Null out isoch handle */ 3225 *t1394_idma_hdl = NULL; 3226 3227 TNF_PROBE_0_DEBUG(t1394_free_isoch_dma_exit, 3228 S1394_TNF_SL_ISOCH_STACK, ""); 3229 } 3230 3231 /* 3232 * Function: t1394_start_isoch_dma() 3233 * Input(s): t1394_hdl The target "handle" returned by 3234 * t1394_attach() 3235 * t1394_idma_hdl The IDMA "handle" returned by 3236 * t1394_alloc_isoch_dma() 3237 * idma_ctrlinfo This structure contains control args 3238 * used when starting isoch DMA for 3239 * the allocated resource 3240 * flags One flag defined - ID1394_START_ON_CYCLE 3241 * 3242 * Output(s): result Used to pass more specific info back 3243 * to target 3244 * 3245 * Description: t1394_start_isoch_dma() is used to start DMA for the isoch 3246 * stream associated with t1394_idma_hdl. 3247 */ 3248 /* ARGSUSED */ 3249 int 3250 t1394_start_isoch_dma(t1394_handle_t t1394_hdl, 3251 t1394_isoch_dma_handle_t t1394_idma_hdl, 3252 id1394_isoch_dma_ctrlinfo_t *idma_ctrlinfo, uint_t flags, 3253 int *result) 3254 { 3255 s1394_hal_t *hal; 3256 int ret; 3257 3258 TNF_PROBE_0_DEBUG(t1394_start_isoch_dma_enter, 3259 S1394_TNF_SL_ISOCH_STACK, ""); 3260 3261 ASSERT(t1394_hdl != NULL); 3262 ASSERT(t1394_idma_hdl != NULL); 3263 ASSERT(idma_ctrlinfo != NULL); 3264 3265 /* Find the HAL this target resides on */ 3266 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3267 3268 ret = HAL_CALL(hal).start_isoch_dma(hal->halinfo.hal_private, 3269 (void *)t1394_idma_hdl, idma_ctrlinfo, flags, result); 3270 3271 TNF_PROBE_0_DEBUG(t1394_start_isoch_dma_exit, 3272 S1394_TNF_SL_ISOCH_STACK, ""); 3273 return (ret); 3274 } 3275 3276 /* 3277 * Function: t1394_stop_isoch_dma() 3278 * Input(s): t1394_hdl The target "handle" returned by 3279 * t1394_attach() 3280 * t1394_idma_hdl The IDMA "handle" returned by 3281 * t1394_alloc_isoch_dma() 3282 * flags The flags parameter is unused (for now) 3283 * 3284 * Output(s): None 3285 * 3286 * Description: t1394_stop_isoch_dma() is used to stop DMA for the isoch 3287 * stream associated with t1394_idma_hdl. 3288 */ 3289 /* ARGSUSED */ 3290 void 3291 t1394_stop_isoch_dma(t1394_handle_t t1394_hdl, 3292 t1394_isoch_dma_handle_t t1394_idma_hdl, uint_t flags) 3293 { 3294 s1394_hal_t *hal; 3295 int result; 3296 3297 TNF_PROBE_0_DEBUG(t1394_stop_isoch_dma_enter, 3298 S1394_TNF_SL_ISOCH_STACK, ""); 3299 3300 ASSERT(t1394_hdl != NULL); 3301 ASSERT(t1394_idma_hdl != NULL); 3302 3303 /* Find the HAL this target resides on */ 3304 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3305 3306 HAL_CALL(hal).stop_isoch_dma(hal->halinfo.hal_private, 3307 (void *)t1394_idma_hdl, &result); 3308 3309 TNF_PROBE_0_DEBUG(t1394_stop_isoch_dma_exit, 3310 S1394_TNF_SL_ISOCH_STACK, ""); 3311 } 3312 3313 /* 3314 * Function: t1394_update_isoch_dma() 3315 * Input(s): t1394_hdl The target "handle" returned by 3316 * t1394_attach() 3317 * t1394_idma_hdl The IDMA "handle" returned by 3318 * t1394_alloc_isoch_dma() 3319 * idma_updateinfo This structure contains ixl command args 3320 * used when updating args in an 3321 * existing list of ixl commands with 3322 * args in a new list of ixl commands. 3323 * flags The flags parameter is unused (for now) 3324 * 3325 * Output(s): result Used to pass more specific info back 3326 * to target 3327 * 3328 * Description: t1394_update_isoch_dma() is used to alter an IXL program that 3329 * has already been built (compiled) by t1394_alloc_isoch_dma(). 3330 */ 3331 /* ARGSUSED */ 3332 int 3333 t1394_update_isoch_dma(t1394_handle_t t1394_hdl, 3334 t1394_isoch_dma_handle_t t1394_idma_hdl, 3335 id1394_isoch_dma_updateinfo_t *idma_updateinfo, uint_t flags, 3336 int *result) 3337 { 3338 s1394_hal_t *hal; 3339 int ret; 3340 3341 TNF_PROBE_0_DEBUG(t1394_update_isoch_dma_enter, 3342 S1394_TNF_SL_ISOCH_STACK, ""); 3343 3344 ASSERT(t1394_hdl != NULL); 3345 ASSERT(t1394_idma_hdl != NULL); 3346 ASSERT(idma_updateinfo != NULL); 3347 3348 /* Find the HAL this target resides on */ 3349 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3350 3351 ret = HAL_CALL(hal).update_isoch_dma(hal->halinfo.hal_private, 3352 (void *)t1394_idma_hdl, idma_updateinfo, flags, result); 3353 3354 TNF_PROBE_0_DEBUG(t1394_update_isoch_dma_exit, 3355 S1394_TNF_SL_ISOCH_STACK, ""); 3356 return (ret); 3357 } 3358 3359 /* 3360 * Function: t1394_initiate_bus_reset() 3361 * Input(s): t1394_hdl The target "handle" returned by 3362 * t1394_attach() 3363 * flags The flags parameter is unused (for now) 3364 * 3365 * Output(s): None 3366 * 3367 * Description: t1394_initiate_bus_reset() determines whether the local 3368 * device has a P1394A PHY and will support the arbitrated 3369 * short bus reset. If not, it will initiate a normal bus reset. 3370 */ 3371 /* ARGSUSED */ 3372 void 3373 t1394_initiate_bus_reset(t1394_handle_t t1394_hdl, uint_t flags) 3374 { 3375 s1394_hal_t *hal; 3376 int ret; 3377 3378 TNF_PROBE_0_DEBUG(t1394_initiate_bus_reset_enter, 3379 S1394_TNF_SL_BR_STACK, ""); 3380 3381 ASSERT(t1394_hdl != NULL); 3382 3383 /* Find the HAL this target resides on */ 3384 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3385 3386 /* Reset the bus */ 3387 if (hal->halinfo.phy == H1394_PHY_1394A) { 3388 ret = HAL_CALL(hal).short_bus_reset(hal->halinfo.hal_private); 3389 if (ret != DDI_SUCCESS) { 3390 TNF_PROBE_1(t1394_initiate_bus_reset_error, 3391 S1394_TNF_SL_ERROR, "", tnf_string, msg, 3392 "Error initiating short bus reset"); 3393 } 3394 } else { 3395 ret = HAL_CALL(hal).bus_reset(hal->halinfo.hal_private); 3396 if (ret != DDI_SUCCESS) { 3397 TNF_PROBE_1(t1394_initiate_bus_reset_error, 3398 S1394_TNF_SL_ERROR, "", tnf_string, msg, 3399 "Error initiating bus reset"); 3400 } 3401 } 3402 3403 TNF_PROBE_0_DEBUG(t1394_initiate_bus_reset_exit, 3404 S1394_TNF_SL_BR_STACK, ""); 3405 } 3406 3407 /* 3408 * Function: t1394_get_topology_map() 3409 * Input(s): t1394_hdl The target "handle" returned by 3410 * t1394_attach() 3411 * bus_generation The current generation 3412 * tm_length The size of the tm_buffer given 3413 * flags The flags parameter is unused (for now) 3414 * 3415 * Output(s): tm_buffer Filled in by the 1394 Software Framework 3416 * with the contents of the local 3417 * TOPOLOGY_MAP 3418 * 3419 * Description: t1394_get_topology_map() returns the 1394 TOPLOGY_MAP. See 3420 * IEEE 1394-1995 Section 8.2.3.4.1 for format information. This 3421 * call can fail if there is a generation mismatch or the 3422 * tm_buffer is too small to hold the TOPOLOGY_MAP. 3423 */ 3424 /* ARGSUSED */ 3425 int 3426 t1394_get_topology_map(t1394_handle_t t1394_hdl, uint_t bus_generation, 3427 size_t tm_length, uint_t flags, uint32_t *tm_buffer) 3428 { 3429 s1394_hal_t *hal; 3430 uint32_t *tm_ptr; 3431 uint_t length; 3432 3433 TNF_PROBE_0_DEBUG(t1394_get_topology_map_enter, S1394_TNF_SL_CSR_STACK, 3434 ""); 3435 3436 ASSERT(t1394_hdl != NULL); 3437 3438 /* Find the HAL this target resides on */ 3439 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3440 3441 /* Lock the topology tree */ 3442 mutex_enter(&hal->topology_tree_mutex); 3443 3444 /* Check the bus_generation for the Topology Map */ 3445 if (bus_generation != hal->generation_count) { 3446 /* Unlock the topology tree */ 3447 mutex_exit(&hal->topology_tree_mutex); 3448 TNF_PROBE_1(t1394_get_topology_map_error, 3449 S1394_TNF_SL_CSR_ERROR, "", tnf_string, msg, 3450 "Generation mismatch"); 3451 TNF_PROBE_0_DEBUG(t1394_get_topology_map_exit, 3452 S1394_TNF_SL_CSR_STACK, ""); 3453 return (DDI_FAILURE); 3454 } 3455 3456 tm_ptr = (uint32_t *)hal->CSR_topology_map; 3457 length = tm_ptr[0] >> 16; 3458 length = length * 4; /* Bytes instead of quadlets */ 3459 length = length + 4; /* don't forget the first quad */ 3460 3461 /* Check that the buffer is big enough */ 3462 if (length > (uint_t)tm_length) { 3463 /* Unlock the topology tree */ 3464 mutex_exit(&hal->topology_tree_mutex); 3465 TNF_PROBE_1(t1394_get_topology_map_error, 3466 S1394_TNF_SL_CSR_ERROR, "", tnf_string, msg, 3467 "Buffer size too small"); 3468 TNF_PROBE_0_DEBUG(t1394_get_topology_map_exit, 3469 S1394_TNF_SL_CSR_STACK, ""); 3470 return (DDI_FAILURE); 3471 } 3472 3473 /* Do the copy */ 3474 bcopy(tm_ptr, tm_buffer, length); 3475 3476 /* Unlock the topology tree */ 3477 mutex_exit(&hal->topology_tree_mutex); 3478 TNF_PROBE_0_DEBUG(t1394_get_topology_map_exit, S1394_TNF_SL_CSR_STACK, 3479 ""); 3480 return (DDI_SUCCESS); 3481 } 3482 3483 /* 3484 * Function: t1394_CRC16() 3485 * Input(s): d The data to compute the CRC-16 for 3486 * crc_length The length into the data to compute for 3487 * flags The flags parameter is unused (for now) 3488 * 3489 * Output(s): CRC The CRC-16 computed for the length 3490 * of data specified 3491 * 3492 * Description: t1394_CRC16() implements ISO/IEC 13213:1994, ANSI/IEEE Std 3493 * 1212, 1994 - 8.1.5. 3494 */ 3495 /* ARGSUSED */ 3496 uint_t 3497 t1394_CRC16(uint32_t *d, size_t crc_length, uint_t flags) 3498 { 3499 /* Implements ISO/IEC 13213:1994, */ 3500 /* ANSI/IEEE Std 1212, 1994 - 8.1.5 */ 3501 uint_t ret; 3502 3503 TNF_PROBE_0_DEBUG(t1394_CRC16_enter, S1394_TNF_SL_STACK, ""); 3504 3505 ret = s1394_CRC16((uint_t *)d, (uint_t)crc_length); 3506 3507 TNF_PROBE_0_DEBUG(t1394_CRC16_exit, S1394_TNF_SL_STACK, ""); 3508 return (ret); 3509 } 3510 3511 /* 3512 * Function: t1394_add_cfgrom_entry() 3513 * Input(s): t1394_hdl The target "handle" returned by 3514 * t1394_attach() 3515 * cfgrom_entryinfo This structure holds the cfgrom key, 3516 * buffer, and size 3517 * flags The flags parameter is unused (for now) 3518 * 3519 * Output(s): t1394_cfgrom_hdl The ConfigROM "handle" used in 3520 * t1394_rem_cfgrom_entry() 3521 * result Used to pass more specific info back 3522 * to target 3523 * 3524 * Description: t1394_add_cfgrom_entry() adds an entry to the local Config ROM, 3525 * updating the directory entries as necessary. This call could 3526 * fail because there is no room for the new entry in Config ROM 3527 * (T1394_ECFGROM_FULL), the key is invalid (T1394_EINVALID_PARAM), 3528 * or it was called in interrupt context (T1394_EINVALID_CONTEXT). 3529 */ 3530 /* ARGSUSED */ 3531 int 3532 t1394_add_cfgrom_entry(t1394_handle_t t1394_hdl, 3533 t1394_cfgrom_entryinfo_t *cfgrom_entryinfo, uint_t flags, 3534 t1394_cfgrom_handle_t *t1394_cfgrom_hdl, int *result) 3535 { 3536 s1394_hal_t *hal; 3537 s1394_target_t *target; 3538 int ret; 3539 uint_t key; 3540 uint_t size; 3541 uint32_t *buffer; 3542 3543 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_enter, 3544 S1394_TNF_SL_CFGROM_STACK, ""); 3545 3546 ASSERT(t1394_hdl != NULL); 3547 3548 target = (s1394_target_t *)t1394_hdl; 3549 3550 key = cfgrom_entryinfo->ce_key; 3551 buffer = cfgrom_entryinfo->ce_buffer; 3552 size = (uint_t)cfgrom_entryinfo->ce_size; 3553 3554 /* Check for a valid size */ 3555 if (size == 0) { 3556 *result = T1394_EINVALID_PARAM; 3557 TNF_PROBE_1_DEBUG(t1394_add_cfgrom_entry_error, 3558 S1394_TNF_SL_CFGROM_ERROR, "", tnf_string, msg, 3559 "Invalid size of Config ROM buffer (== 0)"); 3560 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_exit, 3561 S1394_TNF_SL_CFGROM_STACK, ""); 3562 return (DDI_FAILURE); 3563 } 3564 3565 /* Check for a valid key type */ 3566 if (((key << IEEE1212_KEY_VALUE_SHIFT) & IEEE1212_KEY_TYPE_MASK) == 0) { 3567 *result = T1394_EINVALID_PARAM; 3568 TNF_PROBE_1_DEBUG(t1394_add_cfgrom_entry_error, 3569 S1394_TNF_SL_CFGROM_ERROR, "", tnf_string, msg, 3570 "Invalid key_type in Config ROM key"); 3571 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_exit, 3572 S1394_TNF_SL_CFGROM_STACK, ""); 3573 return (DDI_FAILURE); 3574 } 3575 3576 /* Find the HAL this target resides on */ 3577 hal = target->on_hal; 3578 3579 /* Is this on the interrupt stack? */ 3580 if (curthread->t_flag == T_INTR_THREAD) { 3581 *result = T1394_EINVALID_CONTEXT; 3582 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_exit, 3583 S1394_TNF_SL_CFGROM_STACK, ""); 3584 return (DDI_FAILURE); 3585 } 3586 3587 /* Lock the Config ROM buffer */ 3588 mutex_enter(&hal->local_config_rom_mutex); 3589 3590 ret = s1394_add_config_rom_entry(hal, key, buffer, size, 3591 (void **)t1394_cfgrom_hdl, result); 3592 if (ret != DDI_SUCCESS) { 3593 if (*result == CMD1394_ERSRC_CONFLICT) 3594 *result = T1394_ECFGROM_FULL; 3595 mutex_exit(&hal->local_config_rom_mutex); 3596 3597 TNF_PROBE_1(t1394_add_cfgrom_entry_error, 3598 S1394_TNF_SL_CFGROM_ERROR, "", tnf_string, msg, 3599 "Failed in s1394_add_cfgrom_entry()"); 3600 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_exit, 3601 "stacktrace 1394 s1394", ""); 3602 return (ret); 3603 } 3604 3605 /* Setup the timeout function */ 3606 if (hal->config_rom_timer_set == B_FALSE) { 3607 hal->config_rom_timer_set = B_TRUE; 3608 mutex_exit(&hal->local_config_rom_mutex); 3609 hal->config_rom_timer = 3610 timeout(s1394_update_config_rom_callback, hal, 3611 drv_usectohz(CONFIG_ROM_UPDATE_DELAY * 1000)); 3612 } else { 3613 mutex_exit(&hal->local_config_rom_mutex); 3614 } 3615 3616 TNF_PROBE_0_DEBUG(t1394_add_cfgrom_entry_exit, 3617 S1394_TNF_SL_CFGROM_STACK, ""); 3618 return (ret); 3619 } 3620 3621 /* 3622 * Function: t1394_rem_cfgrom_entry() 3623 * Input(s): t1394_hdl The target "handle" returned by 3624 * t1394_attach() 3625 * flags The flags parameter is unused (for now) 3626 * t1394_cfgrom_hdl The ConfigROM "handle" returned by 3627 * t1394_add_cfgrom_entry() 3628 * 3629 * Output(s): result Used to pass more specific info back 3630 * to target 3631 * 3632 * Description: t1394_rem_cfgrom_entry() is used to remove a previously added 3633 * Config ROM entry (indicated by t1394_cfgrom_hdl). 3634 */ 3635 /* ARGSUSED */ 3636 int 3637 t1394_rem_cfgrom_entry(t1394_handle_t t1394_hdl, uint_t flags, 3638 t1394_cfgrom_handle_t *t1394_cfgrom_hdl, int *result) 3639 { 3640 s1394_hal_t *hal; 3641 s1394_target_t *target; 3642 int ret; 3643 3644 TNF_PROBE_0_DEBUG(t1394_rem_cfgrom_entry_enter, 3645 S1394_TNF_SL_CFGROM_STACK, ""); 3646 3647 ASSERT(t1394_hdl != NULL); 3648 3649 target = (s1394_target_t *)t1394_hdl; 3650 3651 /* Find the HAL this target resides on */ 3652 hal = target->on_hal; 3653 3654 /* Is this on the interrupt stack? */ 3655 if (curthread->t_flag == T_INTR_THREAD) { 3656 *result = T1394_EINVALID_CONTEXT; 3657 TNF_PROBE_0_DEBUG(t1394_rem_cfgrom_entry_exit, 3658 S1394_TNF_SL_CFGROM_STACK, ""); 3659 return (DDI_FAILURE); 3660 } 3661 3662 /* Lock the Config ROM buffer */ 3663 mutex_enter(&hal->local_config_rom_mutex); 3664 3665 ret = s1394_remove_config_rom_entry(hal, (void **)t1394_cfgrom_hdl, 3666 result); 3667 if (ret != DDI_SUCCESS) { 3668 mutex_exit(&hal->local_config_rom_mutex); 3669 TNF_PROBE_1(t1394_rem_cfgrom_entry_error, 3670 S1394_TNF_SL_CFGROM_ERROR, "", tnf_string, msg, 3671 "Failed in s1394_remove_cfgrom_entry()"); 3672 TNF_PROBE_0_DEBUG(t1394_rem_cfgrom_entry_exit, 3673 "stacktrace 1394 s1394", ""); 3674 return (ret); 3675 } 3676 3677 /* Setup the timeout function */ 3678 if (hal->config_rom_timer_set == B_FALSE) { 3679 hal->config_rom_timer_set = B_TRUE; 3680 mutex_exit(&hal->local_config_rom_mutex); 3681 hal->config_rom_timer = 3682 timeout(s1394_update_config_rom_callback, hal, 3683 drv_usectohz(CONFIG_ROM_UPDATE_DELAY * 1000)); 3684 } else { 3685 mutex_exit(&hal->local_config_rom_mutex); 3686 } 3687 3688 TNF_PROBE_0_DEBUG(t1394_rem_cfgrom_entry_exit, 3689 S1394_TNF_SL_CFGROM_STACK, ""); 3690 return (ret); 3691 } 3692 3693 /* 3694 * Function: t1394_get_targetinfo() 3695 * Input(s): t1394_hdl The target "handle" returned by 3696 * t1394_attach() 3697 * bus_generation The current generation 3698 * flags The flags parameter is unused (for now) 3699 * 3700 * Output(s): targetinfo Structure containing max_payload, 3701 * max_speed, and target node ID. 3702 * 3703 * Description: t1394_get_targetinfo() is used to retrieve information specific 3704 * to a target device. It will fail if the generation given 3705 * does not match the current generation. 3706 */ 3707 /* ARGSUSED */ 3708 int 3709 t1394_get_targetinfo(t1394_handle_t t1394_hdl, uint_t bus_generation, 3710 uint_t flags, t1394_targetinfo_t *targetinfo) 3711 { 3712 s1394_hal_t *hal; 3713 s1394_target_t *target; 3714 uint_t dev; 3715 uint_t curr; 3716 uint_t from_node; 3717 uint_t to_node; 3718 3719 TNF_PROBE_0_DEBUG(t1394_get_targetinfo_enter, S1394_TNF_SL_STACK, ""); 3720 3721 ASSERT(t1394_hdl != NULL); 3722 3723 /* Find the HAL this target resides on */ 3724 hal = ((s1394_target_t *)t1394_hdl)->on_hal; 3725 3726 target = (s1394_target_t *)t1394_hdl; 3727 3728 /* Lock the topology tree */ 3729 mutex_enter(&hal->topology_tree_mutex); 3730 3731 /* Check the bus_generation */ 3732 if (bus_generation != hal->generation_count) { 3733 /* Unlock the topology tree */ 3734 mutex_exit(&hal->topology_tree_mutex); 3735 TNF_PROBE_3(t1394_get_targetinfo_error, S1394_TNF_SL_STACK, "", 3736 tnf_string, msg, "Generation mismatch", 3737 tnf_uint, gen, bus_generation, 3738 tnf_uint, current_gen, hal->generation_count); 3739 return (DDI_FAILURE); 3740 } 3741 3742 rw_enter(&hal->target_list_rwlock, RW_READER); 3743 /* 3744 * If there is no node, report T1394_INVALID_NODEID for target_nodeID; 3745 * current_max_speed and current_max_payload are undefined for this 3746 * case. 3747 */ 3748 if (((target->target_state & S1394_TARG_GONE) != 0) || 3749 (target->on_node == NULL)) { 3750 targetinfo->target_nodeID = T1394_INVALID_NODEID; 3751 TNF_PROBE_1_DEBUG(t1394_get_targetinfo_exit, 3752 S1394_TNF_SL_STACK, "", tnf_string, msg, "No device"); 3753 } else { 3754 targetinfo->target_nodeID = 3755 (target->on_hal->node_id & IEEE1394_BUS_NUM_MASK) | 3756 target->on_node->node_num; 3757 3758 from_node = (target->on_hal->node_id) & IEEE1394_NODE_NUM_MASK; 3759 to_node = target->on_node->node_num; 3760 3761 targetinfo->current_max_speed = (uint_t)s1394_speed_map_get( 3762 hal, from_node, to_node); 3763 3764 /* Get current_max_payload */ 3765 s1394_get_maxpayload(target, &dev, &curr); 3766 targetinfo->current_max_payload = curr; 3767 3768 TNF_PROBE_3_DEBUG(t1394_get_targetinfo_exit, 3769 S1394_TNF_SL_STACK, "", 3770 tnf_uint, payload, targetinfo->current_max_payload, 3771 tnf_uint, speed, targetinfo->current_max_speed, 3772 tnf_uint, nodeid, targetinfo->target_nodeID); 3773 } 3774 3775 rw_exit(&hal->target_list_rwlock); 3776 /* Unlock the topology tree */ 3777 mutex_exit(&hal->topology_tree_mutex); 3778 return (DDI_SUCCESS); 3779 } 3780