sbp.c revision 1.19
1 /* $NetBSD: sbp.c,v 1.19 2007/11/05 19:08:57 kiyohara Exp $ */ 2 /*- 3 * Copyright (c) 2003 Hidetoshi Shimokawa 4 * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the acknowledgement as bellow: 17 * 18 * This product includes software developed by K. Kobayashi and H. Shimokawa 19 * 20 * 4. The name of the author may not be used to endorse or promote products 21 * derived from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 27 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 29 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 31 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 32 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 * 35 * $FreeBSD: src/sys/dev/firewire/sbp.c,v 1.92 2007/06/06 14:31:36 simokawa Exp $ 36 * 37 */ 38 39 #if defined(__FreeBSD__) 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/conf.h> 43 #include <sys/module.h> 44 #include <sys/bus.h> 45 #include <sys/kernel.h> 46 #include <sys/sysctl.h> 47 #include <sys/bus.h> 48 #include <sys/malloc.h> 49 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102 50 #include <sys/lock.h> 51 #include <sys/mutex.h> 52 #endif 53 54 #if defined(__DragonFly__) || __FreeBSD_version < 500106 55 #include <sys/devicestat.h> /* for struct devstat */ 56 #endif 57 58 #ifdef __DragonFly__ 59 #include <bus/cam/cam.h> 60 #include <bus/cam/cam_ccb.h> 61 #include <bus/cam/cam_sim.h> 62 #include <bus/cam/cam_xpt_sim.h> 63 #include <bus/cam/cam_debug.h> 64 #include <bus/cam/cam_periph.h> 65 #include <bus/cam/scsi/scsi_all.h> 66 67 #include <bus/firewire/fw_port.h> 68 #include <bus/firewire/firewire.h> 69 #include <bus/firewire/firewirereg.h> 70 #include <bus/firewire/fwdma.h> 71 #include <bus/firewire/iec13213.h> 72 #include "sbp.h" 73 #else 74 #include <cam/cam.h> 75 #include <cam/cam_ccb.h> 76 #include <cam/cam_sim.h> 77 #include <cam/cam_xpt_sim.h> 78 #include <cam/cam_debug.h> 79 #include <cam/cam_periph.h> 80 #include <cam/scsi/scsi_all.h> 81 82 #include <dev/firewire/fw_port.h> 83 #include <dev/firewire/firewire.h> 84 #include <dev/firewire/firewirereg.h> 85 #include <dev/firewire/fwdma.h> 86 #include <dev/firewire/iec13213.h> 87 #include <dev/firewire/sbp.h> 88 #endif 89 #elif defined(__NetBSD__) 90 #include <sys/param.h> 91 #include <sys/device.h> 92 #include <sys/errno.h> 93 #include <sys/buf.h> 94 #include <sys/kernel.h> 95 #include <sys/kthread.h> 96 #include <sys/malloc.h> 97 #include <sys/proc.h> 98 #include <sys/sysctl.h> 99 100 #include <sys/bus.h> 101 102 #include <dev/scsipi/scsi_spc.h> 103 #include <dev/scsipi/scsi_all.h> 104 #include <dev/scsipi/scsipi_all.h> 105 #include <dev/scsipi/scsiconf.h> 106 #include <dev/scsipi/scsipiconf.h> 107 108 #include <dev/ieee1394/fw_port.h> 109 #include <dev/ieee1394/firewire.h> 110 #include <dev/ieee1394/firewirereg.h> 111 #include <dev/ieee1394/fwdma.h> 112 #include <dev/ieee1394/iec13213.h> 113 #include <dev/ieee1394/sbp.h> 114 115 #include "locators.h" 116 #endif 117 118 #define ccb_sdev_ptr spriv_ptr0 119 #define ccb_sbp_ptr spriv_ptr1 120 121 #define SBP_NUM_TARGETS 8 /* MAX 64 */ 122 /* 123 * Scan_bus doesn't work for more than 8 LUNs 124 * because of CAM_SCSI2_MAXLUN in cam_xpt.c 125 */ 126 #define SBP_NUM_LUNS 64 127 #define SBP_MAXPHYS MIN(MAXPHYS, (512*1024) /* 512KB */) 128 #define SBP_DMA_SIZE PAGE_SIZE 129 #define SBP_LOGIN_SIZE sizeof(struct sbp_login_res) 130 #define SBP_QUEUE_LEN ((SBP_DMA_SIZE - SBP_LOGIN_SIZE) / sizeof(struct sbp_ocb)) 131 #define SBP_NUM_OCB (SBP_QUEUE_LEN * SBP_NUM_TARGETS) 132 133 /* 134 * STATUS FIFO addressing 135 * bit 136 * ----------------------- 137 * 0- 1( 2): 0 (alignment) 138 * 2- 9( 8): lun 139 * 10-31(14): unit 140 * 32-47(16): SBP_BIND_HI 141 * 48-64(16): bus_id, node_id 142 */ 143 #define SBP_BIND_HI 0x1 144 #define SBP_DEV2ADDR(u, l) \ 145 (((u_int64_t)SBP_BIND_HI << 32) \ 146 | (((u) & 0x3fff) << 10) \ 147 | (((l) & 0xff) << 2)) 148 #define SBP_ADDR2UNIT(a) (((a) >> 10) & 0x3fff) 149 #define SBP_ADDR2LUN(a) (((a) >> 2) & 0xff) 150 #define SBP_INITIATOR 7 151 152 static const char *orb_fun_name[] = { 153 ORB_FUN_NAMES 154 }; 155 156 static int debug = 0; 157 static int auto_login = 1; 158 static int max_speed = -1; 159 static int sbp_cold = 1; 160 static int ex_login = 1; 161 static int login_delay = 1000; /* msec */ 162 static int scan_delay = 500; /* msec */ 163 static int use_doorbell = 0; 164 static int sbp_tags = 0; 165 166 #if defined(__FreeBSD__) 167 SYSCTL_DECL(_hw_firewire); 168 SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD, 0, "SBP-II Subsystem"); 169 SYSCTL_INT(_debug, OID_AUTO, sbp_debug, CTLFLAG_RW, &debug, 0, 170 "SBP debug flag"); 171 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, auto_login, CTLFLAG_RW, &auto_login, 0, 172 "SBP perform login automatically"); 173 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, max_speed, CTLFLAG_RW, &max_speed, 0, 174 "SBP transfer max speed"); 175 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, exclusive_login, CTLFLAG_RW, 176 &ex_login, 0, "SBP enable exclusive login"); 177 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, login_delay, CTLFLAG_RW, 178 &login_delay, 0, "SBP login delay in msec"); 179 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, scan_delay, CTLFLAG_RW, 180 &scan_delay, 0, "SBP scan delay in msec"); 181 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, use_doorbell, CTLFLAG_RW, 182 &use_doorbell, 0, "SBP use doorbell request"); 183 SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, tags, CTLFLAG_RW, &sbp_tags, 0, 184 "SBP tagged queuing support"); 185 186 TUNABLE_INT("hw.firewire.sbp.auto_login", &auto_login); 187 TUNABLE_INT("hw.firewire.sbp.max_speed", &max_speed); 188 TUNABLE_INT("hw.firewire.sbp.exclusive_login", &ex_login); 189 TUNABLE_INT("hw.firewire.sbp.login_delay", &login_delay); 190 TUNABLE_INT("hw.firewire.sbp.scan_delay", &scan_delay); 191 TUNABLE_INT("hw.firewire.sbp.use_doorbell", &use_doorbell); 192 TUNABLE_INT("hw.firewire.sbp.tags", &sbp_tags); 193 #elif defined(__NetBSD__) 194 static int sysctl_sbp_verify(SYSCTLFN_PROTO, int lower, int upper); 195 static int sysctl_sbp_verify_max_speed(SYSCTLFN_PROTO); 196 static int sysctl_sbp_verify_tags(SYSCTLFN_PROTO); 197 198 /* 199 * Setup sysctl(3) MIB, hw.sbp.* 200 * 201 * TBD condition CTLFLAG_PERMANENT on being an LKM or not 202 */ 203 SYSCTL_SETUP(sysctl_sbp, "sysctl sbp(4) subtree setup") 204 { 205 int rc, sbp_node_num; 206 const struct sysctlnode *node; 207 208 if ((rc = sysctl_createv(clog, 0, NULL, NULL, 209 CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL, 210 NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) { 211 goto err; 212 } 213 214 if ((rc = sysctl_createv(clog, 0, NULL, &node, 215 CTLFLAG_PERMANENT, CTLTYPE_NODE, "sbp", 216 SYSCTL_DESCR("sbp controls"), NULL, 0, NULL, 217 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) { 218 goto err; 219 } 220 sbp_node_num = node->sysctl_num; 221 222 /* sbp auto login flag */ 223 if ((rc = sysctl_createv(clog, 0, NULL, &node, 224 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 225 "auto_login", SYSCTL_DESCR("SBP perform login automatically"), 226 NULL, 0, &auto_login, 227 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 228 goto err; 229 } 230 231 /* sbp max speed */ 232 if ((rc = sysctl_createv(clog, 0, NULL, &node, 233 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 234 "max_speed", SYSCTL_DESCR("SBP transfer max speed"), 235 sysctl_sbp_verify_max_speed, 0, &max_speed, 236 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 237 goto err; 238 } 239 240 /* sbp exclusive login flag */ 241 if ((rc = sysctl_createv(clog, 0, NULL, &node, 242 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 243 "exclusive_login", SYSCTL_DESCR("SBP enable exclusive login"), 244 NULL, 0, &ex_login, 245 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 246 goto err; 247 } 248 249 /* sbp login delay */ 250 if ((rc = sysctl_createv(clog, 0, NULL, &node, 251 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 252 "login_delay", SYSCTL_DESCR("SBP login delay in msec"), 253 NULL, 0, &login_delay, 254 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 255 goto err; 256 } 257 258 /* sbp scan delay */ 259 if ((rc = sysctl_createv(clog, 0, NULL, &node, 260 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 261 "scan_delay", SYSCTL_DESCR("SBP scan delay in msec"), 262 NULL, 0, &scan_delay, 263 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 264 goto err; 265 } 266 267 /* sbp use doorbell flag */ 268 if ((rc = sysctl_createv(clog, 0, NULL, &node, 269 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 270 "use_doorbell", SYSCTL_DESCR("SBP use doorbell request"), 271 NULL, 0, &use_doorbell, 272 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 273 goto err; 274 } 275 276 /* sbp force tagged queuing */ 277 if ((rc = sysctl_createv(clog, 0, NULL, &node, 278 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 279 "tags", SYSCTL_DESCR("SBP tagged queuing support"), 280 sysctl_sbp_verify_tags, 0, &sbp_tags, 281 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 282 goto err; 283 } 284 285 /* sbp driver debug flag */ 286 if ((rc = sysctl_createv(clog, 0, NULL, &node, 287 CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT, 288 "sbp_debug", SYSCTL_DESCR("SBP debug flag"), 289 NULL, 0, &debug, 290 0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) { 291 goto err; 292 } 293 294 return; 295 296 err: 297 printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc); 298 } 299 300 static int 301 sysctl_sbp_verify(SYSCTLFN_ARGS, int lower, int upper) 302 { 303 int error, t; 304 struct sysctlnode node; 305 306 node = *rnode; 307 t = *(int*)rnode->sysctl_data; 308 node.sysctl_data = &t; 309 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 310 if (error || newp == NULL) 311 return (error); 312 313 if (t < lower || t > upper) 314 return (EINVAL); 315 316 *(int*)rnode->sysctl_data = t; 317 318 return (0); 319 } 320 321 static int 322 sysctl_sbp_verify_max_speed(SYSCTLFN_ARGS) 323 { 324 return (sysctl_sbp_verify(SYSCTLFN_CALL(rnode), 0, FWSPD_S400)); 325 } 326 327 static int 328 sysctl_sbp_verify_tags(SYSCTLFN_ARGS) 329 { 330 return (sysctl_sbp_verify(SYSCTLFN_CALL(rnode), -1, 1)); 331 } 332 #endif 333 334 #define NEED_RESPONSE 0 335 336 #define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE) 337 #ifdef __sparc64__ /* iommu */ 338 #define SBP_IND_MAX howmany(SBP_MAXPHYS, SBP_SEG_MAX) 339 #else 340 #define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE) 341 #endif 342 struct sbp_ocb { 343 STAILQ_ENTRY(sbp_ocb) ocb; 344 sbp_scsi_xfer *sxfer; 345 bus_addr_t bus_addr; 346 uint32_t orb[8]; 347 #define IND_PTR_OFFSET (8*sizeof(uint32_t)) 348 struct ind_ptr ind_ptr[SBP_IND_MAX]; 349 struct sbp_dev *sdev; 350 int flags; /* XXX should be removed */ 351 bus_dmamap_t dmamap; 352 }; 353 354 #define OCB_ACT_MGM 0 355 #define OCB_ACT_CMD 1 356 #define OCB_MATCH(o,s) ((o)->bus_addr == ntohl((s)->orb_lo)) 357 358 struct sbp_dev{ 359 #define SBP_DEV_RESET 0 /* accept login */ 360 #define SBP_DEV_LOGIN 1 /* to login */ 361 #if 0 362 #define SBP_DEV_RECONN 2 /* to reconnect */ 363 #endif 364 #define SBP_DEV_TOATTACH 3 /* to attach */ 365 #define SBP_DEV_PROBE 4 /* scan lun */ 366 #define SBP_DEV_ATTACHED 5 /* in operation */ 367 #define SBP_DEV_DEAD 6 /* unavailable unit */ 368 #define SBP_DEV_RETRY 7 /* unavailable unit */ 369 uint8_t status:4, 370 timeout:4; 371 uint8_t type; 372 uint16_t lun_id; 373 uint16_t freeze; 374 #define ORB_LINK_DEAD (1 << 0) 375 #define VALID_LUN (1 << 1) 376 #define ORB_POINTER_ACTIVE (1 << 2) 377 #define ORB_POINTER_NEED (1 << 3) 378 #define ORB_DOORBELL_ACTIVE (1 << 4) 379 #define ORB_DOORBELL_NEED (1 << 5) 380 #define ORB_SHORTAGE (1 << 6) 381 uint16_t flags; 382 #if defined(__FreeBSD__) 383 struct cam_path *path; 384 #elif defined(__NetBSD__) 385 struct scsipi_periph *periph; 386 #endif 387 struct sbp_target *target; 388 struct fwdma_alloc dma; 389 struct sbp_login_res *login; 390 struct callout login_callout; 391 struct sbp_ocb *ocb; 392 STAILQ_HEAD(, sbp_ocb) ocbs; 393 STAILQ_HEAD(, sbp_ocb) free_ocbs; 394 struct sbp_ocb *last_ocb; 395 char vendor[32]; 396 char product[32]; 397 char revision[10]; 398 }; 399 400 struct sbp_target { 401 int target_id; 402 int num_lun; 403 struct sbp_dev **luns; 404 struct sbp_softc *sbp; 405 struct fw_device *fwdev; 406 uint32_t mgm_hi, mgm_lo; 407 struct sbp_ocb *mgm_ocb_cur; 408 STAILQ_HEAD(, sbp_ocb) mgm_ocb_queue; 409 struct callout mgm_ocb_timeout; 410 struct callout scan_callout; 411 STAILQ_HEAD(, fw_xfer) xferlist; 412 int n_xfer; 413 }; 414 415 struct sbp_softc { 416 struct firewire_dev_comm fd; 417 #if defined(__FreeBSD__) 418 struct cam_sim *sim; 419 struct cam_path *path; 420 #elif defined(__NetBSD__) 421 struct scsipi_adapter sc_adapter; 422 struct scsipi_channel sc_channel; 423 struct device *sc_bus; 424 struct lwp *lwp; 425 #endif 426 struct sbp_target target; 427 struct fw_bind fwb; 428 fw_bus_dma_tag_t dmat; 429 struct timeval last_busreset; 430 #define SIMQ_FREEZED 1 431 int flags; 432 fw_mtx_t mtx; 433 }; 434 #define SBP_LOCK(sbp) fw_mtx_lock(&(sbp)->mtx) 435 #define SBP_UNLOCK(sbp) fw_mtx_unlock(&(sbp)->mtx) 436 437 #if defined(__NetBSD__) 438 int sbpmatch (struct device *, struct cfdata *, void *); 439 void sbpattach (struct device *parent, struct device *self, void *aux); 440 int sbpdetach (struct device *self, int flags); 441 #endif 442 static void sbp_post_explore (void *); 443 static void sbp_recv (struct fw_xfer *); 444 static void sbp_mgm_callback (struct fw_xfer *); 445 #if 0 446 static void sbp_cmd_callback (struct fw_xfer *); 447 #endif 448 static void sbp_orb_pointer (struct sbp_dev *, struct sbp_ocb *); 449 static void sbp_doorbell(struct sbp_dev *); 450 static void sbp_execute_ocb (void *, bus_dma_segment_t *, int, int); 451 static void sbp_free_ocb (struct sbp_dev *, struct sbp_ocb *); 452 static void sbp_abort_ocb (struct sbp_ocb *, int); 453 static void sbp_abort_all_ocbs (struct sbp_dev *, int); 454 static struct fw_xfer * sbp_write_cmd (struct sbp_dev *, int, int); 455 static struct sbp_ocb * sbp_get_ocb (struct sbp_dev *); 456 static struct sbp_ocb * sbp_enqueue_ocb (struct sbp_dev *, struct sbp_ocb *); 457 static struct sbp_ocb * sbp_dequeue_ocb (struct sbp_dev *, struct sbp_status *); 458 static void sbp_free_sdev(struct sbp_dev *); 459 static void sbp_free_target (struct sbp_target *); 460 static void sbp_mgm_timeout (void *arg); 461 static void sbp_timeout (void *arg); 462 static void sbp_mgm_orb (struct sbp_dev *, int, struct sbp_ocb *); 463 #if defined(__FreeBSD__) 464 465 MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/FireWire"); 466 #elif defined(__NetBSD__) 467 static void sbp_scsipi_request( 468 struct scsipi_channel *, scsipi_adapter_req_t, void *); 469 static void sbp_minphys(struct buf *); 470 471 MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/IEEE1394"); 472 #endif 473 474 #if defined(__FreeBSD__) 475 /* cam related functions */ 476 static void sbp_action(struct cam_sim *, sbp_scsi_xfer *sxfer); 477 static void sbp_poll(struct cam_sim *); 478 static void sbp_cam_scan_lun(struct cam_periph *, sbp_scsi_xfer *); 479 static void sbp_cam_scan_target(void *); 480 static void sbp_cam_detach_sdev(struct sbp_dev *); 481 static void sbp_cam_detach_target (struct sbp_target *); 482 #define SBP_DETACH_SDEV(sd) sbp_cam_detach_sdev((sd)) 483 #define SBP_DETACH_TARGET(st) sbp_cam_detach_target((st)) 484 #elif defined(__NetBSD__) 485 /* scsipi related functions */ 486 static void sbp_scsipi_scan_target(void *); 487 static void sbp_scsipi_detach_sdev(struct sbp_dev *); 488 static void sbp_scsipi_detach_target (struct sbp_target *); 489 #define SBP_DETACH_SDEV(sd) sbp_scsipi_detach_sdev((sd)) 490 #define SBP_DETACH_TARGET(st) sbp_scsipi_detach_target((st)) 491 #endif 492 493 static const char *orb_status0[] = { 494 /* 0 */ "No additional information to report", 495 /* 1 */ "Request type not supported", 496 /* 2 */ "Speed not supported", 497 /* 3 */ "Page size not supported", 498 /* 4 */ "Access denied", 499 /* 5 */ "Logical unit not supported", 500 /* 6 */ "Maximum payload too small", 501 /* 7 */ "Reserved for future standardization", 502 /* 8 */ "Resources unavailable", 503 /* 9 */ "Function rejected", 504 /* A */ "Login ID not recognized", 505 /* B */ "Dummy ORB completed", 506 /* C */ "Request aborted", 507 /* FF */ "Unspecified error" 508 #define MAX_ORB_STATUS0 0xd 509 }; 510 511 static const char *orb_status1_object[] = { 512 /* 0 */ "Operation request block (ORB)", 513 /* 1 */ "Data buffer", 514 /* 2 */ "Page table", 515 /* 3 */ "Unable to specify" 516 }; 517 518 static const char *orb_status1_serial_bus_error[] = { 519 /* 0 */ "Missing acknowledge", 520 /* 1 */ "Reserved; not to be used", 521 /* 2 */ "Time-out error", 522 /* 3 */ "Reserved; not to be used", 523 /* 4 */ "Busy retry limit exceeded(X)", 524 /* 5 */ "Busy retry limit exceeded(A)", 525 /* 6 */ "Busy retry limit exceeded(B)", 526 /* 7 */ "Reserved for future standardization", 527 /* 8 */ "Reserved for future standardization", 528 /* 9 */ "Reserved for future standardization", 529 /* A */ "Reserved for future standardization", 530 /* B */ "Tardy retry limit exceeded", 531 /* C */ "Conflict error", 532 /* D */ "Data error", 533 /* E */ "Type error", 534 /* F */ "Address error" 535 }; 536 537 #if defined(__FreeBSD__) 538 #if 0 539 static void 540 sbp_identify(driver_t *driver, device_t parent) 541 { 542 device_t child; 543 SBP_DEBUG(0) 544 printf("sbp_identify\n"); 545 END_DEBUG 546 547 child = BUS_ADD_CHILD(parent, 0, "sbp", fw_get_unit(parent)); 548 } 549 #endif 550 551 /* 552 * sbp_probe() 553 */ 554 static int 555 sbp_probe(device_t dev) 556 { 557 device_t pa; 558 559 SBP_DEBUG(0) 560 printf("sbp_probe\n"); 561 END_DEBUG 562 563 pa = device_get_parent(dev); 564 if(fw_get_unit(dev) != fw_get_unit(pa)){ 565 return(ENXIO); 566 } 567 568 device_set_desc(dev, "SBP-2/SCSI over FireWire"); 569 570 #if 0 571 if (bootverbose) 572 debug = bootverbose; 573 #endif 574 575 return (0); 576 } 577 #elif defined(__NetBSD__) 578 int 579 sbpmatch(struct device *parent, struct cfdata *cf, void *aux) 580 { 581 struct fw_attach_args *fwa = aux; 582 583 if (strcmp(fwa->name, "sbp") == 0) 584 return 1; 585 return 0; 586 } 587 #endif 588 589 static void 590 sbp_show_sdev_info(struct sbp_dev *sdev, int new) 591 { 592 struct fw_device *fwdev; 593 594 printf("%s:%d:%d ", 595 fw_get_nameunit(sdev->target->sbp->fd.dev), 596 sdev->target->target_id, 597 sdev->lun_id 598 ); 599 if (new == 2) { 600 return; 601 } 602 fwdev = sdev->target->fwdev; 603 printf("ordered:%d type:%d EUI:%08x%08x node:%d " 604 "speed:%d maxrec:%d", 605 (sdev->type & 0x40) >> 6, 606 (sdev->type & 0x1f), 607 fwdev->eui.hi, 608 fwdev->eui.lo, 609 fwdev->dst, 610 fwdev->speed, 611 fwdev->maxrec 612 ); 613 if (new) 614 printf(" new!\n"); 615 else 616 printf("\n"); 617 sbp_show_sdev_info(sdev, 2); 618 printf("'%s' '%s' '%s'\n", sdev->vendor, sdev->product, sdev->revision); 619 } 620 621 static void 622 sbp_alloc_lun(struct sbp_target *target) 623 { 624 struct crom_context cc; 625 struct csrreg *reg; 626 struct sbp_dev *sdev, **newluns; 627 struct sbp_softc *sbp; 628 int maxlun, lun, i; 629 630 sbp = target->sbp; 631 crom_init_context(&cc, target->fwdev->csrrom); 632 /* XXX shoud parse appropriate unit directories only */ 633 maxlun = -1; 634 while (cc.depth >= 0) { 635 reg = crom_search_key(&cc, CROM_LUN); 636 if (reg == NULL) 637 break; 638 lun = reg->val & 0xffff; 639 SBP_DEBUG(0) 640 printf("target %d lun %d found\n", target->target_id, lun); 641 END_DEBUG 642 if (maxlun < lun) 643 maxlun = lun; 644 crom_next(&cc); 645 } 646 if (maxlun < 0) 647 printf("%s:%d no LUN found\n", 648 fw_get_nameunit(target->sbp->fd.dev), 649 target->target_id); 650 651 maxlun ++; 652 if (maxlun >= SBP_NUM_LUNS) 653 maxlun = SBP_NUM_LUNS; 654 655 /* Invalidiate stale devices */ 656 for (lun = 0; lun < target->num_lun; lun ++) { 657 sdev = target->luns[lun]; 658 if (sdev == NULL) 659 continue; 660 sdev->flags &= ~VALID_LUN; 661 if (lun >= maxlun) { 662 /* lost device */ 663 SBP_DETACH_SDEV(sdev); 664 sbp_free_sdev(sdev); 665 } 666 } 667 668 /* Reallocate */ 669 if (maxlun != target->num_lun) { 670 newluns = (struct sbp_dev **) realloc(target->luns, 671 sizeof(struct sbp_dev *) * maxlun, 672 M_SBP, M_NOWAIT | M_ZERO); 673 674 if (newluns == NULL) { 675 printf("%s: realloc failed\n", __func__); 676 newluns = target->luns; 677 maxlun = target->num_lun; 678 } 679 680 /* 681 * We must zero the extended region for the case 682 * realloc() doesn't allocate new buffer. 683 */ 684 if (maxlun > target->num_lun) 685 bzero(&newluns[target->num_lun], 686 sizeof(struct sbp_dev *) * 687 (maxlun - target->num_lun)); 688 689 target->luns = newluns; 690 target->num_lun = maxlun; 691 } 692 693 crom_init_context(&cc, target->fwdev->csrrom); 694 while (cc.depth >= 0) { 695 int new = 0; 696 697 reg = crom_search_key(&cc, CROM_LUN); 698 if (reg == NULL) 699 break; 700 lun = reg->val & 0xffff; 701 if (lun >= SBP_NUM_LUNS) { 702 printf("too large lun %d\n", lun); 703 goto next; 704 } 705 706 sdev = target->luns[lun]; 707 if (sdev == NULL) { 708 sdev = malloc(sizeof(struct sbp_dev), 709 M_SBP, M_NOWAIT | M_ZERO); 710 if (sdev == NULL) { 711 printf("%s: malloc failed\n", __func__); 712 goto next; 713 } 714 target->luns[lun] = sdev; 715 sdev->lun_id = lun; 716 sdev->target = target; 717 STAILQ_INIT(&sdev->ocbs); 718 fw_callout_init(&sdev->login_callout); 719 sdev->status = SBP_DEV_RESET; 720 new = 1; 721 SBP_DEVICE_PREATTACH(); 722 } 723 sdev->flags |= VALID_LUN; 724 sdev->type = (reg->val & 0xff0000) >> 16; 725 726 if (new == 0) 727 goto next; 728 729 fwdma_malloc(sbp->fd.fc, 730 /* alignment */ sizeof(uint32_t), 731 SBP_DMA_SIZE, &sdev->dma, BUS_DMA_NOWAIT); 732 if (sdev->dma.v_addr == NULL) { 733 printf("%s: dma space allocation failed\n", 734 __func__); 735 free(sdev, M_SBP); 736 target->luns[lun] = NULL; 737 goto next; 738 } 739 sdev->login = (struct sbp_login_res *) sdev->dma.v_addr; 740 sdev->ocb = (struct sbp_ocb *) 741 ((char *)sdev->dma.v_addr + SBP_LOGIN_SIZE); 742 bzero((char *)sdev->ocb, 743 sizeof (struct sbp_ocb) * SBP_QUEUE_LEN); 744 745 STAILQ_INIT(&sdev->free_ocbs); 746 for (i = 0; i < SBP_QUEUE_LEN; i++) { 747 struct sbp_ocb *ocb; 748 ocb = &sdev->ocb[i]; 749 ocb->bus_addr = sdev->dma.bus_addr 750 + SBP_LOGIN_SIZE 751 + sizeof(struct sbp_ocb) * i 752 + offsetof(struct sbp_ocb, orb[0]); 753 if (fw_bus_dmamap_create(sbp->dmat, 0, &ocb->dmamap)) { 754 printf("sbp_attach: cannot create dmamap\n"); 755 /* XXX */ 756 goto next; 757 } 758 sbp_free_ocb(sdev, ocb); 759 } 760 next: 761 crom_next(&cc); 762 } 763 764 for (lun = 0; lun < target->num_lun; lun ++) { 765 sdev = target->luns[lun]; 766 if (sdev != NULL && (sdev->flags & VALID_LUN) == 0) { 767 SBP_DETACH_SDEV(sdev); 768 sbp_free_sdev(sdev); 769 target->luns[lun] = NULL; 770 } 771 } 772 } 773 774 static struct sbp_target * 775 sbp_alloc_target(struct sbp_softc *sbp, struct fw_device *fwdev) 776 { 777 struct sbp_target *target; 778 struct crom_context cc; 779 struct csrreg *reg; 780 781 SBP_DEBUG(1) 782 printf("sbp_alloc_target\n"); 783 END_DEBUG 784 /* new target */ 785 target = &sbp->target; 786 target->sbp = sbp; 787 target->fwdev = fwdev; 788 target->target_id = 0; 789 /* XXX we may want to reload mgm port after each bus reset */ 790 /* XXX there might be multiple management agents */ 791 crom_init_context(&cc, target->fwdev->csrrom); 792 reg = crom_search_key(&cc, CROM_MGM); 793 if (reg == NULL || reg->val == 0) { 794 printf("NULL management address\n"); 795 target->fwdev = NULL; 796 return NULL; 797 } 798 target->mgm_hi = 0xffff; 799 target->mgm_lo = 0xf0000000 | (reg->val << 2); 800 target->mgm_ocb_cur = NULL; 801 SBP_DEBUG(1) 802 printf("target: mgm_port: %x\n", target->mgm_lo); 803 END_DEBUG 804 STAILQ_INIT(&target->xferlist); 805 target->n_xfer = 0; 806 STAILQ_INIT(&target->mgm_ocb_queue); 807 fw_callout_init(&target->mgm_ocb_timeout); 808 fw_callout_init(&target->scan_callout); 809 810 target->luns = NULL; 811 target->num_lun = 0; 812 return target; 813 } 814 815 static void 816 sbp_probe_lun(struct sbp_dev *sdev) 817 { 818 struct fw_device *fwdev; 819 struct crom_context c, *cc = &c; 820 struct csrreg *reg; 821 822 bzero(sdev->vendor, sizeof(sdev->vendor)); 823 bzero(sdev->product, sizeof(sdev->product)); 824 825 fwdev = sdev->target->fwdev; 826 crom_init_context(cc, fwdev->csrrom); 827 /* get vendor string */ 828 crom_search_key(cc, CSRKEY_VENDOR); 829 crom_next(cc); 830 crom_parse_text(cc, sdev->vendor, sizeof(sdev->vendor)); 831 /* skip to the unit directory for SBP-2 */ 832 while ((reg = crom_search_key(cc, CSRKEY_VER)) != NULL) { 833 if (reg->val == CSRVAL_T10SBP2) 834 break; 835 crom_next(cc); 836 } 837 /* get firmware revision */ 838 reg = crom_search_key(cc, CSRKEY_FIRM_VER); 839 if (reg != NULL) 840 snprintf(sdev->revision, sizeof(sdev->revision), 841 "%06x", reg->val); 842 /* get product string */ 843 crom_search_key(cc, CSRKEY_MODEL); 844 crom_next(cc); 845 crom_parse_text(cc, sdev->product, sizeof(sdev->product)); 846 } 847 848 static void 849 sbp_login_callout(void *arg) 850 { 851 struct sbp_dev *sdev = (struct sbp_dev *)arg; 852 sbp_mgm_orb(sdev, ORB_FUN_LGI, NULL); 853 } 854 855 static void 856 sbp_login(struct sbp_dev *sdev) 857 { 858 struct timeval delta; 859 struct timeval t; 860 int ticks = 0; 861 862 microtime(&delta); 863 fw_timevalsub(&delta, &sdev->target->sbp->last_busreset); 864 t.tv_sec = login_delay / 1000; 865 t.tv_usec = (login_delay % 1000) * 1000; 866 fw_timevalsub(&t, &delta); 867 if (t.tv_sec >= 0 && t.tv_usec > 0) 868 ticks = (t.tv_sec * 1000 + t.tv_usec / 1000) * hz / 1000; 869 SBP_DEBUG(0) 870 printf("%s: sec = %jd usec = %ld ticks = %d\n", __func__, 871 (intmax_t)t.tv_sec, t.tv_usec, ticks); 872 END_DEBUG 873 fw_callout_reset(&sdev->login_callout, ticks, 874 sbp_login_callout, (void *)(sdev)); 875 } 876 877 static void 878 sbp_probe_target(void *arg) 879 { 880 struct sbp_target *target = (struct sbp_target *)arg; 881 struct sbp_softc *sbp; 882 struct sbp_dev *sdev; 883 struct firewire_comm *fc; 884 int i; 885 886 SBP_DEBUG(1) 887 printf("sbp_probe_target %d\n", target->target_id); 888 END_DEBUG 889 890 sbp = target->sbp; 891 fc = target->sbp->fd.fc; 892 sbp_alloc_lun(target); 893 894 /* XXX untimeout mgm_ocb and dequeue */ 895 for (i=0; i < target->num_lun; i++) { 896 sdev = target->luns[i]; 897 if (sdev == NULL) 898 continue; 899 if (sdev->status != SBP_DEV_DEAD) { 900 if (SBP_DEVICE(sdev) != NULL) { 901 SBP_LOCK(sbp); 902 SBP_DEVICE_FREEZE(sdev, 1); 903 sdev->freeze ++; 904 SBP_UNLOCK(sbp); 905 } 906 sbp_probe_lun(sdev); 907 SBP_DEBUG(0) 908 sbp_show_sdev_info(sdev, 909 (sdev->status == SBP_DEV_RESET)); 910 END_DEBUG 911 912 sbp_abort_all_ocbs(sdev, XS_SCSI_BUS_RESET); 913 switch (sdev->status) { 914 case SBP_DEV_RESET: 915 /* new or revived target */ 916 if (auto_login) 917 sbp_login(sdev); 918 break; 919 case SBP_DEV_TOATTACH: 920 case SBP_DEV_PROBE: 921 case SBP_DEV_ATTACHED: 922 case SBP_DEV_RETRY: 923 default: 924 sbp_mgm_orb(sdev, ORB_FUN_RCN, NULL); 925 break; 926 } 927 } else { 928 switch (sdev->status) { 929 case SBP_DEV_ATTACHED: 930 SBP_DEBUG(0) 931 /* the device has gone */ 932 sbp_show_sdev_info(sdev, 2); 933 printf("lost target\n"); 934 END_DEBUG 935 if (SBP_DEVICE(sdev) != NULL) { 936 SBP_LOCK(sbp); 937 SBP_DEVICE_FREEZE(sdev, 1); 938 sdev->freeze ++; 939 SBP_UNLOCK(sbp); 940 } 941 sdev->status = SBP_DEV_RETRY; 942 sbp_abort_all_ocbs(sdev, XS_SCSI_BUS_RESET); 943 break; 944 case SBP_DEV_PROBE: 945 case SBP_DEV_TOATTACH: 946 sdev->status = SBP_DEV_RESET; 947 break; 948 case SBP_DEV_RETRY: 949 case SBP_DEV_RESET: 950 case SBP_DEV_DEAD: 951 break; 952 } 953 } 954 } 955 } 956 957 #define SBP_FWDEV_ALIVE(fwdev) (((fwdev)->status == FWDEVATTACHED) \ 958 && crom_has_specver((fwdev)->csrrom, CSRVAL_ANSIT10, CSRVAL_T10SBP2)) 959 960 static void 961 sbp_post_busreset(void *arg) 962 { 963 struct sbp_softc *sbp = (struct sbp_softc *)arg; 964 struct sbp_target *target = &sbp->target; 965 struct fw_device *fwdev = target->fwdev; 966 int alive; 967 968 alive = SBP_FWDEV_ALIVE(fwdev); 969 SBP_DEBUG(0) 970 printf("sbp_post_busreset\n"); 971 if (!alive) 972 printf("not alive\n"); 973 END_DEBUG 974 microtime(&sbp->last_busreset); 975 976 if (!alive) 977 return; 978 979 SBP_LOCK(sbp); 980 SBP_BUS_FREEZE(sbp); 981 SBP_UNLOCK(sbp); 982 } 983 984 static void 985 sbp_post_explore(void *arg) 986 { 987 struct sbp_softc *sbp = (struct sbp_softc *)arg; 988 struct sbp_target *target = &sbp->target; 989 struct fw_device *fwdev = target->fwdev; 990 int alive; 991 992 alive = SBP_FWDEV_ALIVE(fwdev); 993 SBP_DEBUG(0) 994 printf("sbp_post_explore (sbp_cold=%d)\n", sbp_cold); 995 if (!alive) 996 printf("not alive\n"); 997 END_DEBUG 998 if (!alive) 999 return; 1000 1001 if (sbp_cold > 0) 1002 sbp_cold --; 1003 1004 #if 0 1005 /* 1006 * XXX don't let CAM the bus rest. 1007 * CAM tries to do something with freezed (DEV_RETRY) devices. 1008 */ 1009 xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL); 1010 #endif 1011 1012 SBP_DEBUG(0) 1013 printf("sbp_post_explore: EUI:%08x%08x ", fwdev->eui.hi, fwdev->eui.lo); 1014 END_DEBUG 1015 sbp_probe_target((void *)target); 1016 if (target->num_lun == 0) 1017 sbp_free_target(target); 1018 1019 SBP_LOCK(sbp); 1020 SBP_BUS_THAW(sbp); 1021 SBP_UNLOCK(sbp); 1022 } 1023 1024 #if NEED_RESPONSE 1025 static void 1026 sbp_loginres_callback(struct fw_xfer *xfer){ 1027 int s; 1028 struct sbp_dev *sdev; 1029 sdev = (struct sbp_dev *)xfer->sc; 1030 SBP_DEBUG(1) 1031 sbp_show_sdev_info(sdev, 2); 1032 printf("sbp_loginres_callback\n"); 1033 END_DEBUG 1034 /* recycle */ 1035 s = splfw(); 1036 STAILQ_INSERT_TAIL(&sdev->target->sbp->fwb.xferlist, xfer, link); 1037 splx(s); 1038 return; 1039 } 1040 #endif 1041 1042 static inline void 1043 sbp_xfer_free(struct fw_xfer *xfer) 1044 { 1045 struct sbp_dev *sdev; 1046 int s; 1047 1048 sdev = (struct sbp_dev *)xfer->sc; 1049 fw_xfer_unload(xfer); 1050 s = splfw(); 1051 SBP_LOCK(sdev->target->sbp); 1052 STAILQ_INSERT_TAIL(&sdev->target->xferlist, xfer, link); 1053 SBP_UNLOCK(sdev->target->sbp); 1054 splx(s); 1055 } 1056 1057 static void 1058 sbp_reset_start_callback(struct fw_xfer *xfer) 1059 { 1060 struct sbp_dev *tsdev, *sdev = (struct sbp_dev *)xfer->sc; 1061 struct sbp_target *target = sdev->target; 1062 int i; 1063 1064 if (xfer->resp != 0) { 1065 sbp_show_sdev_info(sdev, 2); 1066 printf("sbp_reset_start failed: resp=%d\n", xfer->resp); 1067 } 1068 1069 for (i = 0; i < target->num_lun; i++) { 1070 tsdev = target->luns[i]; 1071 if (tsdev != NULL && tsdev->status == SBP_DEV_LOGIN) 1072 sbp_login(tsdev); 1073 } 1074 } 1075 1076 static void 1077 sbp_reset_start(struct sbp_dev *sdev) 1078 { 1079 struct fw_xfer *xfer; 1080 struct fw_pkt *fp; 1081 1082 SBP_DEBUG(0) 1083 sbp_show_sdev_info(sdev, 2); 1084 printf("sbp_reset_start\n"); 1085 END_DEBUG 1086 1087 xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0); 1088 xfer->hand = sbp_reset_start_callback; 1089 fp = &xfer->send.hdr; 1090 fp->mode.wreqq.dest_hi = 0xffff; 1091 fp->mode.wreqq.dest_lo = 0xf0000000 | RESET_START; 1092 fp->mode.wreqq.data = htonl(0xf); 1093 fw_asyreq(xfer->fc, -1, xfer); 1094 } 1095 1096 static void 1097 sbp_mgm_callback(struct fw_xfer *xfer) 1098 { 1099 struct sbp_dev *sdev; 1100 int resp; 1101 1102 sdev = (struct sbp_dev *)xfer->sc; 1103 1104 SBP_DEBUG(1) 1105 sbp_show_sdev_info(sdev, 2); 1106 printf("sbp_mgm_callback\n"); 1107 END_DEBUG 1108 resp = xfer->resp; 1109 sbp_xfer_free(xfer); 1110 #if 0 1111 if (resp != 0) { 1112 sbp_show_sdev_info(sdev, 2); 1113 printf("management ORB failed(%d) ... RESET_START\n", resp); 1114 sbp_reset_start(sdev); 1115 } 1116 #endif 1117 return; 1118 } 1119 1120 #if defined(__FreeBSD__) 1121 static struct sbp_dev * 1122 sbp_next_dev(struct sbp_target *target, int lun) 1123 { 1124 struct sbp_dev **sdevp; 1125 int i; 1126 1127 for (i = lun, sdevp = &target->luns[lun]; i < target->num_lun; 1128 i++, sdevp++) 1129 if (*sdevp != NULL && (*sdevp)->status == SBP_DEV_PROBE) 1130 return(*sdevp); 1131 return(NULL); 1132 } 1133 1134 #define SCAN_PRI 1 1135 static void 1136 sbp_cam_scan_lun(struct cam_periph *periph, sbp_scsi_xfer *sxfer) 1137 { 1138 struct sbp_target *target; 1139 struct sbp_dev *sdev; 1140 1141 sdev = (struct sbp_dev *) sxfer->ccb_h.ccb_sdev_ptr; 1142 target = sdev->target; 1143 SBP_DEBUG(0) 1144 sbp_show_sdev_info(sdev, 2); 1145 printf("sbp_cam_scan_lun\n"); 1146 END_DEBUG 1147 if ((SCSI_XFER_ERROR(sxfer) & CAM_STATUS_MASK) == XS_REQ_CMP) { 1148 sdev->status = SBP_DEV_ATTACHED; 1149 } else { 1150 sbp_show_sdev_info(sdev, 2); 1151 printf("scan failed\n"); 1152 } 1153 sdev = sbp_next_dev(target, sdev->lun_id + 1); 1154 if (sdev == NULL) { 1155 free(sxfer, M_SBP); 1156 return; 1157 } 1158 /* reuse sxfer */ 1159 xpt_setup_ccb(&sxfer->ccb_h, sdev->path, SCAN_PRI); 1160 sxfer->ccb_h.ccb_sdev_ptr = sdev; 1161 xpt_action(sxfer); 1162 xpt_release_devq(sdev->path, sdev->freeze, TRUE); 1163 sdev->freeze = 1; 1164 } 1165 1166 static void 1167 sbp_cam_scan_target(void *arg) 1168 { 1169 struct sbp_target *target = (struct sbp_target *)arg; 1170 struct sbp_dev *sdev; 1171 sbp_scsi_xfer *sxfer; 1172 1173 sdev = sbp_next_dev(target, 0); 1174 if (sdev == NULL) { 1175 printf("sbp_cam_scan_target: nothing to do for target%d\n", 1176 target->target_id); 1177 return; 1178 } 1179 SBP_DEBUG(0) 1180 sbp_show_sdev_info(sdev, 2); 1181 printf("sbp_cam_scan_target\n"); 1182 END_DEBUG 1183 sxfer = malloc(sizeof(sbp_scsi_xfer), M_SBP, M_NOWAIT | M_ZERO); 1184 if (sxfer == NULL) { 1185 printf("sbp_cam_scan_target: malloc failed\n"); 1186 return; 1187 } 1188 xpt_setup_ccb(&sxfer->ccb_h, sdev->path, SCAN_PRI); 1189 sxfer->ccb_h.func_code = XPT_SCAN_LUN; 1190 sxfer->ccb_h.cbfcnp = sbp_cam_scan_lun; 1191 sxfer->ccb_h.flags |= CAM_DEV_QFREEZE; 1192 sxfer->crcn.flags = CAM_FLAG_NONE; 1193 sxfer->ccb_h.ccb_sdev_ptr = sdev; 1194 1195 /* The scan is in progress now. */ 1196 SBP_LOCK(target->sbp); 1197 xpt_action(sxfer); 1198 xpt_release_devq(sdev->path, sdev->freeze, TRUE); 1199 sdev->freeze = 1; 1200 SBP_UNLOCK(target->sbp); 1201 } 1202 1203 static inline void 1204 sbp_scan_dev(struct sbp_dev *sdev) 1205 { 1206 sdev->status = SBP_DEV_PROBE; 1207 fw_callout_reset(&sdev->target->scan_callout, scan_delay * hz / 1000, 1208 sbp_cam_scan_target, (void *)sdev->target); 1209 } 1210 #else 1211 static void 1212 sbp_scsipi_scan_target(void *arg) 1213 { 1214 struct sbp_target *target = (struct sbp_target *)arg; 1215 struct sbp_softc *sbp = target->sbp; 1216 struct sbp_dev *sdev; 1217 struct scsipi_channel *chan = &sbp->sc_channel; 1218 struct scsibus_softc *sc_bus = (struct scsibus_softc *)sbp->sc_bus; 1219 int lun, yet; 1220 1221 do { 1222 tsleep(target, PWAIT|PCATCH, "-", 0); 1223 yet = 0; 1224 1225 for (lun = 0; lun < target->num_lun; lun ++) { 1226 sdev = target->luns[lun]; 1227 if (sdev == NULL) 1228 continue; 1229 if (sdev->status != SBP_DEV_PROBE) { 1230 yet ++; 1231 continue; 1232 } 1233 1234 if (sdev->periph == NULL) { 1235 if (chan->chan_nluns < target->num_lun) 1236 chan->chan_nluns = target->num_lun; 1237 1238 scsi_probe_bus(sc_bus, 1239 target->target_id, sdev->lun_id); 1240 sdev->periph = scsipi_lookup_periph( 1241 chan, target->target_id, lun); 1242 } 1243 sdev->status = SBP_DEV_ATTACHED; 1244 } 1245 } while (yet > 0); 1246 1247 sbp->lwp = NULL; 1248 kthread_exit(0); 1249 } 1250 1251 static inline void 1252 sbp_scan_dev(struct sbp_dev *sdev) 1253 { 1254 sdev->status = SBP_DEV_PROBE; 1255 wakeup(sdev->target); 1256 } 1257 #endif 1258 1259 1260 static void 1261 sbp_do_attach(struct fw_xfer *xfer) 1262 { 1263 struct sbp_dev *sdev; 1264 struct sbp_target *target; 1265 struct sbp_softc *sbp; 1266 1267 sdev = (struct sbp_dev *)xfer->sc; 1268 target = sdev->target; 1269 sbp = target->sbp; 1270 1271 SBP_DEBUG(0) 1272 sbp_show_sdev_info(sdev, 2); 1273 printf("sbp_do_attach\n"); 1274 END_DEBUG 1275 sbp_xfer_free(xfer); 1276 1277 #if defined(__FreeBSD__) 1278 if (sdev->path == NULL) 1279 xpt_create_path(&sdev->path, xpt_periph, 1280 cam_sim_path(target->sbp->sim), 1281 target->target_id, sdev->lun_id); 1282 1283 /* 1284 * Let CAM scan the bus if we are in the boot process. 1285 * XXX xpt_scan_bus cannot detect LUN larger than 0 1286 * if LUN 0 doesn't exists. 1287 */ 1288 if (sbp_cold > 0) { 1289 sdev->status = SBP_DEV_ATTACHED; 1290 return; 1291 } 1292 #endif 1293 1294 sbp_scan_dev(sdev); 1295 return; 1296 } 1297 1298 static void 1299 sbp_agent_reset_callback(struct fw_xfer *xfer) 1300 { 1301 struct sbp_dev *sdev; 1302 1303 sdev = (struct sbp_dev *)xfer->sc; 1304 SBP_DEBUG(1) 1305 sbp_show_sdev_info(sdev, 2); 1306 printf("%s\n", __func__); 1307 END_DEBUG 1308 if (xfer->resp != 0) { 1309 sbp_show_sdev_info(sdev, 2); 1310 printf("%s: resp=%d\n", __func__, xfer->resp); 1311 } 1312 1313 sbp_xfer_free(xfer); 1314 if (SBP_DEVICE(sdev)) { 1315 SBP_LOCK(sdev->target->sbp); 1316 SBP_DEVICE_THAW(sdev, sdev->freeze); 1317 sdev->freeze = 0; 1318 SBP_UNLOCK(sdev->target->sbp); 1319 } 1320 } 1321 1322 static void 1323 sbp_agent_reset(struct sbp_dev *sdev) 1324 { 1325 struct fw_xfer *xfer; 1326 struct fw_pkt *fp; 1327 1328 SBP_DEBUG(0) 1329 sbp_show_sdev_info(sdev, 2); 1330 printf("sbp_agent_reset\n"); 1331 END_DEBUG 1332 xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x04); 1333 if (xfer == NULL) 1334 return; 1335 if (sdev->status == SBP_DEV_ATTACHED || sdev->status == SBP_DEV_PROBE) 1336 xfer->hand = sbp_agent_reset_callback; 1337 else 1338 xfer->hand = sbp_do_attach; 1339 fp = &xfer->send.hdr; 1340 fp->mode.wreqq.data = htonl(0xf); 1341 fw_asyreq(xfer->fc, -1, xfer); 1342 sbp_abort_all_ocbs(sdev, XS_BDR_SENT); 1343 } 1344 1345 static void 1346 sbp_busy_timeout_callback(struct fw_xfer *xfer) 1347 { 1348 struct sbp_dev *sdev; 1349 1350 sdev = (struct sbp_dev *)xfer->sc; 1351 SBP_DEBUG(1) 1352 sbp_show_sdev_info(sdev, 2); 1353 printf("sbp_busy_timeout_callback\n"); 1354 END_DEBUG 1355 sbp_xfer_free(xfer); 1356 sbp_agent_reset(sdev); 1357 } 1358 1359 static void 1360 sbp_busy_timeout(struct sbp_dev *sdev) 1361 { 1362 struct fw_pkt *fp; 1363 struct fw_xfer *xfer; 1364 SBP_DEBUG(0) 1365 sbp_show_sdev_info(sdev, 2); 1366 printf("sbp_busy_timeout\n"); 1367 END_DEBUG 1368 xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0); 1369 1370 xfer->hand = sbp_busy_timeout_callback; 1371 fp = &xfer->send.hdr; 1372 fp->mode.wreqq.dest_hi = 0xffff; 1373 fp->mode.wreqq.dest_lo = 0xf0000000 | BUSY_TIMEOUT; 1374 fp->mode.wreqq.data = htonl((1 << (13+12)) | 0xf); 1375 fw_asyreq(xfer->fc, -1, xfer); 1376 } 1377 1378 static void 1379 sbp_orb_pointer_callback(struct fw_xfer *xfer) 1380 { 1381 struct sbp_dev *sdev; 1382 sdev = (struct sbp_dev *)xfer->sc; 1383 1384 SBP_DEBUG(1) 1385 sbp_show_sdev_info(sdev, 2); 1386 printf("%s\n", __func__); 1387 END_DEBUG 1388 if (xfer->resp != 0) { 1389 /* XXX */ 1390 printf("%s: xfer->resp = %d\n", __func__, xfer->resp); 1391 } 1392 sbp_xfer_free(xfer); 1393 sdev->flags &= ~ORB_POINTER_ACTIVE; 1394 1395 if ((sdev->flags & ORB_POINTER_NEED) != 0) { 1396 struct sbp_ocb *ocb; 1397 1398 sdev->flags &= ~ORB_POINTER_NEED; 1399 ocb = STAILQ_FIRST(&sdev->ocbs); 1400 if (ocb != NULL) 1401 sbp_orb_pointer(sdev, ocb); 1402 } 1403 return; 1404 } 1405 1406 static void 1407 sbp_orb_pointer(struct sbp_dev *sdev, struct sbp_ocb *ocb) 1408 { 1409 struct fw_xfer *xfer; 1410 struct fw_pkt *fp; 1411 SBP_DEBUG(1) 1412 sbp_show_sdev_info(sdev, 2); 1413 printf("%s: 0x%08x\n", __func__, (uint32_t)ocb->bus_addr); 1414 END_DEBUG 1415 1416 if ((sdev->flags & ORB_POINTER_ACTIVE) != 0) { 1417 SBP_DEBUG(0) 1418 printf("%s: orb pointer active\n", __func__); 1419 END_DEBUG 1420 sdev->flags |= ORB_POINTER_NEED; 1421 return; 1422 } 1423 1424 sdev->flags |= ORB_POINTER_ACTIVE; 1425 xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0x08); 1426 if (xfer == NULL) 1427 return; 1428 xfer->hand = sbp_orb_pointer_callback; 1429 1430 fp = &xfer->send.hdr; 1431 fp->mode.wreqb.len = 8; 1432 fp->mode.wreqb.extcode = 0; 1433 xfer->send.payload[0] = 1434 htonl(((sdev->target->sbp->fd.fc->nodeid | FWLOCALBUS )<< 16)); 1435 xfer->send.payload[1] = htonl((uint32_t)ocb->bus_addr); 1436 1437 if(fw_asyreq(xfer->fc, -1, xfer) != 0){ 1438 sbp_xfer_free(xfer); 1439 SCSI_XFER_ERROR(ocb->sxfer) = XS_REQ_INVALID; 1440 SCSI_TRANSFER_DONE(ocb->sxfer); 1441 } 1442 } 1443 1444 static void 1445 sbp_doorbell_callback(struct fw_xfer *xfer) 1446 { 1447 struct sbp_dev *sdev; 1448 sdev = (struct sbp_dev *)xfer->sc; 1449 1450 SBP_DEBUG(1) 1451 sbp_show_sdev_info(sdev, 2); 1452 printf("sbp_doorbell_callback\n"); 1453 END_DEBUG 1454 if (xfer->resp != 0) { 1455 /* XXX */ 1456 printf("%s: xfer->resp = %d\n", __func__, xfer->resp); 1457 } 1458 sbp_xfer_free(xfer); 1459 sdev->flags &= ~ORB_DOORBELL_ACTIVE; 1460 if ((sdev->flags & ORB_DOORBELL_NEED) != 0) { 1461 sdev->flags &= ~ORB_DOORBELL_NEED; 1462 sbp_doorbell(sdev); 1463 } 1464 return; 1465 } 1466 1467 static void 1468 sbp_doorbell(struct sbp_dev *sdev) 1469 { 1470 struct fw_xfer *xfer; 1471 struct fw_pkt *fp; 1472 SBP_DEBUG(1) 1473 sbp_show_sdev_info(sdev, 2); 1474 printf("sbp_doorbell\n"); 1475 END_DEBUG 1476 1477 if ((sdev->flags & ORB_DOORBELL_ACTIVE) != 0) { 1478 sdev->flags |= ORB_DOORBELL_NEED; 1479 return; 1480 } 1481 sdev->flags |= ORB_DOORBELL_ACTIVE; 1482 xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x10); 1483 if (xfer == NULL) 1484 return; 1485 xfer->hand = sbp_doorbell_callback; 1486 fp = &xfer->send.hdr; 1487 fp->mode.wreqq.data = htonl(0xf); 1488 fw_asyreq(xfer->fc, -1, xfer); 1489 } 1490 1491 static struct fw_xfer * 1492 sbp_write_cmd(struct sbp_dev *sdev, int tcode, int offset) 1493 { 1494 struct fw_xfer *xfer; 1495 struct fw_pkt *fp; 1496 struct sbp_target *target; 1497 int s, new = 0; 1498 1499 target = sdev->target; 1500 s = splfw(); 1501 xfer = STAILQ_FIRST(&target->xferlist); 1502 if (xfer == NULL) { 1503 if (target->n_xfer > 5 /* XXX */) { 1504 printf("sbp: no more xfer for this target\n"); 1505 splx(s); 1506 return(NULL); 1507 } 1508 xfer = fw_xfer_alloc_buf(M_SBP, 8, 0); 1509 if(xfer == NULL){ 1510 printf("sbp: fw_xfer_alloc_buf failed\n"); 1511 splx(s); 1512 return NULL; 1513 } 1514 target->n_xfer ++; 1515 if (debug) 1516 printf("sbp: alloc %d xfer\n", target->n_xfer); 1517 new = 1; 1518 } else { 1519 STAILQ_REMOVE_HEAD(&target->xferlist, link); 1520 } 1521 splx(s); 1522 1523 microtime(&xfer->tv); 1524 1525 if (new) { 1526 xfer->recv.pay_len = 0; 1527 xfer->send.spd = min(sdev->target->fwdev->speed, max_speed); 1528 xfer->fc = sdev->target->sbp->fd.fc; 1529 } 1530 1531 if (tcode == FWTCODE_WREQB) 1532 xfer->send.pay_len = 8; 1533 else 1534 xfer->send.pay_len = 0; 1535 1536 xfer->sc = (void *)sdev; 1537 fp = &xfer->send.hdr; 1538 fp->mode.wreqq.dest_hi = sdev->login->cmd_hi; 1539 fp->mode.wreqq.dest_lo = sdev->login->cmd_lo + offset; 1540 fp->mode.wreqq.tlrt = 0; 1541 fp->mode.wreqq.tcode = tcode; 1542 fp->mode.wreqq.pri = 0; 1543 fp->mode.wreqq.dst = FWLOCALBUS | sdev->target->fwdev->dst; 1544 1545 return xfer; 1546 } 1547 1548 static void 1549 sbp_mgm_orb(struct sbp_dev *sdev, int func, struct sbp_ocb *aocb) 1550 { 1551 struct fw_xfer *xfer; 1552 struct fw_pkt *fp; 1553 struct sbp_ocb *ocb; 1554 struct sbp_target *target; 1555 int s, nid, dv_unit; 1556 1557 target = sdev->target; 1558 nid = target->sbp->fd.fc->nodeid | FWLOCALBUS; 1559 dv_unit = fw_get_unit(target->sbp->fd.dev); 1560 1561 s = splfw(); 1562 SBP_LOCK(target->sbp); 1563 if (func == ORB_FUN_RUNQUEUE) { 1564 ocb = STAILQ_FIRST(&target->mgm_ocb_queue); 1565 if (target->mgm_ocb_cur != NULL || ocb == NULL) { 1566 SBP_UNLOCK(target->sbp); 1567 splx(s); 1568 return; 1569 } 1570 STAILQ_REMOVE_HEAD(&target->mgm_ocb_queue, ocb); 1571 SBP_UNLOCK(target->sbp); 1572 goto start; 1573 } 1574 if ((ocb = sbp_get_ocb(sdev)) == NULL) { 1575 SBP_UNLOCK(target->sbp); 1576 splx(s); 1577 /* XXX */ 1578 return; 1579 } 1580 SBP_UNLOCK(target->sbp); 1581 ocb->flags = OCB_ACT_MGM; 1582 ocb->sdev = sdev; 1583 1584 bzero((void *)ocb->orb, sizeof(ocb->orb)); 1585 ocb->orb[6] = htonl((nid << 16) | SBP_BIND_HI); 1586 ocb->orb[7] = htonl(SBP_DEV2ADDR(dv_unit, sdev->lun_id)); 1587 1588 SBP_DEBUG(0) 1589 sbp_show_sdev_info(sdev, 2); 1590 printf("%s\n", orb_fun_name[(func>>16)&0xf]); 1591 END_DEBUG 1592 switch (func) { 1593 case ORB_FUN_LGI: 1594 ocb->orb[0] = ocb->orb[1] = 0; /* password */ 1595 ocb->orb[2] = htonl(nid << 16); 1596 ocb->orb[3] = htonl(sdev->dma.bus_addr); 1597 ocb->orb[4] = htonl(ORB_NOTIFY | sdev->lun_id); 1598 if (ex_login) 1599 ocb->orb[4] |= htonl(ORB_EXV); 1600 ocb->orb[5] = htonl(SBP_LOGIN_SIZE); 1601 break; 1602 case ORB_FUN_ATA: 1603 ocb->orb[0] = htonl((0 << 16) | 0); 1604 ocb->orb[1] = htonl(aocb->bus_addr & 0xffffffff); 1605 /* fall through */ 1606 case ORB_FUN_RCN: 1607 case ORB_FUN_LGO: 1608 case ORB_FUN_LUR: 1609 case ORB_FUN_RST: 1610 case ORB_FUN_ATS: 1611 ocb->orb[4] = htonl(ORB_NOTIFY | func | sdev->login->id); 1612 break; 1613 } 1614 1615 if (target->mgm_ocb_cur != NULL) { 1616 /* there is a standing ORB */ 1617 SBP_LOCK(target->sbp); 1618 STAILQ_INSERT_TAIL(&sdev->target->mgm_ocb_queue, ocb, ocb); 1619 SBP_UNLOCK(target->sbp); 1620 splx(s); 1621 return; 1622 } 1623 start: 1624 target->mgm_ocb_cur = ocb; 1625 splx(s); 1626 1627 fw_callout_reset(&target->mgm_ocb_timeout, 5*hz, 1628 sbp_mgm_timeout, (void *)ocb); 1629 xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0); 1630 if(xfer == NULL){ 1631 return; 1632 } 1633 xfer->hand = sbp_mgm_callback; 1634 1635 fp = &xfer->send.hdr; 1636 fp->mode.wreqb.dest_hi = sdev->target->mgm_hi; 1637 fp->mode.wreqb.dest_lo = sdev->target->mgm_lo; 1638 fp->mode.wreqb.len = 8; 1639 fp->mode.wreqb.extcode = 0; 1640 xfer->send.payload[0] = htonl(nid << 16); 1641 xfer->send.payload[1] = htonl(ocb->bus_addr & 0xffffffff); 1642 SBP_DEBUG(0) 1643 sbp_show_sdev_info(sdev, 2); 1644 printf("mgm orb: %08x\n", (uint32_t)ocb->bus_addr); 1645 END_DEBUG 1646 1647 /* cache writeback & invalidate(required ORB_FUN_LGI func) */ 1648 /* when abort_ocb, should sync POST ope ? */ 1649 fwdma_sync(&sdev->dma, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 1650 fw_asyreq(xfer->fc, -1, xfer); 1651 } 1652 1653 static void 1654 sbp_print_scsi_cmd(struct sbp_ocb *ocb) 1655 { 1656 #if defined(__FreeBSD__) 1657 struct ccb_scsiio *csio; 1658 1659 csio = &ocb->sxfer->csio; 1660 #endif 1661 printf("%s:%d:%d XPT_SCSI_IO: " 1662 "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x" 1663 ", flags: 0x%02x, " 1664 "%db cmd/%db data/%db sense\n", 1665 fw_get_nameunit(ocb->sdev->target->sbp->fd.dev), 1666 SCSI_XFER_TARGET(ocb->sxfer), SCSI_XFER_LUN(ocb->sxfer), 1667 SCSI_XFER_10BCMD_DUMP(ocb->sxfer), 1668 SCSI_XFER_DIR(ocb->sxfer), 1669 SCSI_XFER_CMDLEN(ocb->sxfer), SCSI_XFER_DATALEN(ocb->sxfer), 1670 SCSI_XFER_SENSELEN(ocb->sxfer)); 1671 } 1672 1673 static void 1674 sbp_scsi_status(struct sbp_status *sbp_status, struct sbp_ocb *ocb) 1675 { 1676 struct sbp_cmd_status *sbp_cmd_status; 1677 scsi3_sense_data_t sense = 1678 (scsi3_sense_data_t)SCSI_SENSE_DATA(ocb->sxfer); 1679 1680 sbp_cmd_status = (struct sbp_cmd_status *)sbp_status->data; 1681 1682 SBP_DEBUG(0) 1683 sbp_print_scsi_cmd(ocb); 1684 /* XXX need decode status */ 1685 sbp_show_sdev_info(ocb->sdev, 2); 1686 printf("SCSI status %x sfmt %x valid %x key %x code %x qlfr %x len %d\n", 1687 sbp_cmd_status->status, 1688 sbp_cmd_status->sfmt, 1689 sbp_cmd_status->valid, 1690 sbp_cmd_status->s_key, 1691 sbp_cmd_status->s_code, 1692 sbp_cmd_status->s_qlfr, 1693 sbp_status->len 1694 ); 1695 END_DEBUG 1696 1697 switch (sbp_cmd_status->status) { 1698 case SCSI_STATUS_CHECK_COND: 1699 case SCSI_STATUS_BUSY: 1700 case SCSI_STATUS_CMD_TERMINATED: 1701 if(sbp_cmd_status->sfmt == SBP_SFMT_CURR){ 1702 sense->response_code = SSD_CURRENT_ERROR; 1703 }else{ 1704 sense->response_code = SSD_DEFERRED_ERROR; 1705 } 1706 if(sbp_cmd_status->valid) 1707 sense->response_code |= SSD_RESPONSE_CODE_VALID; 1708 sense->flags = sbp_cmd_status->s_key; 1709 if(sbp_cmd_status->mark) 1710 sense->flags |= SSD_FILEMARK; 1711 if(sbp_cmd_status->eom) 1712 sense->flags |= SSD_EOM; 1713 if(sbp_cmd_status->ill_len) 1714 sense->flags |= SSD_ILI; 1715 1716 bcopy(&sbp_cmd_status->info, &sense->information[0], 4); 1717 1718 if (sbp_status->len <= 1) 1719 /* XXX not scsi status. shouldn't be happened */ 1720 sense->asl = 0; 1721 else if (sbp_status->len <= 4) 1722 /* add_sense_code(_qual), info, cmd_spec_info */ 1723 sense->asl = 6; 1724 else 1725 /* fru, sense_key_spec */ 1726 sense->asl = 10; 1727 1728 bcopy(&sbp_cmd_status->cdb, &sense->csi[0], 4); 1729 1730 sense->asc = sbp_cmd_status->s_code; 1731 sense->ascq = sbp_cmd_status->s_qlfr; 1732 sense->fruc = sbp_cmd_status->fru; 1733 1734 bcopy(&sbp_cmd_status->s_keydep[0], &sense->sks[0], 3); 1735 SCSI_XFER_ERROR(ocb->sxfer) = XS_SENSE; 1736 SCSI_XFER_STATUS(ocb->sxfer) = sbp_cmd_status->status; 1737 /* 1738 { 1739 uint8_t j, *tmp; 1740 tmp = sense; 1741 for( j = 0 ; j < 32 ; j+=8){ 1742 printf("sense %02x%02x %02x%02x %02x%02x %02x%02x\n", 1743 tmp[j], tmp[j+1], tmp[j+2], tmp[j+3], 1744 tmp[j+4], tmp[j+5], tmp[j+6], tmp[j+7]); 1745 } 1746 1747 } 1748 */ 1749 break; 1750 default: 1751 sbp_show_sdev_info(ocb->sdev, 2); 1752 printf("sbp_scsi_status: unknown scsi status 0x%x\n", 1753 sbp_cmd_status->status); 1754 } 1755 } 1756 1757 static void 1758 sbp_fix_inq_data(struct sbp_ocb *ocb) 1759 { 1760 sbp_scsi_xfer *sxfer = ocb->sxfer; 1761 struct sbp_dev *sdev; 1762 scsi3_inquiry_data_t inq = 1763 (scsi3_inquiry_data_t)SCSI_INQUIRY_DATA(sxfer); 1764 sdev = ocb->sdev; 1765 1766 if (SCSI_XFER_EVPD(sxfer)) 1767 return; 1768 SBP_DEBUG(1) 1769 sbp_show_sdev_info(sdev, 2); 1770 printf("sbp_fix_inq_data\n"); 1771 END_DEBUG 1772 switch (inq->device & SID_TYPE) { 1773 case T_DIRECT: 1774 #if 0 1775 /* 1776 * XXX Convert Direct Access device to RBC. 1777 * I've never seen FireWire DA devices which support READ_6. 1778 */ 1779 if ((inq->device & SID_TYPE) == T_DIRECT) 1780 inq->device |= T_RBC; /* T_DIRECT == 0 */ 1781 #endif 1782 /* fall through */ 1783 case T_RBC: 1784 /* 1785 * Override vendor/product/revision information. 1786 * Some devices sometimes return strange strings. 1787 */ 1788 #if 1 1789 bcopy(sdev->vendor, inq->vendor, sizeof(inq->vendor)); 1790 bcopy(sdev->product, inq->product, sizeof(inq->product)); 1791 bcopy(sdev->revision+2, inq->revision, sizeof(inq->revision)); 1792 #endif 1793 break; 1794 } 1795 /* 1796 * Force to enable/disable tagged queuing. 1797 * XXX CAM also checks SCP_QUEUE_DQUE flag in the control mode page. 1798 */ 1799 if (sbp_tags > 0) 1800 inq->flags[1] |= SID_CmdQue; 1801 else if (sbp_tags < 0) 1802 inq->flags[1] &= ~SID_CmdQue; 1803 1804 } 1805 1806 static void 1807 sbp_recv1(struct fw_xfer *xfer) 1808 { 1809 struct fw_pkt *rfp; 1810 #if NEED_RESPONSE 1811 struct fw_pkt *sfp; 1812 #endif 1813 struct sbp_softc *sbp; 1814 struct sbp_dev *sdev; 1815 struct sbp_ocb *ocb; 1816 struct sbp_login_res *login_res = NULL; 1817 struct sbp_status *sbp_status; 1818 struct sbp_target *target; 1819 int orb_fun, status_valid0, status_valid, l, reset_agent = 0; 1820 uint32_t addr; 1821 /* 1822 uint32_t *ld; 1823 ld = xfer->recv.buf; 1824 printf("sbp %x %d %d %08x %08x %08x %08x\n", 1825 xfer->resp, xfer->recv.len, xfer->recv.off, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3])); 1826 printf("sbp %08x %08x %08x %08x\n", ntohl(ld[4]), ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7])); 1827 printf("sbp %08x %08x %08x %08x\n", ntohl(ld[8]), ntohl(ld[9]), ntohl(ld[10]), ntohl(ld[11])); 1828 */ 1829 sbp = (struct sbp_softc *)xfer->sc; 1830 if (xfer->resp != 0){ 1831 printf("sbp_recv: xfer->resp = %d\n", xfer->resp); 1832 goto done0; 1833 } 1834 if (xfer->recv.payload == NULL){ 1835 printf("sbp_recv: xfer->recv.payload == NULL\n"); 1836 goto done0; 1837 } 1838 rfp = &xfer->recv.hdr; 1839 if(rfp->mode.wreqb.tcode != FWTCODE_WREQB){ 1840 printf("sbp_recv: tcode = %d\n", rfp->mode.wreqb.tcode); 1841 goto done0; 1842 } 1843 sbp_status = (struct sbp_status *)xfer->recv.payload; 1844 addr = rfp->mode.wreqb.dest_lo; 1845 SBP_DEBUG(2) 1846 printf("received address 0x%x\n", addr); 1847 END_DEBUG 1848 target = &sbp->target; 1849 l = SBP_ADDR2LUN(addr); 1850 if (l >= target->num_lun || target->luns[l] == NULL) { 1851 fw_printf(sbp->fd.dev, 1852 "sbp_recv1: invalid lun %d (target=%d)\n", 1853 l, target->target_id); 1854 goto done0; 1855 } 1856 sdev = target->luns[l]; 1857 1858 fwdma_sync(&sdev->dma, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 1859 1860 ocb = NULL; 1861 switch (sbp_status->src) { 1862 case SRC_NEXT_EXISTS: 1863 case SRC_NO_NEXT: 1864 /* check mgm_ocb_cur first */ 1865 ocb = target->mgm_ocb_cur; 1866 if (ocb != NULL) { 1867 if (OCB_MATCH(ocb, sbp_status)) { 1868 fw_callout_stop(&target->mgm_ocb_timeout); 1869 target->mgm_ocb_cur = NULL; 1870 break; 1871 } 1872 } 1873 ocb = sbp_dequeue_ocb(sdev, sbp_status); 1874 if (ocb == NULL) { 1875 sbp_show_sdev_info(sdev, 2); 1876 #if defined(__DragonFly__) || \ 1877 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 1878 printf("No ocb(%lx) on the queue\n", 1879 #else 1880 printf("No ocb(%x) on the queue\n", 1881 #endif 1882 ntohl(sbp_status->orb_lo)); 1883 } 1884 break; 1885 case SRC_UNSOL: 1886 /* unsolicit */ 1887 sbp_show_sdev_info(sdev, 2); 1888 printf("unsolicit status received\n"); 1889 break; 1890 default: 1891 sbp_show_sdev_info(sdev, 2); 1892 printf("unknown sbp_status->src\n"); 1893 } 1894 1895 status_valid0 = (sbp_status->src < 2 1896 && sbp_status->resp == SBP_REQ_CMP 1897 && sbp_status->dead == 0); 1898 status_valid = (status_valid0 && sbp_status->status == 0); 1899 1900 if (!status_valid0 || debug > 2){ 1901 int status; 1902 SBP_DEBUG(0) 1903 sbp_show_sdev_info(sdev, 2); 1904 printf("ORB status src:%x resp:%x dead:%x" 1905 #if defined(__DragonFly__) || \ 1906 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 1907 " len:%x stat:%x orb:%x%08lx\n", 1908 #else 1909 " len:%x stat:%x orb:%x%08x\n", 1910 #endif 1911 sbp_status->src, sbp_status->resp, sbp_status->dead, 1912 sbp_status->len, sbp_status->status, 1913 ntohs(sbp_status->orb_hi), ntohl(sbp_status->orb_lo)); 1914 END_DEBUG 1915 sbp_show_sdev_info(sdev, 2); 1916 status = sbp_status->status; 1917 switch(sbp_status->resp) { 1918 case SBP_REQ_CMP: 1919 if (status > MAX_ORB_STATUS0) 1920 printf("%s\n", orb_status0[MAX_ORB_STATUS0]); 1921 else 1922 printf("%s\n", orb_status0[status]); 1923 break; 1924 case SBP_TRANS_FAIL: 1925 printf("Obj: %s, Error: %s\n", 1926 orb_status1_object[(status>>6) & 3], 1927 orb_status1_serial_bus_error[status & 0xf]); 1928 break; 1929 case SBP_ILLE_REQ: 1930 printf("Illegal request\n"); 1931 break; 1932 case SBP_VEND_DEP: 1933 printf("Vendor dependent\n"); 1934 break; 1935 default: 1936 printf("unknown respose code %d\n", sbp_status->resp); 1937 } 1938 } 1939 1940 /* we have to reset the fetch agent if it's dead */ 1941 if (sbp_status->dead) { 1942 if (SBP_DEVICE(sdev) != NULL) { 1943 SBP_LOCK(sbp); 1944 SBP_DEVICE_FREEZE(sdev, 1); 1945 sdev->freeze ++; 1946 SBP_UNLOCK(sbp); 1947 } 1948 reset_agent = 1; 1949 } 1950 1951 if (ocb == NULL) 1952 goto done; 1953 1954 switch(ntohl(ocb->orb[4]) & ORB_FMT_MSK){ 1955 case ORB_FMT_NOP: 1956 break; 1957 case ORB_FMT_VED: 1958 break; 1959 case ORB_FMT_STD: 1960 switch(ocb->flags) { 1961 case OCB_ACT_MGM: 1962 orb_fun = ntohl(ocb->orb[4]) & ORB_FUN_MSK; 1963 reset_agent = 0; 1964 switch(orb_fun) { 1965 case ORB_FUN_LGI: 1966 login_res = sdev->login; 1967 login_res->len = ntohs(login_res->len); 1968 login_res->id = ntohs(login_res->id); 1969 login_res->cmd_hi = ntohs(login_res->cmd_hi); 1970 login_res->cmd_lo = ntohl(login_res->cmd_lo); 1971 if (status_valid) { 1972 SBP_DEBUG(0) 1973 sbp_show_sdev_info(sdev, 2); 1974 printf("login: len %d, ID %d, cmd %08x%08x, recon_hold %d\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo, ntohs(login_res->recon_hold)); 1975 END_DEBUG 1976 sbp_busy_timeout(sdev); 1977 } else { 1978 /* forgot logout? */ 1979 sbp_show_sdev_info(sdev, 2); 1980 printf("login failed\n"); 1981 sdev->status = SBP_DEV_RESET; 1982 } 1983 break; 1984 case ORB_FUN_RCN: 1985 login_res = sdev->login; 1986 if (status_valid) { 1987 SBP_DEBUG(0) 1988 sbp_show_sdev_info(sdev, 2); 1989 printf("reconnect: len %d, ID %d, cmd %08x%08x\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo); 1990 END_DEBUG 1991 #if 1 1992 #if defined(__FreeBSD__) 1993 if (sdev->status == SBP_DEV_ATTACHED) 1994 sbp_scan_dev(sdev); 1995 else 1996 #endif 1997 sbp_agent_reset(sdev); 1998 #else 1999 sdev->status = SBP_DEV_ATTACHED; 2000 sbp_mgm_orb(sdev, ORB_FUN_ATS, NULL); 2001 #endif 2002 } else { 2003 /* reconnection hold time exceed? */ 2004 SBP_DEBUG(0) 2005 sbp_show_sdev_info(sdev, 2); 2006 printf("reconnect failed\n"); 2007 END_DEBUG 2008 sbp_login(sdev); 2009 } 2010 break; 2011 case ORB_FUN_LGO: 2012 sdev->status = SBP_DEV_RESET; 2013 break; 2014 case ORB_FUN_RST: 2015 sbp_busy_timeout(sdev); 2016 break; 2017 case ORB_FUN_LUR: 2018 case ORB_FUN_ATA: 2019 case ORB_FUN_ATS: 2020 sbp_agent_reset(sdev); 2021 break; 2022 default: 2023 sbp_show_sdev_info(sdev, 2); 2024 printf("unknown function %d\n", orb_fun); 2025 break; 2026 } 2027 sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL); 2028 break; 2029 case OCB_ACT_CMD: 2030 sdev->timeout = 0; 2031 if(ocb->sxfer != NULL){ 2032 sbp_scsi_xfer *sxfer = ocb->sxfer; 2033 /* 2034 uint32_t *ld = SCSI_XFER_DATA(ocb->sxfer); 2035 if(ld != NULL && 2036 SCSI_XFER_DATALEN(ocb->sxfer) != 0) 2037 printf("ptr %08x %08x %08x %08x\n", ld[0], ld[1], ld[2], ld[3]); 2038 else 2039 printf("ptr NULL\n"); 2040 printf("len %d\n", sbp_status->len); 2041 */ 2042 if(sbp_status->len > 1){ 2043 sbp_scsi_status(sbp_status, ocb); 2044 }else{ 2045 if(sbp_status->resp != SBP_REQ_CMP){ 2046 SCSI_XFER_ERROR(sxfer) = 2047 XS_REQ_CMP_ERR; 2048 }else{ 2049 SCSI_XFER_ERROR(sxfer) = 2050 XS_REQ_CMP; 2051 SCSI_XFER_REQUEST_COMPLETE( 2052 sxfer); 2053 } 2054 } 2055 /* fix up inq data */ 2056 if (SCSI_XFER_OPECODE(sxfer) == INQUIRY) 2057 sbp_fix_inq_data(ocb); 2058 SBP_LOCK(sbp); 2059 SCSI_TRANSFER_DONE(sxfer); 2060 SBP_UNLOCK(sbp); 2061 } 2062 break; 2063 default: 2064 break; 2065 } 2066 } 2067 2068 if (!use_doorbell) 2069 sbp_free_ocb(sdev, ocb); 2070 done: 2071 if (reset_agent) 2072 sbp_agent_reset(sdev); 2073 2074 done0: 2075 xfer->recv.pay_len = SBP_RECV_LEN; 2076 /* The received packet is usually small enough to be stored within 2077 * the buffer. In that case, the controller return ack_complete and 2078 * no respose is necessary. 2079 * 2080 * XXX fwohci.c and firewire.c should inform event_code such as 2081 * ack_complete or ack_pending to upper driver. 2082 */ 2083 #if NEED_RESPONSE 2084 xfer->send.off = 0; 2085 sfp = (struct fw_pkt *)xfer->send.buf; 2086 sfp->mode.wres.dst = rfp->mode.wreqb.src; 2087 xfer->dst = sfp->mode.wres.dst; 2088 xfer->spd = min(sdev->target->fwdev->speed, max_speed); 2089 xfer->hand = sbp_loginres_callback; 2090 2091 sfp->mode.wres.tlrt = rfp->mode.wreqb.tlrt; 2092 sfp->mode.wres.tcode = FWTCODE_WRES; 2093 sfp->mode.wres.rtcode = 0; 2094 sfp->mode.wres.pri = 0; 2095 2096 fw_asyreq(xfer->fc, -1, xfer); 2097 #else 2098 /* recycle */ 2099 STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link); 2100 #endif 2101 2102 return; 2103 2104 } 2105 2106 static void 2107 sbp_recv(struct fw_xfer *xfer) 2108 { 2109 int s; 2110 2111 s = splfwsbp(); 2112 sbp_recv1(xfer); 2113 splx(s); 2114 } 2115 /* 2116 * sbp_attach() 2117 */ 2118 FW_ATTACH(sbp) 2119 { 2120 FW_ATTACH_START(sbp, sbp, fwa); 2121 int dv_unit, error, s; 2122 struct firewire_comm *fc; 2123 SBP_ATTACH_START; 2124 2125 if (DFLTPHYS > SBP_MAXPHYS) 2126 fw_printf(sbp->fd.dev, 2127 "Warning, DFLTPHYS(%dKB) is larger than " 2128 "SBP_MAXPHYS(%dKB).\n", DFLTPHYS / 1024, 2129 SBP_MAXPHYS / 1024); 2130 SBP_DEBUG(0) 2131 printf("sbp_attach (cold=%d)\n", cold); 2132 END_DEBUG 2133 2134 if (cold) 2135 sbp_cold ++; 2136 sbp->fd.fc = fc = fwa->fc; 2137 fw_mtx_init(&sbp->mtx, "sbp", NULL, MTX_DEF); 2138 2139 if (max_speed < 0) 2140 max_speed = fc->speed; 2141 2142 error = fw_bus_dma_tag_create(/*parent*/fc->dmat, 2143 /* XXX shoud be 4 for sane backend? */ 2144 /*alignment*/1, 2145 /*boundary*/0, 2146 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, 2147 /*highaddr*/BUS_SPACE_MAXADDR, 2148 /*filter*/NULL, /*filterarg*/NULL, 2149 /*maxsize*/0x100000, /*nsegments*/SBP_IND_MAX, 2150 /*maxsegsz*/SBP_SEG_MAX, 2151 /*flags*/BUS_DMA_ALLOCNOW, 2152 /*lockfunc*/busdma_lock_mutex, 2153 /*lockarg*/&sbp->mtx, 2154 &sbp->dmat); 2155 if (error != 0) { 2156 printf("sbp_attach: Could not allocate DMA tag " 2157 "- error %d\n", error); 2158 FW_ATTACH_RETURN(ENOMEM); 2159 } 2160 2161 #if defined(__FreeBSD__) 2162 devq = cam_simq_alloc(/*maxopenings*/SBP_NUM_OCB); 2163 if (devq == NULL) 2164 return (ENXIO); 2165 #endif 2166 2167 sbp->target.fwdev = NULL; 2168 sbp->target.luns = NULL; 2169 2170 if (sbp_alloc_target(sbp, fwa->fwdev) == NULL) 2171 FW_ATTACH_RETURN(ENXIO); 2172 2173 SBP_SCSIBUS_ATTACH; 2174 2175 /* We reserve 16 bit space (4 bytes X 64 unit X 256 luns) */ 2176 dv_unit = fw_get_unit(sbp->fd.dev); 2177 sbp->fwb.start = SBP_DEV2ADDR(dv_unit, 0); 2178 sbp->fwb.end = SBP_DEV2ADDR(dv_unit, -1); 2179 /* pre-allocate xfer */ 2180 STAILQ_INIT(&sbp->fwb.xferlist); 2181 fw_xferlist_add(&sbp->fwb.xferlist, M_SBP, 2182 /*send*/ 0, /*recv*/ SBP_RECV_LEN, SBP_NUM_OCB/2, 2183 fc, (void *)sbp, sbp_recv); 2184 fw_bindadd(fc, &sbp->fwb); 2185 2186 sbp->fd.post_busreset = sbp_post_busreset; 2187 sbp->fd.post_explore = sbp_post_explore; 2188 2189 if (fc->status != FWBUSNOTREADY) { 2190 s = splfw(); 2191 sbp_post_busreset((void *)sbp); 2192 sbp_post_explore((void *)sbp); 2193 splx(s); 2194 } 2195 2196 FW_ATTACH_RETURN(0); 2197 #if defined(__FreeBSD__) 2198 fail: 2199 SBP_UNLOCK(sbp); 2200 cam_sim_free(sbp->sim, /*free_devq*/TRUE); 2201 return (ENXIO); 2202 #endif 2203 } 2204 2205 static int 2206 sbp_logout_all(struct sbp_softc *sbp) 2207 { 2208 struct sbp_target *target; 2209 struct sbp_dev *sdev; 2210 int i; 2211 2212 SBP_DEBUG(0) 2213 printf("sbp_logout_all\n"); 2214 END_DEBUG 2215 target = &sbp->target; 2216 if (target->luns != NULL) 2217 for (i = 0; i < target->num_lun; i++) { 2218 sdev = target->luns[i]; 2219 if (sdev == NULL) 2220 continue; 2221 fw_callout_stop(&sdev->login_callout); 2222 if (sdev->status >= SBP_DEV_TOATTACH && 2223 sdev->status <= SBP_DEV_ATTACHED) 2224 sbp_mgm_orb(sdev, ORB_FUN_LGO, NULL); 2225 } 2226 2227 return 0; 2228 } 2229 2230 #if defined(__FreeBSD__) 2231 static int 2232 sbp_shutdown(device_t dev) 2233 { 2234 struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev)); 2235 2236 sbp_logout_all(sbp); 2237 return (0); 2238 } 2239 #endif 2240 2241 static void 2242 sbp_free_sdev(struct sbp_dev *sdev) 2243 { 2244 int i; 2245 2246 if (sdev == NULL) 2247 return; 2248 for (i = 0; i < SBP_QUEUE_LEN; i++) 2249 fw_bus_dmamap_destroy(sdev->target->sbp->dmat, 2250 sdev->ocb[i].dmamap); 2251 fwdma_free(sdev->target->sbp->fd.fc, &sdev->dma); 2252 free(sdev, M_SBP); 2253 } 2254 2255 static void 2256 sbp_free_target(struct sbp_target *target) 2257 { 2258 struct sbp_softc *sbp; 2259 struct fw_xfer *xfer, *next; 2260 int i; 2261 2262 if (target->luns == NULL) 2263 return; 2264 fw_callout_stop(&target->mgm_ocb_timeout); 2265 sbp = target->sbp; 2266 for (i = 0; i < target->num_lun; i++) 2267 sbp_free_sdev(target->luns[i]); 2268 2269 for (xfer = STAILQ_FIRST(&target->xferlist); 2270 xfer != NULL; xfer = next) { 2271 next = STAILQ_NEXT(xfer, link); 2272 fw_xfer_free_buf(xfer); 2273 } 2274 STAILQ_INIT(&target->xferlist); 2275 free(target->luns, M_SBP); 2276 target->num_lun = 0;; 2277 target->luns = NULL; 2278 target->fwdev = NULL; 2279 } 2280 2281 FW_DETACH(sbp) 2282 { 2283 FW_DETACH_START(sbp, sbp); 2284 struct firewire_comm *fc = sbp->fd.fc; 2285 int i; 2286 2287 SBP_DEBUG(0) 2288 printf("sbp_detach\n"); 2289 END_DEBUG 2290 2291 SBP_DETACH_TARGET(&sbp->target); 2292 #if defined(__FreeBSD__) 2293 SBP_LOCK(sbp); 2294 xpt_async(AC_LOST_DEVICE, sbp->path, NULL); 2295 xpt_free_path(sbp->path); 2296 xpt_bus_deregister(cam_sim_path(sbp->sim)); 2297 cam_sim_free(sbp->sim, /*free_devq*/ TRUE), 2298 SBP_UNLOCK(sbp); 2299 #endif 2300 2301 sbp_logout_all(sbp); 2302 2303 /* XXX wait for logout completion */ 2304 tsleep(&i, FWPRI, "sbpdtc", hz/2); 2305 2306 sbp_free_target(&sbp->target); 2307 2308 fw_bindremove(fc, &sbp->fwb); 2309 fw_xferlist_remove(&sbp->fwb.xferlist); 2310 2311 fw_bus_dma_tag_destroy(sbp->dmat); 2312 fw_mtx_destroy(&sbp->mtx); 2313 2314 return (0); 2315 } 2316 2317 #if defined(__FreeBSD__) 2318 static void 2319 sbp_cam_detach_sdev(struct sbp_dev *sdev) 2320 { 2321 if (sdev == NULL) 2322 return; 2323 if (sdev->status == SBP_DEV_DEAD) 2324 return; 2325 if (sdev->status == SBP_DEV_RESET) 2326 return; 2327 sbp_abort_all_ocbs(sdev, CAM_DEV_NOT_THERE); 2328 if (sdev->path) { 2329 SBP_LOCK(sdev->target->sbp); 2330 xpt_release_devq(sdev->path, 2331 sdev->freeze, TRUE); 2332 sdev->freeze = 0; 2333 xpt_async(AC_LOST_DEVICE, sdev->path, NULL); 2334 xpt_free_path(sdev->path); 2335 sdev->path = NULL; 2336 SBP_UNLOCK(sdev->target->sbp); 2337 } 2338 } 2339 2340 static void 2341 sbp_cam_detach_target(struct sbp_target *target) 2342 { 2343 int i; 2344 2345 if (target->luns != NULL) { 2346 SBP_DEBUG(0) 2347 printf("sbp_detach_target %d\n", target->target_id); 2348 END_DEBUG 2349 fw_callout_stop(&target->scan_callout); 2350 for (i = 0; i < target->num_lun; i++) 2351 sbp_cam_detach_sdev(target->luns[i]); 2352 } 2353 } 2354 #elif defined(__NetBSD__) 2355 static void 2356 sbp_scsipi_detach_sdev(struct sbp_dev *sdev) 2357 { 2358 struct sbp_target *target; 2359 struct sbp_softc *sbp; 2360 2361 if (sdev == NULL) 2362 return; 2363 2364 target = sdev->target; 2365 if (target == NULL) 2366 return; 2367 2368 sbp = target->sbp; 2369 2370 if (sdev->status == SBP_DEV_DEAD) 2371 return; 2372 if (sdev->status == SBP_DEV_RESET) 2373 return; 2374 if (sdev->periph) { 2375 scsipi_periph_thaw(sdev->periph, sdev->freeze); 2376 scsipi_channel_thaw(&sbp->sc_channel, 0); /* XXXX */ 2377 sdev->freeze = 0; 2378 if (scsipi_target_detach(&sbp->sc_channel, 2379 target->target_id, sdev->lun_id, DETACH_FORCE) != 0) { 2380 sbp_show_sdev_info(sdev, 2); 2381 printf("detach failed\n"); 2382 } 2383 sdev->periph = NULL; 2384 } 2385 sbp_abort_all_ocbs(sdev, XS_DEV_NOT_THERE); 2386 } 2387 2388 static void 2389 sbp_scsipi_detach_target(struct sbp_target *target) 2390 { 2391 struct sbp_softc *sbp = target->sbp; 2392 int i; 2393 2394 if (target->luns != NULL) { 2395 SBP_DEBUG(0) 2396 printf("sbp_detach_target %d\n", target->target_id); 2397 END_DEBUG 2398 fw_callout_stop(&target->scan_callout); 2399 for (i = 0; i < target->num_lun; i++) 2400 sbp_scsipi_detach_sdev(target->luns[i]); 2401 if (config_detach(sbp->sc_bus, DETACH_FORCE) != 0) 2402 fw_printf(sbp->fd.dev, "%d detach failed\n", 2403 target->target_id); 2404 sbp->sc_bus = NULL; 2405 } 2406 } 2407 #endif 2408 2409 static void 2410 sbp_target_reset(struct sbp_dev *sdev, int method) 2411 { 2412 int i; 2413 struct sbp_target *target = sdev->target; 2414 struct sbp_dev *tsdev; 2415 2416 for (i = 0; i < target->num_lun; i++) { 2417 tsdev = target->luns[i]; 2418 if (tsdev == NULL) 2419 continue; 2420 if (tsdev->status == SBP_DEV_DEAD) 2421 continue; 2422 if (tsdev->status == SBP_DEV_RESET) 2423 continue; 2424 SBP_LOCK(target->sbp); 2425 SBP_DEVICE_FREEZE(tsdev, 1); 2426 tsdev->freeze ++; 2427 SBP_UNLOCK(target->sbp); 2428 sbp_abort_all_ocbs(tsdev, XS_CMD_TIMEOUT); 2429 if (method == 2) 2430 tsdev->status = SBP_DEV_LOGIN; 2431 } 2432 switch(method) { 2433 case 1: 2434 printf("target reset\n"); 2435 sbp_mgm_orb(sdev, ORB_FUN_RST, NULL); 2436 break; 2437 case 2: 2438 printf("reset start\n"); 2439 sbp_reset_start(sdev); 2440 break; 2441 } 2442 2443 } 2444 2445 static void 2446 sbp_mgm_timeout(void *arg) 2447 { 2448 struct sbp_ocb *ocb = (struct sbp_ocb *)arg; 2449 struct sbp_dev *sdev = ocb->sdev; 2450 struct sbp_target *target = sdev->target; 2451 2452 sbp_show_sdev_info(sdev, 2); 2453 printf("request timeout(mgm orb:0x%08x) ... ", 2454 (uint32_t)ocb->bus_addr); 2455 target->mgm_ocb_cur = NULL; 2456 sbp_free_ocb(sdev, ocb); 2457 #if 0 2458 /* XXX */ 2459 printf("run next request\n"); 2460 sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL); 2461 #endif 2462 #if 1 2463 printf("reset start\n"); 2464 sbp_reset_start(sdev); 2465 #endif 2466 } 2467 2468 static void 2469 sbp_timeout(void *arg) 2470 { 2471 struct sbp_ocb *ocb = (struct sbp_ocb *)arg; 2472 struct sbp_dev *sdev = ocb->sdev; 2473 2474 sbp_show_sdev_info(sdev, 2); 2475 printf("request timeout(cmd orb:0x%08x) ... ", 2476 (uint32_t)ocb->bus_addr); 2477 2478 sdev->timeout ++; 2479 switch(sdev->timeout) { 2480 case 1: 2481 printf("agent reset\n"); 2482 SBP_LOCK(sdev->target->sbp); 2483 SBP_DEVICE_FREEZE(sdev, 1); 2484 sdev->freeze ++; 2485 SBP_UNLOCK(sdev->target->sbp); 2486 sbp_abort_all_ocbs(sdev, XS_CMD_TIMEOUT); 2487 sbp_agent_reset(sdev); 2488 break; 2489 case 2: 2490 case 3: 2491 sbp_target_reset(sdev, sdev->timeout - 1); 2492 break; 2493 #if 0 2494 default: 2495 /* XXX give up */ 2496 SBP_DETACH_TARGET(target); 2497 if (target->luns != NULL) 2498 free(target->luns, M_SBP); 2499 target->num_lun = 0;; 2500 target->luns = NULL; 2501 target->fwdev = NULL; 2502 #endif 2503 } 2504 } 2505 2506 static void 2507 sbp_action1(struct sbp_softc *sbp, sbp_scsi_xfer *sxfer) 2508 { 2509 2510 struct sbp_target *target = NULL; 2511 struct sbp_dev *sdev = NULL; 2512 2513 /* target:lun -> sdev mapping */ 2514 if (sbp != NULL) { 2515 target = &sbp->target; 2516 if (target->fwdev != NULL 2517 && NOT_LUN_WILDCARD(SCSI_XFER_LUN(sxfer)) 2518 && SCSI_XFER_LUN(sxfer) < target->num_lun) { 2519 sdev = target->luns[SCSI_XFER_LUN(sxfer)]; 2520 if (sdev != NULL && sdev->status != SBP_DEV_ATTACHED && 2521 sdev->status != SBP_DEV_PROBE) 2522 sdev = NULL; 2523 } 2524 } 2525 2526 SBP_DEBUG(1) 2527 if (sdev == NULL) 2528 printf("invalid target %d lun %d\n", 2529 SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer)); 2530 END_DEBUG 2531 2532 switch (SCSI_XFER_FUNCCODE(sxfer)) { 2533 case XPT_SCSI_IO: 2534 #if defined(__FreeBSD__) 2535 case XPT_RESET_DEV: 2536 case XPT_GET_TRAN_SETTINGS: 2537 case XPT_SET_TRAN_SETTINGS: 2538 case XPT_CALC_GEOMETRY: 2539 #endif 2540 if (sdev == NULL) { 2541 SBP_DEBUG(1) 2542 printf("%s:%d:%d:func_code 0x%04x: " 2543 "Invalid target (target needed)\n", 2544 sbp ? fw_get_nameunit(sbp->fd.dev) : "???", 2545 SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer), 2546 SCSI_XFER_FUNCCODE(sxfer)); 2547 END_DEBUG 2548 2549 SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE; 2550 SCSI_TRANSFER_DONE(sxfer); 2551 return; 2552 } 2553 break; 2554 #if defined(__FreeBSD__) 2555 case XPT_PATH_INQ: 2556 case XPT_NOOP: 2557 /* The opcodes sometimes aimed at a target (sc is valid), 2558 * sometimes aimed at the SIM (sc is invalid and target is 2559 * CAM_TARGET_WILDCARD) 2560 */ 2561 if (sbp == NULL && 2562 sxfer->ccb_h.target_id != CAM_TARGET_WILDCARD) { 2563 SBP_DEBUG(0) 2564 printf("%s:%d:%d func_code 0x%04x: " 2565 "Invalid target (no wildcard)\n", 2566 fw_get_nameunit(sbp->fd.dev), 2567 sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun, 2568 sxfer->ccb_h.func_code); 2569 END_DEBUG 2570 SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE; 2571 SCSI_TRANSFER_DONE(sxfer); 2572 return; 2573 } 2574 break; 2575 #endif 2576 default: 2577 /* XXX Hm, we should check the input parameters */ 2578 break; 2579 } 2580 2581 switch (SCSI_XFER_FUNCCODE(sxfer)) { 2582 case XPT_SCSI_IO: 2583 { 2584 struct sbp_ocb *ocb; 2585 int speed; 2586 void *cdb; 2587 fw_mtx_assert(sim->mtx, MA_OWNED); 2588 2589 SBP_DEBUG(2) 2590 printf("%s:%d:%d XPT_SCSI_IO: " 2591 "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x" 2592 ", flags: 0x%02x, " 2593 "%db cmd/%db data/%db sense\n", 2594 fw_get_nameunit(sbp->fd.dev), 2595 SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer), 2596 SCSI_XFER_10BCMD_DUMP(sxfer), 2597 SCSI_XFER_DIR(sxfer), 2598 SCSI_XFER_CMDLEN(sxfer), SCSI_XFER_DATALEN(sxfer), 2599 SCSI_XFER_SENSELEN(sxfer)); 2600 END_DEBUG 2601 if(sdev == NULL){ 2602 SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE; 2603 SCSI_TRANSFER_DONE(sxfer); 2604 return; 2605 } 2606 #if 0 2607 /* if we are in probe stage, pass only probe commands */ 2608 if (sdev->status == SBP_DEV_PROBE) { 2609 char *name; 2610 name = xpt_path_periph(sxfer->ccb_h.path)->periph_name; 2611 printf("probe stage, periph name: %s\n", name); 2612 if (strcmp(name, "probe") != 0) { 2613 SCSI_XFER_ERROR(sxfer) = XS_REQUEUE_REQ; 2614 SCSI_TRANSFER_DONE(sxfer); 2615 return; 2616 } 2617 } 2618 #endif 2619 if ((ocb = sbp_get_ocb(sdev)) == NULL) { 2620 SCSI_XFER_ERROR(sxfer) = XS_REQUEUE_REQ; 2621 if (sdev->freeze == 0) { 2622 SBP_LOCK(sdev->target->sbp); 2623 SBP_DEVICE_FREEZE(sdev, 1); 2624 sdev->freeze ++; 2625 SBP_UNLOCK(sdev->target->sbp); 2626 } 2627 SCSI_TRANSFER_DONE(sxfer); 2628 return; 2629 } 2630 2631 ocb->flags = OCB_ACT_CMD; 2632 ocb->sdev = sdev; 2633 ocb->sxfer = sxfer; 2634 #if defined(__FreeBSD__) 2635 sxfer->ccb_h.ccb_sdev_ptr = sdev; 2636 #endif 2637 ocb->orb[0] = htonl(1 << 31); 2638 ocb->orb[1] = 0; 2639 ocb->orb[2] = htonl(((sbp->fd.fc->nodeid | FWLOCALBUS )<< 16) ); 2640 ocb->orb[3] = htonl(ocb->bus_addr + IND_PTR_OFFSET); 2641 speed = min(target->fwdev->speed, max_speed); 2642 ocb->orb[4] = htonl(ORB_NOTIFY | ORB_CMD_SPD(speed) 2643 | ORB_CMD_MAXP(speed + 7)); 2644 if(SCSI_XFER_DIR(sxfer) == SCSI_XFER_DATA_IN){ 2645 ocb->orb[4] |= htonl(ORB_CMD_IN); 2646 } 2647 2648 if (CAM_XFER_FLAGS(sxfer) & CAM_SCATTER_VALID) 2649 printf("sbp: CAM_SCATTER_VALID\n"); 2650 if (CAM_XFER_FLAGS(sxfer) & CAM_DATA_PHYS) 2651 printf("sbp: CAM_DATA_PHYS\n"); 2652 2653 cdb = SCSI_XFER_CMD(sxfer); 2654 bcopy(cdb, (void *)&ocb->orb[5], SCSI_XFER_CMDLEN(sxfer)); 2655 /* 2656 printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[0]), ntohl(ocb->orb[1]), ntohl(ocb->orb[2]), ntohl(ocb->orb[3])); 2657 printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[4]), ntohl(ocb->orb[5]), ntohl(ocb->orb[6]), ntohl(ocb->orb[7])); 2658 */ 2659 if (SCSI_XFER_DATALEN(sxfer) > 0) { 2660 int s, error; 2661 2662 s = splsoftvm(); 2663 error = fw_bus_dmamap_load(/*dma tag*/sbp->dmat, 2664 /*dma map*/ocb->dmamap, 2665 SCSI_XFER_DATA(sxfer), 2666 SCSI_XFER_DATALEN(sxfer), 2667 sbp_execute_ocb, 2668 ocb, 2669 /*flags*/0); 2670 splx(s); 2671 if (error) 2672 printf("sbp: bus_dmamap_load error %d\n", error); 2673 } else 2674 sbp_execute_ocb(ocb, NULL, 0, 0); 2675 break; 2676 } 2677 #if defined(__FreeBSD__) 2678 case XPT_CALC_GEOMETRY: 2679 { 2680 struct ccb_calc_geometry *ccg; 2681 #if defined(__DragonFly__) || __FreeBSD_version < 501100 2682 uint32_t size_mb; 2683 uint32_t secs_per_cylinder; 2684 int extended = 1; 2685 #endif 2686 2687 ccg = &sxfer->ccg; 2688 if (ccg->block_size == 0) { 2689 printf("sbp_action1: block_size is 0.\n"); 2690 SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID; 2691 SCSI_TRANSFER_DONE(sxfer); 2692 break; 2693 } 2694 SBP_DEBUG(1) 2695 printf("%s:%d:%d:%d:XPT_CALC_GEOMETRY: " 2696 #if defined(__DragonFly__) || __FreeBSD_version < 500000 2697 "Volume size = %d\n", 2698 #else 2699 "Volume size = %jd\n", 2700 #endif 2701 fw_get_nameunit(sbp->fd.dev), 2702 cam_sim_path(sbp->sim), 2703 sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun, 2704 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000 2705 (uintmax_t) 2706 #endif 2707 ccg->volume_size); 2708 END_DEBUG 2709 2710 #if defined(__DragonFly__) || __FreeBSD_version < 501100 2711 size_mb = ccg->volume_size 2712 / ((1024L * 1024L) / ccg->block_size); 2713 2714 if (size_mb > 1024 && extended) { 2715 ccg->heads = 255; 2716 ccg->secs_per_track = 63; 2717 } else { 2718 ccg->heads = 64; 2719 ccg->secs_per_track = 32; 2720 } 2721 secs_per_cylinder = ccg->heads * ccg->secs_per_track; 2722 ccg->cylinders = ccg->volume_size / secs_per_cylinder; 2723 SCSI_XFER_ERROR(sxfer) = XS_REQ_CMP; 2724 #else 2725 cam_calc_geometry(ccg, /*extended*/1); 2726 #endif 2727 SCSI_TRANSFER_DONE(sxfer); 2728 break; 2729 } 2730 case XPT_RESET_BUS: /* Reset the specified SCSI bus */ 2731 { 2732 2733 SBP_DEBUG(1) 2734 printf("%s:%d:XPT_RESET_BUS: \n", 2735 fw_get_nameunit(sbp->fd.dev), cam_sim_path(sbp->sim)); 2736 END_DEBUG 2737 2738 SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID; 2739 SCSI_TRANSFER_DONE(sxfer); 2740 break; 2741 } 2742 case XPT_PATH_INQ: /* Path routing inquiry */ 2743 { 2744 struct ccb_pathinq *cpi = &sxfer->cpi; 2745 struct cam_sim *sim = sbp->sim; 2746 2747 SBP_DEBUG(1) 2748 printf("%s:%d:%d XPT_PATH_INQ:.\n", 2749 fw_get_nameunit(sbp->fd.dev), 2750 sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun); 2751 END_DEBUG 2752 cpi->version_num = 1; /* XXX??? */ 2753 cpi->hba_inquiry = PI_TAG_ABLE; 2754 cpi->target_sprt = 0; 2755 cpi->hba_misc = PIM_NOBUSRESET | PIM_NO_6_BYTE; 2756 cpi->hba_eng_cnt = 0; 2757 cpi->max_target = SBP_NUM_TARGETS - 1; 2758 cpi->max_lun = SBP_NUM_LUNS - 1; 2759 cpi->initiator_id = SBP_INITIATOR; 2760 cpi->bus_id = sim->bus_id; 2761 cpi->base_transfer_speed = 400 * 1000 / 8; 2762 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2763 strncpy(cpi->hba_vid, "SBP", HBA_IDLEN); 2764 strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN); 2765 cpi->unit_number = sim->unit_number; 2766 cpi->transport = XPORT_SPI; /* XX should havea FireWire */ 2767 cpi->transport_version = 2; 2768 cpi->protocol = PROTO_SCSI; 2769 cpi->protocol_version = SCSI_REV_2; 2770 2771 SCSI_XFER_ERROR(cpi) = XS_REQ_CMP; 2772 SCSI_TRANSFER_DONE(sxfer); 2773 break; 2774 } 2775 case XPT_GET_TRAN_SETTINGS: 2776 { 2777 struct ccb_trans_settings *cts = &sxfer->cts; 2778 struct ccb_trans_settings_scsi *scsi = 2779 &cts->proto_specific.scsi; 2780 struct ccb_trans_settings_spi *spi = 2781 &cts->xport_specific.spi; 2782 2783 cts->protocol = PROTO_SCSI; 2784 cts->protocol_version = SCSI_REV_2; 2785 cts->transport = XPORT_SPI; /* should have a FireWire */ 2786 cts->transport_version = 2; 2787 spi->valid = CTS_SPI_VALID_DISC; 2788 spi->flags = CTS_SPI_FLAGS_DISC_ENB; 2789 scsi->valid = CTS_SCSI_VALID_TQ; 2790 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB; 2791 SBP_DEBUG(1) 2792 printf("%s:%d:%d XPT_GET_TRAN_SETTINGS:.\n", 2793 fw_get_nameunit(sbp->fd.dev), 2794 sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun); 2795 END_DEBUG 2796 SCSI_XFER_ERROR(cts) = XS_REQ_CMP; 2797 SCSI_TRANSFER_DONE(sxfer); 2798 break; 2799 } 2800 case XPT_ABORT: 2801 SCSI_XFER_ERROR(sxfer) = XS_UA_ABORT; 2802 SCSI_TRANSFER_DONE(sxfer); 2803 break; 2804 case XPT_SET_TRAN_SETTINGS: 2805 /* XXX */ 2806 default: 2807 SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID; 2808 SCSI_TRANSFER_DONE(sxfer); 2809 break; 2810 #endif 2811 } 2812 return; 2813 } 2814 2815 #if defined(__FreeBSD__) 2816 static void 2817 sbp_action(struct cam_sim *sim, sbp_scsi_xfer *sxfer) 2818 { 2819 int s; 2820 2821 s = splfw(); 2822 sbp_action1(sim->softc, sxfer); 2823 splx(s); 2824 } 2825 #endif 2826 2827 static void 2828 sbp_execute_ocb(void *arg, bus_dma_segment_t *segments, int seg, int error) 2829 { 2830 int i; 2831 struct sbp_ocb *ocb; 2832 struct sbp_ocb *prev; 2833 bus_dma_segment_t *s; 2834 2835 if (error) 2836 printf("sbp_execute_ocb: error=%d\n", error); 2837 2838 ocb = (struct sbp_ocb *)arg; 2839 2840 SBP_DEBUG(2) 2841 printf("sbp_execute_ocb: seg %d", seg); 2842 for (i = 0; i < seg; i++) 2843 #if defined(__DragonFly__) || \ 2844 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 2845 printf(", %x:%d", segments[i].ds_addr, segments[i].ds_len); 2846 #else 2847 printf(", %jx:%jd", (uintmax_t)segments[i].ds_addr, 2848 (uintmax_t)segments[i].ds_len); 2849 #endif 2850 printf("\n"); 2851 END_DEBUG 2852 2853 if (seg == 1) { 2854 /* direct pointer */ 2855 s = &segments[0]; 2856 if (s->ds_len > SBP_SEG_MAX) 2857 panic("ds_len > SBP_SEG_MAX, fix busdma code"); 2858 ocb->orb[3] = htonl(s->ds_addr); 2859 ocb->orb[4] |= htonl(s->ds_len); 2860 } else if(seg > 1) { 2861 /* page table */ 2862 for (i = 0; i < seg; i++) { 2863 s = &segments[i]; 2864 SBP_DEBUG(0) 2865 /* XXX LSI Logic "< 16 byte" bug might be hit */ 2866 if (s->ds_len < 16) 2867 printf("sbp_execute_ocb: warning, " 2868 #if defined(__DragonFly__) || \ 2869 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 2870 "segment length(%d) is less than 16." 2871 #else 2872 "segment length(%jd) is less than 16." 2873 #endif 2874 "(seg=%d/%d)\n", (uintmax_t)s->ds_len, i+1, seg); 2875 END_DEBUG 2876 if (s->ds_len > SBP_SEG_MAX) 2877 panic("ds_len > SBP_SEG_MAX, fix busdma code"); 2878 ocb->ind_ptr[i].hi = htonl(s->ds_len << 16); 2879 ocb->ind_ptr[i].lo = htonl(s->ds_addr); 2880 } 2881 ocb->orb[4] |= htonl(ORB_CMD_PTBL | seg); 2882 } 2883 2884 if (seg > 0) 2885 fw_bus_dmamap_sync(ocb->sdev->target->sbp->dmat, ocb->dmamap, 2886 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 2887 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 2888 prev = sbp_enqueue_ocb(ocb->sdev, ocb); 2889 fwdma_sync(&ocb->sdev->dma, BUS_DMASYNC_PREWRITE); 2890 if (use_doorbell) { 2891 if (prev == NULL) { 2892 if (ocb->sdev->last_ocb != NULL) 2893 sbp_doorbell(ocb->sdev); 2894 else 2895 sbp_orb_pointer(ocb->sdev, ocb); 2896 } 2897 } else { 2898 if (prev == NULL || (ocb->sdev->flags & ORB_LINK_DEAD) != 0) { 2899 ocb->sdev->flags &= ~ORB_LINK_DEAD; 2900 sbp_orb_pointer(ocb->sdev, ocb); 2901 } 2902 } 2903 } 2904 2905 #if defined(__FreeBSD__) 2906 static void 2907 sbp_poll(struct cam_sim *sim) 2908 { 2909 struct sbp_softc *sbp; 2910 struct firewire_comm *fc; 2911 2912 sbp = (struct sbp_softc *)sim->softc; 2913 fc = sbp->fd.fc; 2914 2915 fc->poll(fc, 0, -1); 2916 2917 return; 2918 } 2919 2920 #endif 2921 static struct sbp_ocb * 2922 sbp_dequeue_ocb(struct sbp_dev *sdev, struct sbp_status *sbp_status) 2923 { 2924 struct sbp_ocb *ocb; 2925 struct sbp_ocb *next; 2926 int s = splfw(), order = 0; 2927 int flags; 2928 2929 SBP_DEBUG(1) 2930 sbp_show_sdev_info(sdev, 2); 2931 #if defined(__DragonFly__) || \ 2932 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 2933 printf("%s: 0x%08lx src %d\n", 2934 #else 2935 printf("%s: 0x%08x src %d\n", 2936 #endif 2937 __func__, ntohl(sbp_status->orb_lo), sbp_status->src); 2938 END_DEBUG 2939 SBP_LOCK(sdev->target->sbp); 2940 for (ocb = STAILQ_FIRST(&sdev->ocbs); ocb != NULL; ocb = next) { 2941 next = STAILQ_NEXT(ocb, ocb); 2942 flags = ocb->flags; 2943 if (OCB_MATCH(ocb, sbp_status)) { 2944 /* found */ 2945 STAILQ_REMOVE(&sdev->ocbs, ocb, sbp_ocb, ocb); 2946 if (ocb->sxfer != NULL) 2947 #if defined(__DragonFly__) || defined(__NetBSD__) 2948 fw_callout_stop(&SCSI_XFER_CALLOUT(ocb->sxfer)); 2949 #else 2950 untimeout(sbp_timeout, (void *)ocb, 2951 SCSI_XFER_CALLOUT(ocb->sxfer)); 2952 #endif 2953 if (ntohl(ocb->orb[4]) & 0xffff) { 2954 fw_bus_dmamap_sync(sdev->target->sbp->dmat, 2955 ocb->dmamap, 2956 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 2957 BUS_DMASYNC_POSTREAD : 2958 BUS_DMASYNC_POSTWRITE); 2959 fw_bus_dmamap_unload(sdev->target->sbp->dmat, 2960 ocb->dmamap); 2961 } 2962 if (!use_doorbell) { 2963 if (sbp_status->src == SRC_NO_NEXT) { 2964 if (next != NULL) 2965 sbp_orb_pointer(sdev, next); 2966 else if (order > 0) { 2967 /* 2968 * Unordered execution 2969 * We need to send pointer for 2970 * next ORB 2971 */ 2972 sdev->flags |= ORB_LINK_DEAD; 2973 } 2974 } 2975 } else { 2976 /* 2977 * XXX this is not correct for unordered 2978 * execution. 2979 */ 2980 if (sdev->last_ocb != NULL) 2981 sbp_free_ocb(sdev, sdev->last_ocb); 2982 sdev->last_ocb = ocb; 2983 if (next != NULL && 2984 sbp_status->src == SRC_NO_NEXT) 2985 sbp_doorbell(sdev); 2986 } 2987 break; 2988 } else 2989 order ++; 2990 } 2991 SBP_UNLOCK(sdev->target->sbp); 2992 splx(s); 2993 SBP_DEBUG(0) 2994 if (ocb && order > 0) { 2995 sbp_show_sdev_info(sdev, 2); 2996 printf("unordered execution order:%d\n", order); 2997 } 2998 END_DEBUG 2999 return (ocb); 3000 } 3001 3002 static struct sbp_ocb * 3003 sbp_enqueue_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb) 3004 { 3005 int s = splfw(); 3006 struct sbp_ocb *prev, *prev2; 3007 3008 SBP_DEBUG(1) 3009 sbp_show_sdev_info(sdev, 2); 3010 #if defined(__DragonFly__) || \ 3011 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 3012 printf("%s: 0x%08x\n", __func__, ocb->bus_addr); 3013 #else 3014 printf("%s: 0x%08jx\n", __func__, (uintmax_t)ocb->bus_addr); 3015 #endif 3016 END_DEBUG 3017 prev2 = prev = STAILQ_LAST(&sdev->ocbs, sbp_ocb, ocb); 3018 STAILQ_INSERT_TAIL(&sdev->ocbs, ocb, ocb); 3019 3020 if (ocb->sxfer != NULL) 3021 #if defined(__DragonFly__) || defined(__NetBSD__) 3022 fw_callout_reset(&SCSI_XFER_CALLOUT(ocb->sxfer), 3023 mstohz(SCSI_XFER_TIMEOUT(ocb->sxfer)), sbp_timeout, ocb); 3024 #else 3025 SCSI_XFER_CALLOUT(ocb->sxfer) = timeout(sbp_timeout, 3026 (void *)ocb, mstohz(SCSI_XFER_TIMEOUT(ocb->sxfer))); 3027 #endif 3028 3029 if (use_doorbell && prev == NULL) 3030 prev2 = sdev->last_ocb; 3031 3032 if (prev2 != NULL) { 3033 SBP_DEBUG(2) 3034 #if defined(__DragonFly__) || \ 3035 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 3036 printf("linking chain 0x%x -> 0x%x\n", 3037 prev2->bus_addr, ocb->bus_addr); 3038 #else 3039 printf("linking chain 0x%jx -> 0x%jx\n", 3040 (uintmax_t)prev2->bus_addr, (uintmax_t)ocb->bus_addr); 3041 #endif 3042 END_DEBUG 3043 prev2->orb[1] = htonl(ocb->bus_addr); 3044 prev2->orb[0] = 0; 3045 } 3046 splx(s); 3047 3048 return prev; 3049 } 3050 3051 static struct sbp_ocb * 3052 sbp_get_ocb(struct sbp_dev *sdev) 3053 { 3054 struct sbp_ocb *ocb; 3055 int s = splfw(); 3056 3057 fw_mtx_assert(&sdev->target->sbp->mtx, MA_OWNED); 3058 ocb = STAILQ_FIRST(&sdev->free_ocbs); 3059 if (ocb == NULL) { 3060 sdev->flags |= ORB_SHORTAGE; 3061 printf("ocb shortage!!!\n"); 3062 splx(s); 3063 return NULL; 3064 } 3065 STAILQ_REMOVE_HEAD(&sdev->free_ocbs, ocb); 3066 splx(s); 3067 ocb->sxfer = NULL; 3068 return (ocb); 3069 } 3070 3071 static void 3072 sbp_free_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb) 3073 { 3074 ocb->flags = 0; 3075 ocb->sxfer = NULL; 3076 3077 SBP_LOCK(sdev->target->sbp); 3078 STAILQ_INSERT_TAIL(&sdev->free_ocbs, ocb, ocb); 3079 if ((sdev->flags & ORB_SHORTAGE) != 0) { 3080 int count; 3081 3082 sdev->flags &= ~ORB_SHORTAGE; 3083 count = sdev->freeze; 3084 sdev->freeze = 0; 3085 SBP_DEVICE_THAW(sdev, count); 3086 } 3087 SBP_UNLOCK(sdev->target->sbp); 3088 } 3089 3090 static void 3091 sbp_abort_ocb(struct sbp_ocb *ocb, int status) 3092 { 3093 struct sbp_dev *sdev; 3094 3095 sdev = ocb->sdev; 3096 SBP_DEBUG(0) 3097 sbp_show_sdev_info(sdev, 2); 3098 #if defined(__DragonFly__) || \ 3099 (defined(__FreeBSD__) && __FreeBSD_version < 500000) 3100 printf("sbp_abort_ocb 0x%x\n", ocb->bus_addr); 3101 #else 3102 printf("sbp_abort_ocb 0x%jx\n", (uintmax_t)ocb->bus_addr); 3103 #endif 3104 END_DEBUG 3105 SBP_DEBUG(1) 3106 if (ocb->sxfer != NULL) 3107 sbp_print_scsi_cmd(ocb); 3108 END_DEBUG 3109 if (ntohl(ocb->orb[4]) & 0xffff) { 3110 fw_bus_dmamap_sync(sdev->target->sbp->dmat, ocb->dmamap, 3111 (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 3112 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 3113 fw_bus_dmamap_unload(sdev->target->sbp->dmat, ocb->dmamap); 3114 } 3115 if (ocb->sxfer != NULL) { 3116 #if defined(__DragonFly__ ) || defined(__NetBSD__) 3117 fw_callout_stop(&SCSI_XFER_CALLOUT(ocb->sxfer)); 3118 #else 3119 untimeout(sbp_timeout, (void *)ocb, 3120 SCSI_XFER_CALLOUT(ocb->sxfer)); 3121 #endif 3122 SCSI_XFER_ERROR(ocb->sxfer) = status; 3123 SBP_LOCK(sdev->target->sbp); 3124 SCSI_TRANSFER_DONE(ocb->sxfer); 3125 SBP_UNLOCK(sdev->target->sbp); 3126 } 3127 sbp_free_ocb(sdev, ocb); 3128 } 3129 3130 static void 3131 sbp_abort_all_ocbs(struct sbp_dev *sdev, int status) 3132 { 3133 int s; 3134 struct sbp_ocb *ocb, *next; 3135 STAILQ_HEAD(, sbp_ocb) temp; 3136 3137 s = splfw(); 3138 3139 bcopy(&sdev->ocbs, &temp, sizeof(temp)); 3140 STAILQ_INIT(&sdev->ocbs); 3141 for (ocb = STAILQ_FIRST(&temp); ocb != NULL; ocb = next) { 3142 next = STAILQ_NEXT(ocb, ocb); 3143 sbp_abort_ocb(ocb, status); 3144 } 3145 if (sdev->last_ocb != NULL) { 3146 sbp_free_ocb(sdev, sdev->last_ocb); 3147 sdev->last_ocb = NULL; 3148 } 3149 3150 splx(s); 3151 } 3152 3153 #if defined(__FreeBSD__) 3154 static devclass_t sbp_devclass; 3155 3156 static device_method_t sbp_methods[] = { 3157 /* device interface */ 3158 DEVMETHOD(device_probe, sbp_probe), 3159 DEVMETHOD(device_attach, sbp_attach), 3160 DEVMETHOD(device_detach, sbp_detach), 3161 DEVMETHOD(device_shutdown, sbp_shutdown), 3162 3163 { 0, 0 } 3164 }; 3165 3166 static driver_t sbp_driver = { 3167 "sbp", 3168 sbp_methods, 3169 sizeof(struct sbp_softc), 3170 }; 3171 #ifdef __DragonFly__ 3172 DECLARE_DUMMY_MODULE(sbp); 3173 #endif 3174 DRIVER_MODULE(sbp, firewire, sbp_driver, sbp_devclass, 0, 0); 3175 MODULE_VERSION(sbp, 1); 3176 MODULE_DEPEND(sbp, firewire, 1, 1, 1); 3177 MODULE_DEPEND(sbp, cam, 1, 1, 1); 3178 #elif defined(__NetBSD__) 3179 static void 3180 sbp_scsipi_request( 3181 struct scsipi_channel *channel, scsipi_adapter_req_t req, void *arg) 3182 { 3183 int i, s; 3184 struct sbp_softc *sbp = 3185 (struct sbp_softc *)channel->chan_adapter->adapt_dev; 3186 struct scsipi_xfer *xs = arg; 3187 3188 if (debug > 1) 3189 printf("Called sbpscsi_scsipi_request\n"); 3190 3191 switch (req) { 3192 case ADAPTER_REQ_RUN_XFER: 3193 if (debug > 1) { 3194 printf("Got req_run_xfer\n"); 3195 printf("xs control: 0x%08x, timeout: %d\n", 3196 xs->xs_control, xs->timeout); 3197 printf("opcode: 0x%02x\n", (int)xs->cmd->opcode); 3198 for (i = 0; i < 15; i++) 3199 printf("0x%02x ",(int)xs->cmd->bytes[i]); 3200 printf("\n"); 3201 } 3202 if (xs->xs_control & XS_CTL_RESET) { 3203 if (debug > 1) 3204 printf("XS_CTL_RESET not support\n"); 3205 break; 3206 } 3207 #define SBPSCSI_SBP2_MAX_CDB 12 3208 if (xs->cmdlen > SBPSCSI_SBP2_MAX_CDB) { 3209 if (debug > 0) 3210 printf( 3211 "sbp doesn't support cdb's larger than %d " 3212 "bytes\n", SBPSCSI_SBP2_MAX_CDB); 3213 SCSI_XFER_ERROR(xs) = XS_REQ_INVALID; 3214 SCSI_TRANSFER_DONE(xs); 3215 return; 3216 } 3217 s = splfw(); 3218 sbp_action1(sbp, xs); 3219 splx(s); 3220 3221 break; 3222 case ADAPTER_REQ_GROW_RESOURCES: 3223 if (debug > 1) 3224 printf("Got req_grow_resources\n"); 3225 break; 3226 case ADAPTER_REQ_SET_XFER_MODE: 3227 if (debug > 1) 3228 printf("Got set xfer mode\n"); 3229 break; 3230 default: 3231 panic("Unknown request: %d\n", (int)req); 3232 } 3233 } 3234 3235 static void 3236 sbp_minphys(struct buf *bp) 3237 { 3238 minphys(bp); 3239 } 3240 3241 CFATTACH_DECL(sbp, sizeof (struct sbp_softc), 3242 sbpmatch, sbpattach, sbpdetach, NULL); 3243 #endif 3244
Indexes created Wed Sep 24 15:09:51 GMT 2025