1 /* $OpenBSD: qla.c,v 1.56 2017/06/05 04:57:37 dlg Exp $ */ 2 3 /* 4 * Copyright (c) 2011 David Gwynne <dlg@openbsd.org> 5 * Copyright (c) 2013, 2014 Jonathan Matthew <jmatthew@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/param.h> 21 #include <sys/systm.h> 22 #include <sys/atomic.h> 23 #include <sys/device.h> 24 #include <sys/ioctl.h> 25 #include <sys/malloc.h> 26 #include <sys/kernel.h> 27 #include <sys/mutex.h> 28 #include <sys/rwlock.h> 29 #include <sys/sensors.h> 30 #include <sys/queue.h> 31 32 #include <machine/bus.h> 33 34 #include <scsi/scsi_all.h> 35 #include <scsi/scsiconf.h> 36 37 #include <dev/ic/qlareg.h> 38 #include <dev/ic/qlavar.h> 39 40 #ifdef QLA_DEBUG 41 #define DPRINTF(m, f...) do { if ((qladebug & (m)) == (m)) printf(f); } \ 42 while (0) 43 #define QLA_D_MBOX 0x01 44 #define QLA_D_INTR 0x02 45 #define QLA_D_PORT 0x04 46 #define QLA_D_IO 0x08 47 #define QLA_D_IOCB 0x10 48 int qladebug = QLA_D_PORT; 49 #else 50 #define DPRINTF(m, f...) 51 #endif 52 53 54 #ifndef ISP_NOFIRMWARE 55 #include <dev/microcode/isp/asm_2100.h> 56 #include <dev/microcode/isp/asm_2200.h> 57 #include <dev/microcode/isp/asm_2300.h> 58 #endif 59 60 struct cfdriver qla_cd = { 61 NULL, 62 "qla", 63 DV_DULL 64 }; 65 66 void qla_scsi_cmd(struct scsi_xfer *); 67 int qla_scsi_probe(struct scsi_link *); 68 69 u_int16_t qla_read(struct qla_softc *, bus_size_t); 70 void qla_write(struct qla_softc *, bus_size_t, u_int16_t); 71 void qla_host_cmd(struct qla_softc *sc, u_int16_t); 72 73 u_int16_t qla_read_queue_2100(struct qla_softc *, bus_size_t); 74 75 int qla_mbox(struct qla_softc *, int); 76 int qla_sns_req(struct qla_softc *, struct qla_dmamem *, int); 77 void qla_mbox_putaddr(u_int16_t *, struct qla_dmamem *); 78 u_int16_t qla_read_mbox(struct qla_softc *, int); 79 void qla_write_mbox(struct qla_softc *, int, u_int16_t); 80 81 void qla_handle_intr(struct qla_softc *, u_int16_t, u_int16_t); 82 void qla_set_ints(struct qla_softc *, int); 83 int qla_read_isr_1G(struct qla_softc *, u_int16_t *, u_int16_t *); 84 int qla_read_isr_2G(struct qla_softc *, u_int16_t *, u_int16_t *); 85 void qla_clear_isr(struct qla_softc *, u_int16_t); 86 87 void qla_update_start(struct qla_softc *, int); 88 void qla_update_done(struct qla_softc *, int); 89 void qla_do_update(void *); 90 91 void qla_put_marker(struct qla_softc *, void *); 92 void qla_put_cmd(struct qla_softc *, void *, struct scsi_xfer *, 93 struct qla_ccb *); 94 struct qla_ccb *qla_handle_resp(struct qla_softc *, u_int16_t); 95 96 int qla_get_port_name_list(struct qla_softc *, u_int32_t); 97 struct qla_fc_port *qla_next_fabric_port(struct qla_softc *, u_int32_t *, 98 u_int32_t *); 99 int qla_get_port_db(struct qla_softc *c, u_int16_t, 100 struct qla_dmamem *); 101 int qla_add_loop_port(struct qla_softc *, struct qla_fc_port *); 102 int qla_add_fabric_port(struct qla_softc *, struct qla_fc_port *); 103 int qla_add_logged_in_port(struct qla_softc *, int, u_int32_t); 104 int qla_classify_port(struct qla_softc *, u_int32_t, u_int64_t, 105 u_int64_t, struct qla_fc_port **); 106 int qla_get_loop_id(struct qla_softc *sc, int); 107 void qla_clear_port_lists(struct qla_softc *); 108 int qla_softreset(struct qla_softc *); 109 void qla_update_topology(struct qla_softc *); 110 int qla_update_fabric(struct qla_softc *); 111 int qla_fabric_plogi(struct qla_softc *, struct qla_fc_port *); 112 void qla_fabric_plogo(struct qla_softc *, struct qla_fc_port *); 113 114 void qla_update_start(struct qla_softc *, int); 115 int qla_async(struct qla_softc *, u_int16_t); 116 117 int qla_verify_firmware(struct qla_softc *sc, u_int16_t); 118 int qla_load_firmware_words(struct qla_softc *, const u_int16_t *, 119 u_int16_t); 120 int qla_load_firmware_2100(struct qla_softc *); 121 int qla_load_firmware_2200(struct qla_softc *); 122 int qla_load_fwchunk_2300(struct qla_softc *, 123 struct qla_dmamem *, const u_int16_t *, u_int32_t); 124 int qla_load_firmware_2300(struct qla_softc *); 125 int qla_load_firmware_2322(struct qla_softc *); 126 int qla_read_nvram(struct qla_softc *); 127 128 struct qla_dmamem *qla_dmamem_alloc(struct qla_softc *, size_t); 129 void qla_dmamem_free(struct qla_softc *, struct qla_dmamem *); 130 131 int qla_alloc_ccbs(struct qla_softc *); 132 void qla_free_ccbs(struct qla_softc *); 133 void *qla_get_ccb(void *); 134 void qla_put_ccb(void *, void *); 135 136 void qla_dump_iocb(struct qla_softc *, void *); 137 void qla_dump_iocb_segs(struct qla_softc *, void *, int); 138 139 static const struct qla_regs qla_regs_2100 = { 140 qla_read_queue_2100, 141 qla_read_isr_1G, 142 QLA_MBOX_BASE_2100 + 0x8, 143 QLA_MBOX_BASE_2100 + 0x8, 144 QLA_MBOX_BASE_2100 + 0xa, 145 QLA_MBOX_BASE_2100 + 0xa 146 }; 147 148 static const struct qla_regs qla_regs_2200 = { 149 qla_read, 150 qla_read_isr_1G, 151 QLA_MBOX_BASE_2200 + 0x8, 152 QLA_MBOX_BASE_2200 + 0x8, 153 QLA_MBOX_BASE_2200 + 0xa, 154 QLA_MBOX_BASE_2200 + 0xa 155 }; 156 157 static const struct qla_regs qla_regs_23XX = { 158 qla_read, 159 qla_read_isr_2G, 160 QLA_REQ_IN, 161 QLA_REQ_OUT, 162 QLA_RESP_IN, 163 QLA_RESP_OUT 164 }; 165 166 #define qla_queue_read(_sc, _r) ((*(_sc)->sc_regs->read)((_sc), (_r))) 167 #define qla_queue_write(_sc, _r, _v) qla_write((_sc), (_r), (_v)) 168 169 #define qla_read_isr(_sc, _isr, _info) \ 170 ((*(_sc)->sc_regs->read_isr)((_sc), (_isr), (_info))) 171 172 struct scsi_adapter qla_switch = { 173 qla_scsi_cmd, 174 scsi_minphys, 175 qla_scsi_probe, 176 NULL, /* scsi_free */ 177 NULL /* ioctl */ 178 }; 179 180 int 181 qla_classify_port(struct qla_softc *sc, u_int32_t location, 182 u_int64_t port_name, u_int64_t node_name, struct qla_fc_port **prev) 183 { 184 struct qla_fc_port *port, *locmatch, *wwnmatch; 185 locmatch = NULL; 186 wwnmatch = NULL; 187 188 /* make sure we don't try to add a port or location twice */ 189 TAILQ_FOREACH(port, &sc->sc_ports_new, update) { 190 if ((port->port_name == port_name && 191 port->node_name == node_name) || 192 port->location == location) { 193 *prev = port; 194 return (QLA_PORT_DISP_DUP); 195 } 196 } 197 198 /* if we're attaching, everything is new */ 199 if (sc->sc_scsibus == NULL) { 200 *prev = NULL; 201 return (QLA_PORT_DISP_NEW); 202 } 203 204 TAILQ_FOREACH(port, &sc->sc_ports, ports) { 205 if (port->location == location) 206 locmatch = port; 207 208 if (port->port_name == port_name && 209 port->node_name == node_name) 210 wwnmatch = port; 211 } 212 213 if (locmatch == NULL && wwnmatch == NULL) { 214 *prev = NULL; 215 return (QLA_PORT_DISP_NEW); 216 } else if (locmatch == wwnmatch) { 217 *prev = locmatch; 218 return (QLA_PORT_DISP_SAME); 219 } else if (wwnmatch != NULL) { 220 *prev = wwnmatch; 221 return (QLA_PORT_DISP_MOVED); 222 } else { 223 *prev = locmatch; 224 return (QLA_PORT_DISP_CHANGED); 225 } 226 } 227 228 int 229 qla_get_loop_id(struct qla_softc *sc, int start) 230 { 231 int i, last; 232 233 if (sc->sc_2k_logins) { 234 i = QLA_2KL_MIN_HANDLE; 235 last = QLA_2KL_MAX_HANDLE; 236 } else { 237 /* if we're an F port, we can have two ranges, but meh */ 238 i = QLA_MIN_HANDLE; 239 last = QLA_MAX_HANDLE; 240 } 241 if (i < start) 242 i = start; 243 244 for (; i <= last; i++) { 245 if (sc->sc_targets[i] == NULL) 246 return (i); 247 } 248 249 return (-1); 250 } 251 252 int 253 qla_get_port_db(struct qla_softc *sc, u_int16_t loopid, struct qla_dmamem *mem) 254 { 255 sc->sc_mbox[0] = QLA_MBOX_GET_PORT_DB; 256 if (sc->sc_2k_logins) { 257 sc->sc_mbox[1] = loopid; 258 } else { 259 sc->sc_mbox[1] = loopid << 8; 260 } 261 262 memset(QLA_DMA_KVA(mem), 0, sizeof(struct qla_get_port_db)); 263 qla_mbox_putaddr(sc->sc_mbox, mem); 264 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, 265 sizeof(struct qla_get_port_db), BUS_DMASYNC_PREREAD); 266 if (qla_mbox(sc, 0x00cf)) { 267 DPRINTF(QLA_D_PORT, "%s: get port db %d failed: %x\n", 268 DEVNAME(sc), loopid, sc->sc_mbox[0]); 269 return (1); 270 } 271 272 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, 273 sizeof(struct qla_get_port_db), BUS_DMASYNC_POSTREAD); 274 return (0); 275 } 276 277 int 278 qla_add_loop_port(struct qla_softc *sc, struct qla_fc_port *port) 279 { 280 struct qla_get_port_db *pdb; 281 struct qla_fc_port *pport = NULL; 282 int disp; 283 284 if (qla_get_port_db(sc, port->loopid, sc->sc_scratch)) { 285 return (1); 286 } 287 pdb = QLA_DMA_KVA(sc->sc_scratch); 288 289 if (letoh16(pdb->prli_svc_word3) & QLA_SVC3_TARGET_ROLE) 290 port->flags |= QLA_PORT_FLAG_IS_TARGET; 291 292 port->port_name = betoh64(pdb->port_name); 293 port->node_name = betoh64(pdb->node_name); 294 port->portid = (letoh16(pdb->port_id[0]) << 16) | 295 letoh16(pdb->port_id[1]); 296 297 mtx_enter(&sc->sc_port_mtx); 298 disp = qla_classify_port(sc, port->location, port->port_name, 299 port->node_name, &pport); 300 switch (disp) { 301 case QLA_PORT_DISP_CHANGED: 302 case QLA_PORT_DISP_MOVED: 303 case QLA_PORT_DISP_NEW: 304 TAILQ_INSERT_TAIL(&sc->sc_ports_new, port, update); 305 sc->sc_targets[port->loopid] = port; 306 break; 307 case QLA_PORT_DISP_DUP: 308 free(port, M_DEVBUF, sizeof *port); 309 break; 310 case QLA_PORT_DISP_SAME: 311 TAILQ_REMOVE(&sc->sc_ports_gone, pport, update); 312 free(port, M_DEVBUF, sizeof *port); 313 break; 314 } 315 mtx_leave(&sc->sc_port_mtx); 316 317 switch (disp) { 318 case QLA_PORT_DISP_CHANGED: 319 case QLA_PORT_DISP_MOVED: 320 case QLA_PORT_DISP_NEW: 321 DPRINTF(QLA_D_PORT, "%s: %s %d; name %llx, port %06x\n", 322 DEVNAME(sc), ISSET(port->flags, QLA_PORT_FLAG_IS_TARGET) ? 323 "target" : "non-target", port->loopid, port->port_name, 324 port->portid); 325 break; 326 } 327 return (0); 328 } 329 330 int 331 qla_add_fabric_port(struct qla_softc *sc, struct qla_fc_port *port) 332 { 333 struct qla_get_port_db *pdb; 334 335 if (qla_get_port_db(sc, port->loopid, sc->sc_scratch)) { 336 return (1); 337 } 338 pdb = QLA_DMA_KVA(sc->sc_scratch); 339 340 if (letoh16(pdb->prli_svc_word3) & QLA_SVC3_TARGET_ROLE) 341 port->flags |= QLA_PORT_FLAG_IS_TARGET; 342 343 /* 344 * if we only know about this port because qla_get_port_name_list 345 * returned it, we don't have its port id or node name, so fill 346 * those in and update its location. 347 */ 348 if (port->location == QLA_LOCATION_FABRIC) { 349 port->node_name = betoh64(pdb->node_name); 350 port->port_name = betoh64(pdb->port_name); 351 port->portid = (letoh16(pdb->port_id[0]) << 16) | 352 letoh16(pdb->port_id[1]); 353 port->location = QLA_LOCATION_PORT_ID(port->portid); 354 } 355 356 mtx_enter(&sc->sc_port_mtx); 357 TAILQ_INSERT_TAIL(&sc->sc_ports_new, port, update); 358 sc->sc_targets[port->loopid] = port; 359 mtx_leave(&sc->sc_port_mtx); 360 361 DPRINTF(QLA_D_PORT, "%s: %s %d; name %llx\n", 362 DEVNAME(sc), ISSET(port->flags, QLA_PORT_FLAG_IS_TARGET) ? 363 "target" : "non-target", port->loopid, port->port_name); 364 return (0); 365 } 366 367 int 368 qla_add_logged_in_port(struct qla_softc *sc, int loopid, u_int32_t portid) 369 { 370 struct qla_fc_port *port; 371 struct qla_get_port_db *pdb; 372 u_int64_t node_name, port_name; 373 int flags, ret; 374 375 ret = qla_get_port_db(sc, loopid, sc->sc_scratch); 376 mtx_enter(&sc->sc_port_mtx); 377 if (ret != 0) { 378 /* put in a fake port to prevent use of this loop id */ 379 printf("%s: loop id %d used, but can't see what's using it\n", 380 DEVNAME(sc), loopid); 381 node_name = 0; 382 port_name = 0; 383 flags = 0; 384 } else { 385 pdb = QLA_DMA_KVA(sc->sc_scratch); 386 node_name = betoh64(pdb->node_name); 387 port_name = betoh64(pdb->port_name); 388 flags = 0; 389 if (letoh16(pdb->prli_svc_word3) & QLA_SVC3_TARGET_ROLE) 390 flags |= QLA_PORT_FLAG_IS_TARGET; 391 392 /* see if we've already found this port */ 393 TAILQ_FOREACH(port, &sc->sc_ports_found, update) { 394 if ((port->node_name == node_name) && 395 (port->port_name == port_name) && 396 (port->portid == portid)) { 397 mtx_leave(&sc->sc_port_mtx); 398 DPRINTF(QLA_D_PORT, "%s: already found port " 399 "%06x\n", DEVNAME(sc), portid); 400 return (0); 401 } 402 } 403 } 404 405 port = malloc(sizeof(*port), M_DEVBUF, M_ZERO | M_NOWAIT); 406 if (port == NULL) { 407 mtx_leave(&sc->sc_port_mtx); 408 printf("%s: failed to allocate a port structure\n", 409 DEVNAME(sc)); 410 return (1); 411 } 412 port->location = QLA_LOCATION_PORT_ID(portid); 413 port->port_name = port_name; 414 port->node_name = node_name; 415 port->loopid = loopid; 416 port->portid = portid; 417 port->flags = flags; 418 419 TAILQ_INSERT_TAIL(&sc->sc_ports, port, ports); 420 sc->sc_targets[port->loopid] = port; 421 mtx_leave(&sc->sc_port_mtx); 422 423 DPRINTF(QLA_D_PORT, "%s: added logged in port %06x at %d\n", 424 DEVNAME(sc), portid, loopid); 425 return (0); 426 } 427 428 int 429 qla_attach(struct qla_softc *sc) 430 { 431 struct scsibus_attach_args saa; 432 struct qla_init_cb *icb; 433 #ifndef ISP_NOFIRMWARE 434 int (*loadfirmware)(struct qla_softc *) = NULL; 435 #endif 436 u_int16_t firmware_addr = 0; 437 u_int64_t dva; 438 int i, rv; 439 440 TAILQ_INIT(&sc->sc_ports); 441 TAILQ_INIT(&sc->sc_ports_new); 442 TAILQ_INIT(&sc->sc_ports_gone); 443 TAILQ_INIT(&sc->sc_ports_found); 444 445 switch (sc->sc_isp_gen) { 446 case QLA_GEN_ISP2100: 447 sc->sc_mbox_base = QLA_MBOX_BASE_2100; 448 sc->sc_regs = &qla_regs_2100; 449 #ifndef ISP_NOFIRMWARE 450 loadfirmware = qla_load_firmware_2100; 451 #endif 452 firmware_addr = QLA_2100_CODE_ORG; 453 break; 454 455 case QLA_GEN_ISP2200: 456 sc->sc_mbox_base = QLA_MBOX_BASE_2200; 457 sc->sc_regs = &qla_regs_2200; 458 #ifndef ISP_NOFIRMWARE 459 loadfirmware = qla_load_firmware_2200; 460 #endif 461 firmware_addr = QLA_2200_CODE_ORG; 462 break; 463 464 case QLA_GEN_ISP23XX: 465 sc->sc_mbox_base = QLA_MBOX_BASE_23XX; 466 sc->sc_regs = &qla_regs_23XX; 467 #ifndef ISP_NOFIRMWARE 468 if (sc->sc_isp_type != QLA_ISP2322) 469 loadfirmware = qla_load_firmware_2300; 470 #endif 471 firmware_addr = QLA_2300_CODE_ORG; 472 break; 473 474 default: 475 printf("unknown isp type\n"); 476 return (ENXIO); 477 } 478 479 /* after reset, mbox registers 1-3 should contain the string "ISP " */ 480 if (qla_read_mbox(sc, 1) != 0x4953 || 481 qla_read_mbox(sc, 2) != 0x5020 || 482 qla_read_mbox(sc, 3) != 0x2020) { 483 /* try releasing the risc processor */ 484 qla_host_cmd(sc, QLA_HOST_CMD_RELEASE); 485 } 486 487 qla_host_cmd(sc, QLA_HOST_CMD_PAUSE); 488 if (qla_softreset(sc) != 0) { 489 printf("softreset failed\n"); 490 return (ENXIO); 491 } 492 493 if (qla_read_nvram(sc) == 0) { 494 sc->sc_nvram_valid = 1; 495 if (sc->sc_port_name == 0) 496 sc->sc_port_name = betoh64(sc->sc_nvram.port_name); 497 if (sc->sc_node_name == 0) 498 sc->sc_node_name = betoh64(sc->sc_nvram.node_name); 499 } 500 501 if (sc->sc_port_name == 0) 502 sc->sc_port_name = QLA_DEFAULT_PORT_NAME; 503 504 #ifdef ISP_NOFIRMWARE 505 if (qla_verify_firmware(sc, firmware_addr)) { 506 printf("%s: no firmware loaded\n", DEVNAME(sc)); 507 return (ENXIO); 508 } 509 #else 510 if (loadfirmware && (loadfirmware)(sc)) { 511 printf("%s: firmware load failed\n", DEVNAME(sc)); 512 return (ENXIO); 513 } 514 #endif 515 516 /* execute firmware */ 517 sc->sc_mbox[0] = QLA_MBOX_EXEC_FIRMWARE; 518 sc->sc_mbox[1] = firmware_addr; 519 #ifdef ISP_NOFIRMWARE 520 sc->sc_mbox[2] = 1; 521 #else 522 if (loadfirmware) 523 sc->sc_mbox[2] = 0; 524 else 525 sc->sc_mbox[2] = 1; 526 #endif 527 if (qla_mbox(sc, 0x0007)) { 528 printf("ISP couldn't exec firmware: %x\n", sc->sc_mbox[0]); 529 return (ENXIO); 530 } 531 532 delay(250000); /* from isp(4) */ 533 534 sc->sc_mbox[0] = QLA_MBOX_ABOUT_FIRMWARE; 535 if (qla_mbox(sc, 0x0001)) { 536 printf("ISP not talking after firmware exec: %x\n", 537 sc->sc_mbox[0]); 538 return (ENXIO); 539 } 540 printf("%s: firmware rev %d.%d.%d, attrs 0x%x\n", DEVNAME(sc), 541 sc->sc_mbox[1], sc->sc_mbox[2], sc->sc_mbox[3], sc->sc_mbox[6]); 542 543 if (sc->sc_mbox[6] & QLA_FW_ATTR_EXPANDED_LUN) 544 sc->sc_expanded_lun = 1; 545 if (sc->sc_mbox[6] & QLA_FW_ATTR_FABRIC) 546 sc->sc_fabric = 1; 547 if (sc->sc_mbox[6] & QLA_FW_ATTR_2K_LOGINS) 548 sc->sc_2k_logins = 1; 549 550 /* work out how many ccbs to allocate */ 551 sc->sc_mbox[0] = QLA_MBOX_GET_FIRMWARE_STATUS; 552 if (qla_mbox(sc, 0x0001)) { 553 printf("couldn't get firmware status: %x\n", sc->sc_mbox[0]); 554 return (ENXIO); 555 } 556 sc->sc_maxcmds = sc->sc_mbox[2]; 557 558 if (qla_alloc_ccbs(sc)) { 559 /* error already printed */ 560 return (ENOMEM); 561 } 562 sc->sc_scratch = qla_dmamem_alloc(sc, QLA_SCRATCH_SIZE); 563 if (sc->sc_scratch == NULL) { 564 printf("%s: unable to allocate scratch\n", DEVNAME(sc)); 565 goto free_ccbs; 566 } 567 568 /* build init buffer thing */ 569 icb = (struct qla_init_cb *)QLA_DMA_KVA(sc->sc_scratch); 570 memset(icb, 0, sizeof(*icb)); 571 icb->icb_version = QLA_ICB_VERSION; 572 /* port and node names are big-endian in the icb */ 573 htobem32(&icb->icb_portname_hi, sc->sc_port_name >> 32); 574 htobem32(&icb->icb_portname_lo, sc->sc_port_name); 575 htobem32(&icb->icb_nodename_hi, sc->sc_node_name >> 32); 576 htobem32(&icb->icb_nodename_lo, sc->sc_node_name); 577 if (sc->sc_nvram_valid) { 578 icb->icb_fw_options = sc->sc_nvram.fw_options; 579 icb->icb_max_frame_len = sc->sc_nvram.frame_payload_size; 580 icb->icb_max_alloc = sc->sc_nvram.max_iocb_allocation; 581 icb->icb_exec_throttle = sc->sc_nvram.execution_throttle; 582 icb->icb_retry_count = sc->sc_nvram.retry_count; 583 icb->icb_retry_delay = sc->sc_nvram.retry_delay; 584 icb->icb_hardaddr = sc->sc_nvram.hard_address; 585 icb->icb_inquiry_data = sc->sc_nvram.inquiry_data; 586 icb->icb_login_timeout = sc->sc_nvram.login_timeout; 587 icb->icb_xfwoptions = sc->sc_nvram.add_fw_options; 588 icb->icb_zfwoptions = sc->sc_nvram.special_options; 589 } else { 590 /* defaults copied from isp(4) */ 591 icb->icb_retry_count = 3; 592 icb->icb_retry_delay = 5; 593 icb->icb_exec_throttle = htole16(16); 594 icb->icb_max_alloc = htole16(256); 595 icb->icb_max_frame_len = htole16(1024); 596 icb->icb_fw_options = htole16(QLA_ICB_FW_FAIRNESS | 597 QLA_ICB_FW_ENABLE_PDB_CHANGED | QLA_ICB_FW_HARD_ADDR | 598 QLA_ICB_FW_FULL_DUPLEX); 599 } 600 /* target mode stuff that we don't care about */ 601 icb->icb_lun_enables = 0; 602 icb->icb_cmd_count = 0; 603 icb->icb_notify_count = 0; 604 icb->icb_lun_timeout = 0; 605 606 /* "zero interrupt operation" */ 607 icb->icb_int_delaytimer = 0; 608 609 icb->icb_req_out = 0; 610 icb->icb_resp_in = 0; 611 htolem16(&icb->icb_req_queue_len, sc->sc_maxcmds); 612 htolem16(&icb->icb_resp_queue_len, sc->sc_maxcmds); 613 dva = QLA_DMA_DVA(sc->sc_requests); 614 htolem32(&icb->icb_req_queue_addr_lo, dva); 615 htolem32(&icb->icb_req_queue_addr_hi, dva >> 32); 616 dva = QLA_DMA_DVA(sc->sc_responses); 617 htolem32(&icb->icb_resp_queue_addr_lo, dva); 618 htolem32(&icb->icb_resp_queue_addr_hi, dva >> 32); 619 620 /* adjust firmware options a bit */ 621 icb->icb_fw_options |= htole16(QLA_ICB_FW_EXTENDED_INIT_CB); 622 icb->icb_fw_options &= ~htole16(QLA_ICB_FW_FAST_POST); 623 624 sc->sc_mbox[0] = QLA_MBOX_INIT_FIRMWARE; 625 sc->sc_mbox[4] = 0; 626 sc->sc_mbox[5] = 0; 627 qla_mbox_putaddr(sc->sc_mbox, sc->sc_scratch); 628 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 629 sizeof(*icb), BUS_DMASYNC_PREWRITE); 630 rv = qla_mbox(sc, 0x00fd); 631 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 632 sizeof(*icb), BUS_DMASYNC_POSTWRITE); 633 634 if (rv != 0) { 635 printf("%s: ISP firmware init failed: %x\n", DEVNAME(sc), 636 sc->sc_mbox[0]); 637 goto free_scratch; 638 } 639 640 /* enable some more notifications */ 641 sc->sc_mbox[0] = QLA_MBOX_SET_FIRMWARE_OPTIONS; 642 sc->sc_mbox[1] = QLA_FW_OPTION1_ASYNC_LIP_F8 | 643 QLA_FW_OPTION1_ASYNC_LIP_RESET | 644 QLA_FW_OPTION1_ASYNC_LIP_ERROR | 645 QLA_FW_OPTION1_ASYNC_LOGIN_RJT; 646 sc->sc_mbox[2] = 0; 647 sc->sc_mbox[3] = 0; 648 if (qla_mbox(sc, 0x000f)) { 649 printf("%s: setting firmware options failed: %x\n", 650 DEVNAME(sc), sc->sc_mbox[0]); 651 goto free_scratch; 652 } 653 654 sc->sc_update_taskq = taskq_create(DEVNAME(sc), 1, IPL_BIO, 0); 655 task_set(&sc->sc_update_task, qla_do_update, sc); 656 657 /* wait a bit for link to come up so we can scan and attach devices */ 658 for (i = 0; i < QLA_WAIT_FOR_LOOP * 10000; i++) { 659 u_int16_t isr, info; 660 661 delay(100); 662 663 if (qla_read_isr(sc, &isr, &info) == 0) 664 continue; 665 666 qla_handle_intr(sc, isr, info); 667 668 if (sc->sc_loop_up) 669 break; 670 } 671 672 if (sc->sc_loop_up) { 673 qla_do_update(sc); 674 } else { 675 DPRINTF(QLA_D_PORT, "%s: loop still down, giving up\n", 676 DEVNAME(sc)); 677 } 678 679 /* we should be good to go now, attach scsibus */ 680 sc->sc_link.adapter = &qla_switch; 681 sc->sc_link.adapter_softc = sc; 682 if (sc->sc_2k_logins) { 683 sc->sc_link.adapter_buswidth = QLA_2KL_BUSWIDTH; 684 } else { 685 sc->sc_link.adapter_buswidth = QLA_BUSWIDTH; 686 } 687 sc->sc_link.adapter_target = sc->sc_link.adapter_buswidth; 688 sc->sc_link.openings = sc->sc_maxcmds; 689 sc->sc_link.pool = &sc->sc_iopool; 690 sc->sc_link.port_wwn = sc->sc_port_name; 691 sc->sc_link.node_wwn = sc->sc_node_name; 692 if (sc->sc_link.node_wwn == 0) { 693 /* 694 * mask out the port number from the port name to get 695 * the node name. 696 */ 697 sc->sc_link.node_wwn = sc->sc_link.port_wwn; 698 sc->sc_link.node_wwn &= ~(0xfULL << 56); 699 } 700 701 memset(&saa, 0, sizeof(saa)); 702 saa.saa_sc_link = &sc->sc_link; 703 704 /* config_found() returns the scsibus attached to us */ 705 sc->sc_scsibus = (struct scsibus_softc *)config_found(&sc->sc_dev, 706 &saa, scsiprint); 707 708 return(0); 709 710 free_scratch: 711 qla_dmamem_free(sc, sc->sc_scratch); 712 free_ccbs: 713 qla_free_ccbs(sc); 714 return (ENXIO); 715 } 716 717 int 718 qla_detach(struct qla_softc *sc, int flags) 719 { 720 return (0); 721 } 722 723 struct qla_ccb * 724 qla_handle_resp(struct qla_softc *sc, u_int16_t id) 725 { 726 struct qla_ccb *ccb; 727 struct qla_iocb_status *status; 728 struct scsi_xfer *xs; 729 u_int32_t handle; 730 u_int8_t *entry; 731 732 ccb = NULL; 733 entry = QLA_DMA_KVA(sc->sc_responses) + (id * QLA_QUEUE_ENTRY_SIZE); 734 735 bus_dmamap_sync(sc->sc_dmat, 736 QLA_DMA_MAP(sc->sc_responses), id * QLA_QUEUE_ENTRY_SIZE, 737 QLA_QUEUE_ENTRY_SIZE, BUS_DMASYNC_POSTREAD); 738 739 qla_dump_iocb(sc, entry); 740 switch (entry[0]) { 741 case QLA_IOCB_STATUS: 742 status = (struct qla_iocb_status *)entry; 743 handle = status->handle; 744 if (handle > sc->sc_maxcmds) { 745 panic("bad completed command handle: %d (> %d)", 746 handle, sc->sc_maxcmds); 747 } 748 749 ccb = &sc->sc_ccbs[handle]; 750 xs = ccb->ccb_xs; 751 if (xs == NULL) { 752 DPRINTF(QLA_D_INTR, "%s: got status for inactive" 753 " ccb %d\n", DEVNAME(sc), handle); 754 ccb = NULL; 755 break; 756 } 757 if (xs->io != ccb) { 758 panic("completed command handle doesn't match xs " 759 "(handle %d, ccb %p, xs->io %p)", handle, ccb, 760 xs->io); 761 } 762 763 if (xs->datalen > 0) { 764 if (ccb->ccb_dmamap->dm_nsegs > 765 QLA_IOCB_SEGS_PER_CMD) { 766 bus_dmamap_sync(sc->sc_dmat, 767 QLA_DMA_MAP(sc->sc_segments), 768 ccb->ccb_seg_offset, 769 sizeof(*ccb->ccb_t4segs) * 770 ccb->ccb_dmamap->dm_nsegs, 771 BUS_DMASYNC_POSTWRITE); 772 } 773 774 bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0, 775 ccb->ccb_dmamap->dm_mapsize, 776 (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD : 777 BUS_DMASYNC_POSTWRITE); 778 bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap); 779 } 780 781 xs->status = letoh16(status->scsi_status); 782 switch (letoh16(status->completion)) { 783 case QLA_IOCB_STATUS_COMPLETE: 784 if (letoh16(status->scsi_status) & 785 QLA_SCSI_STATUS_SENSE_VALID) { 786 memcpy(&xs->sense, status->sense_data, 787 sizeof(xs->sense)); 788 xs->error = XS_SENSE; 789 } else { 790 xs->error = XS_NOERROR; 791 } 792 xs->resid = 0; 793 break; 794 795 case QLA_IOCB_STATUS_DMA_ERROR: 796 DPRINTF(QLA_D_INTR, "%s: dma error\n", DEVNAME(sc)); 797 /* set resid apparently? */ 798 break; 799 800 case QLA_IOCB_STATUS_RESET: 801 DPRINTF(QLA_D_IO, "%s: reset destroyed command\n", 802 DEVNAME(sc)); 803 sc->sc_marker_required = 1; 804 xs->error = XS_RESET; 805 break; 806 807 case QLA_IOCB_STATUS_ABORTED: 808 DPRINTF(QLA_D_IO, "%s: aborted\n", DEVNAME(sc)); 809 sc->sc_marker_required = 1; 810 xs->error = XS_DRIVER_STUFFUP; 811 break; 812 813 case QLA_IOCB_STATUS_TIMEOUT: 814 DPRINTF(QLA_D_IO, "%s: command timed out\n", 815 DEVNAME(sc)); 816 xs->error = XS_TIMEOUT; 817 break; 818 819 case QLA_IOCB_STATUS_DATA_OVERRUN: 820 case QLA_IOCB_STATUS_DATA_UNDERRUN: 821 xs->resid = letoh32(status->resid); 822 xs->error = XS_NOERROR; 823 break; 824 825 case QLA_IOCB_STATUS_QUEUE_FULL: 826 DPRINTF(QLA_D_IO, "%s: queue full\n", DEVNAME(sc)); 827 xs->error = XS_BUSY; 828 break; 829 830 case QLA_IOCB_STATUS_PORT_UNAVAIL: 831 case QLA_IOCB_STATUS_PORT_LOGGED_OUT: 832 case QLA_IOCB_STATUS_PORT_CHANGED: 833 DPRINTF(QLA_D_IO, "%s: dev gone\n", DEVNAME(sc)); 834 xs->error = XS_SELTIMEOUT; 835 break; 836 837 default: 838 DPRINTF(QLA_D_INTR, "%s: unexpected completion" 839 " status %x\n", DEVNAME(sc), status->completion); 840 xs->error = XS_DRIVER_STUFFUP; 841 break; 842 } 843 break; 844 845 case QLA_IOCB_STATUS_CONT: 846 DPRINTF(QLA_D_INTR, "%s: ignoring status continuation iocb\n", 847 DEVNAME(sc)); 848 break; 849 850 /* check for requests that bounce back? */ 851 default: 852 DPRINTF(QLA_D_INTR, "%s: unexpected response entry type %x\n", 853 DEVNAME(sc), entry[0]); 854 break; 855 } 856 857 return (ccb); 858 } 859 860 void 861 qla_handle_intr(struct qla_softc *sc, u_int16_t isr, u_int16_t info) 862 { 863 int i; 864 u_int16_t rspin; 865 struct qla_ccb *ccb; 866 867 switch (isr) { 868 case QLA_INT_TYPE_ASYNC: 869 qla_async(sc, info); 870 break; 871 872 case QLA_INT_TYPE_IO: 873 rspin = qla_queue_read(sc, sc->sc_regs->res_in); 874 if (rspin == sc->sc_last_resp_id) { 875 /* seems to happen a lot on 2200s when mbox commands 876 * complete but it doesn't want to give us the register 877 * semaphore, or something. 878 * 879 * if we're waiting on a mailbox command, don't ack 880 * the interrupt yet. 881 */ 882 if (sc->sc_mbox_pending) { 883 DPRINTF(QLA_D_MBOX, "%s: ignoring premature" 884 " mbox int\n", DEVNAME(sc)); 885 return; 886 } 887 888 break; 889 } 890 891 if (sc->sc_responses == NULL) 892 break; 893 894 DPRINTF(QLA_D_IO, "%s: response queue %x=>%x\n", 895 DEVNAME(sc), sc->sc_last_resp_id, rspin); 896 897 do { 898 ccb = qla_handle_resp(sc, sc->sc_last_resp_id); 899 if (ccb) 900 scsi_done(ccb->ccb_xs); 901 902 sc->sc_last_resp_id++; 903 sc->sc_last_resp_id %= sc->sc_maxcmds; 904 } while (sc->sc_last_resp_id != rspin); 905 906 qla_queue_write(sc, sc->sc_regs->res_out, rspin); 907 break; 908 909 case QLA_INT_TYPE_MBOX: 910 mtx_enter(&sc->sc_mbox_mtx); 911 if (sc->sc_mbox_pending) { 912 DPRINTF(QLA_D_MBOX, "%s: mbox response %x\n", 913 DEVNAME(sc), info); 914 for (i = 0; i < nitems(sc->sc_mbox); i++) { 915 sc->sc_mbox[i] = qla_read_mbox(sc, i); 916 } 917 sc->sc_mbox_pending = 2; 918 wakeup(sc->sc_mbox); 919 mtx_leave(&sc->sc_mbox_mtx); 920 } else { 921 mtx_leave(&sc->sc_mbox_mtx); 922 DPRINTF(QLA_D_MBOX, "%s: unexpected mbox interrupt:" 923 " %x\n", DEVNAME(sc), info); 924 } 925 break; 926 927 default: 928 /* maybe log something? */ 929 break; 930 } 931 932 qla_clear_isr(sc, isr); 933 } 934 935 int 936 qla_intr(void *xsc) 937 { 938 struct qla_softc *sc = xsc; 939 u_int16_t isr; 940 u_int16_t info; 941 942 if (qla_read_isr(sc, &isr, &info) == 0) 943 return (0); 944 945 qla_handle_intr(sc, isr, info); 946 return (1); 947 } 948 949 int 950 qla_scsi_probe(struct scsi_link *link) 951 { 952 struct qla_softc *sc = link->adapter_softc; 953 int rv = 0; 954 955 mtx_enter(&sc->sc_port_mtx); 956 if (sc->sc_targets[link->target] == NULL) 957 rv = ENXIO; 958 else if (!ISSET(sc->sc_targets[link->target]->flags, 959 QLA_PORT_FLAG_IS_TARGET)) 960 rv = ENXIO; 961 else { 962 link->port_wwn = sc->sc_targets[link->target]->port_name; 963 link->node_wwn = sc->sc_targets[link->target]->node_name; 964 } 965 mtx_leave(&sc->sc_port_mtx); 966 967 return (rv); 968 } 969 970 void 971 qla_scsi_cmd(struct scsi_xfer *xs) 972 { 973 struct scsi_link *link = xs->sc_link; 974 struct qla_softc *sc = link->adapter_softc; 975 struct qla_ccb *ccb; 976 struct qla_iocb_req34 *iocb; 977 struct qla_ccb_list list; 978 u_int16_t req, rspin; 979 int offset, error, done; 980 bus_dmamap_t dmap; 981 982 if (xs->cmdlen > sizeof(iocb->req_cdb)) { 983 DPRINTF(QLA_D_IO, "%s: cdb too big (%d)\n", DEVNAME(sc), 984 xs->cmdlen); 985 memset(&xs->sense, 0, sizeof(xs->sense)); 986 xs->sense.error_code = SSD_ERRCODE_VALID | SSD_ERRCODE_CURRENT; 987 xs->sense.flags = SKEY_ILLEGAL_REQUEST; 988 xs->sense.add_sense_code = 0x20; 989 xs->error = XS_SENSE; 990 scsi_done(xs); 991 return; 992 } 993 994 ccb = xs->io; 995 dmap = ccb->ccb_dmamap; 996 if (xs->datalen > 0) { 997 error = bus_dmamap_load(sc->sc_dmat, dmap, xs->data, 998 xs->datalen, NULL, (xs->flags & SCSI_NOSLEEP) ? 999 BUS_DMA_NOWAIT : BUS_DMA_WAITOK); 1000 if (error) { 1001 xs->error = XS_DRIVER_STUFFUP; 1002 scsi_done(xs); 1003 return; 1004 } 1005 1006 bus_dmamap_sync(sc->sc_dmat, dmap, 0, 1007 dmap->dm_mapsize, 1008 (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD : 1009 BUS_DMASYNC_PREWRITE); 1010 } 1011 1012 mtx_enter(&sc->sc_queue_mtx); 1013 1014 /* put in a sync marker if required */ 1015 if (sc->sc_marker_required) { 1016 req = sc->sc_next_req_id++; 1017 if (sc->sc_next_req_id == sc->sc_maxcmds) 1018 sc->sc_next_req_id = 0; 1019 1020 DPRINTF(QLA_D_IO, "%s: writing marker at request %d\n", 1021 DEVNAME(sc), req); 1022 offset = (req * QLA_QUEUE_ENTRY_SIZE); 1023 iocb = QLA_DMA_KVA(sc->sc_requests) + offset; 1024 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_requests), 1025 offset, QLA_QUEUE_ENTRY_SIZE, BUS_DMASYNC_POSTWRITE); 1026 qla_put_marker(sc, iocb); 1027 qla_queue_write(sc, sc->sc_regs->req_in, sc->sc_next_req_id); 1028 sc->sc_marker_required = 0; 1029 } 1030 1031 req = sc->sc_next_req_id++; 1032 if (sc->sc_next_req_id == sc->sc_maxcmds) 1033 sc->sc_next_req_id = 0; 1034 1035 offset = (req * QLA_QUEUE_ENTRY_SIZE); 1036 iocb = QLA_DMA_KVA(sc->sc_requests) + offset; 1037 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_requests), offset, 1038 QLA_QUEUE_ENTRY_SIZE, BUS_DMASYNC_POSTWRITE); 1039 1040 ccb->ccb_xs = xs; 1041 1042 DPRINTF(QLA_D_IO, "%s: writing cmd at request %d\n", DEVNAME(sc), req); 1043 qla_put_cmd(sc, iocb, xs, ccb); 1044 1045 qla_queue_write(sc, sc->sc_regs->req_in, sc->sc_next_req_id); 1046 1047 if (!ISSET(xs->flags, SCSI_POLL)) { 1048 mtx_leave(&sc->sc_queue_mtx); 1049 return; 1050 } 1051 1052 done = 0; 1053 SIMPLEQ_INIT(&list); 1054 do { 1055 u_int16_t isr, info; 1056 1057 delay(100); 1058 1059 if (qla_read_isr(sc, &isr, &info) == 0) { 1060 continue; 1061 } 1062 1063 if (isr != QLA_INT_TYPE_IO) { 1064 qla_handle_intr(sc, isr, info); 1065 continue; 1066 } 1067 1068 rspin = qla_queue_read(sc, sc->sc_regs->res_in); 1069 while (rspin != sc->sc_last_resp_id) { 1070 ccb = qla_handle_resp(sc, sc->sc_last_resp_id); 1071 1072 sc->sc_last_resp_id++; 1073 if (sc->sc_last_resp_id == sc->sc_maxcmds) 1074 sc->sc_last_resp_id = 0; 1075 1076 if (ccb != NULL) 1077 SIMPLEQ_INSERT_TAIL(&list, ccb, ccb_link); 1078 if (ccb == xs->io) 1079 done = 1; 1080 } 1081 qla_queue_write(sc, sc->sc_regs->res_out, rspin); 1082 qla_clear_isr(sc, isr); 1083 } while (done == 0); 1084 1085 mtx_leave(&sc->sc_queue_mtx); 1086 1087 while ((ccb = SIMPLEQ_FIRST(&list)) != NULL) { 1088 SIMPLEQ_REMOVE_HEAD(&list, ccb_link); 1089 scsi_done(ccb->ccb_xs); 1090 } 1091 } 1092 1093 u_int16_t 1094 qla_read(struct qla_softc *sc, bus_size_t offset) 1095 { 1096 u_int16_t v; 1097 v = bus_space_read_2(sc->sc_iot, sc->sc_ioh, offset); 1098 bus_space_barrier(sc->sc_iot, sc->sc_ioh, offset, 2, 1099 BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE); 1100 return (v); 1101 } 1102 1103 void 1104 qla_write(struct qla_softc *sc, bus_size_t offset, u_int16_t value) 1105 { 1106 bus_space_write_2(sc->sc_iot, sc->sc_ioh, offset, value); 1107 bus_space_barrier(sc->sc_iot, sc->sc_ioh, offset, 2, 1108 BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE); 1109 } 1110 1111 u_int16_t 1112 qla_read_mbox(struct qla_softc *sc, int mbox) 1113 { 1114 /* could range-check mboxes according to chip type? */ 1115 return (qla_read(sc, sc->sc_mbox_base + (mbox * 2))); 1116 } 1117 1118 void 1119 qla_write_mbox(struct qla_softc *sc, int mbox, u_int16_t value) 1120 { 1121 qla_write(sc, sc->sc_mbox_base + (mbox * 2), value); 1122 } 1123 1124 void 1125 qla_host_cmd(struct qla_softc *sc, u_int16_t cmd) 1126 { 1127 qla_write(sc, QLA_HOST_CMD_CTRL, cmd << QLA_HOST_CMD_SHIFT); 1128 } 1129 1130 #define MBOX_COMMAND_TIMEOUT 4000 1131 1132 int 1133 qla_mbox(struct qla_softc *sc, int maskin) 1134 { 1135 int i; 1136 int result = 0; 1137 int rv; 1138 1139 sc->sc_mbox_pending = 1; 1140 for (i = 0; i < nitems(sc->sc_mbox); i++) { 1141 if (maskin & (1 << i)) { 1142 qla_write_mbox(sc, i, sc->sc_mbox[i]); 1143 } 1144 } 1145 qla_host_cmd(sc, QLA_HOST_CMD_SET_HOST_INT); 1146 1147 if (sc->sc_scsibus != NULL) { 1148 mtx_enter(&sc->sc_mbox_mtx); 1149 sc->sc_mbox_pending = 1; 1150 while (sc->sc_mbox_pending == 1) { 1151 msleep(sc->sc_mbox, &sc->sc_mbox_mtx, PRIBIO, 1152 "qlambox", 0); 1153 } 1154 result = sc->sc_mbox[0]; 1155 sc->sc_mbox_pending = 0; 1156 mtx_leave(&sc->sc_mbox_mtx); 1157 return (result == QLA_MBOX_COMPLETE ? 0 : result); 1158 } 1159 1160 for (i = 0; i < MBOX_COMMAND_TIMEOUT && result == 0; i++) { 1161 u_int16_t isr, info; 1162 1163 delay(100); 1164 1165 if (qla_read_isr(sc, &isr, &info) == 0) 1166 continue; 1167 1168 switch (isr) { 1169 case QLA_INT_TYPE_MBOX: 1170 result = info; 1171 break; 1172 1173 default: 1174 qla_handle_intr(sc, isr, info); 1175 break; 1176 } 1177 } 1178 1179 if (result == 0) { 1180 /* timed out; do something? */ 1181 DPRINTF(QLA_D_MBOX, "%s: mbox timed out\n", DEVNAME(sc)); 1182 rv = 1; 1183 } else { 1184 for (i = 0; i < nitems(sc->sc_mbox); i++) { 1185 sc->sc_mbox[i] = qla_read_mbox(sc, i); 1186 } 1187 rv = (result == QLA_MBOX_COMPLETE ? 0 : result); 1188 } 1189 1190 qla_clear_isr(sc, QLA_INT_TYPE_MBOX); 1191 sc->sc_mbox_pending = 0; 1192 return (rv); 1193 } 1194 1195 void 1196 qla_mbox_putaddr(u_int16_t *mbox, struct qla_dmamem *mem) 1197 { 1198 mbox[2] = (QLA_DMA_DVA(mem) >> 16) & 0xffff; 1199 mbox[3] = (QLA_DMA_DVA(mem) >> 0) & 0xffff; 1200 mbox[6] = (QLA_DMA_DVA(mem) >> 48) & 0xffff; 1201 mbox[7] = (QLA_DMA_DVA(mem) >> 32) & 0xffff; 1202 } 1203 1204 int 1205 qla_sns_req(struct qla_softc *sc, struct qla_dmamem *mem, int reqsize) 1206 { 1207 struct qla_sns_req_hdr *header; 1208 uint64_t dva; 1209 int rv; 1210 1211 memset(&sc->sc_mbox, 0, sizeof(sc->sc_mbox)); 1212 sc->sc_mbox[0] = QLA_MBOX_SEND_SNS; 1213 sc->sc_mbox[1] = reqsize / 2; 1214 qla_mbox_putaddr(sc->sc_mbox, mem); 1215 1216 header = QLA_DMA_KVA(mem); 1217 htolem16(&header->resp_len, (QLA_DMA_LEN(mem) - reqsize) / 2); 1218 dva = QLA_DMA_DVA(mem) + reqsize; 1219 htolem32(&header->resp_addr_lo, dva); 1220 htolem32(&header->resp_addr_hi, dva >> 32); 1221 header->subcmd_len = htole16((reqsize - sizeof(*header)) / 2); 1222 1223 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, QLA_DMA_LEN(mem), 1224 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 1225 rv = qla_mbox(sc, 0x00cf); 1226 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, QLA_DMA_LEN(mem), 1227 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 1228 1229 return (rv); 1230 } 1231 1232 void 1233 qla_set_ints(struct qla_softc *sc, int enabled) 1234 { 1235 u_int16_t v = enabled ? (QLA_INT_REQ | QLA_RISC_INT_REQ) : 0; 1236 qla_write(sc, QLA_INT_CTRL, v); 1237 } 1238 1239 int 1240 qla_read_isr_1G(struct qla_softc *sc, u_int16_t *isr, u_int16_t *info) 1241 { 1242 u_int16_t int_status; 1243 1244 if (qla_read(sc, QLA_SEMA) & QLA_SEMA_LOCK) { 1245 *info = qla_read_mbox(sc, 0); 1246 if (*info & QLA_MBOX_HAS_STATUS) 1247 *isr = QLA_INT_TYPE_MBOX; 1248 else 1249 *isr = QLA_INT_TYPE_ASYNC; 1250 } else { 1251 int_status = qla_read(sc, QLA_INT_STATUS); 1252 if ((int_status & QLA_INT_REQ) == 0) 1253 return (0); 1254 1255 *isr = QLA_INT_TYPE_IO; 1256 } 1257 1258 return (1); 1259 } 1260 1261 int 1262 qla_read_isr_2G(struct qla_softc *sc, u_int16_t *isr, u_int16_t *info) 1263 { 1264 u_int32_t v; 1265 1266 if ((qla_read(sc, QLA_INT_STATUS) & QLA_INT_REQ) == 0) 1267 return (0); 1268 1269 v = bus_space_read_4(sc->sc_iot, sc->sc_ioh, QLA_RISC_STATUS_LOW); 1270 bus_space_barrier(sc->sc_iot, sc->sc_ioh, QLA_RISC_STATUS_LOW, 1271 4, BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE); 1272 1273 switch (v & QLA_INT_STATUS_MASK) { 1274 case QLA_23XX_INT_ROM_MBOX: 1275 case QLA_23XX_INT_ROM_MBOX_FAIL: 1276 case QLA_23XX_INT_MBOX: 1277 case QLA_23XX_INT_MBOX_FAIL: 1278 *isr = QLA_INT_TYPE_MBOX; 1279 break; 1280 1281 case QLA_23XX_INT_ASYNC: 1282 *isr = QLA_INT_TYPE_ASYNC; 1283 break; 1284 1285 case QLA_23XX_INT_RSPQ: 1286 *isr = QLA_INT_TYPE_IO; 1287 break; 1288 1289 default: 1290 *isr = QLA_INT_TYPE_OTHER; 1291 break; 1292 } 1293 1294 *info = (v >> QLA_INT_INFO_SHIFT); 1295 1296 return (1); 1297 } 1298 1299 void 1300 qla_clear_isr(struct qla_softc *sc, u_int16_t isr) 1301 { 1302 qla_host_cmd(sc, QLA_HOST_CMD_CLR_RISC_INT); 1303 switch (isr) { 1304 case QLA_INT_TYPE_MBOX: 1305 case QLA_INT_TYPE_ASYNC: 1306 qla_write(sc, QLA_SEMA, 0); 1307 break; 1308 default: 1309 break; 1310 } 1311 } 1312 1313 u_int16_t 1314 qla_read_queue_2100(struct qla_softc *sc, bus_size_t queue) 1315 { 1316 u_int16_t a, b, i; 1317 1318 for (i = 0; i < 1000; i++) { 1319 a = qla_read(sc, queue); 1320 b = qla_read(sc, queue); 1321 1322 if (a == b) 1323 return (a); 1324 } 1325 1326 DPRINTF(QLA_D_INTR, "%s: queue ptr unstable\n", DEVNAME(sc)); 1327 1328 return (a); 1329 } 1330 1331 int 1332 qla_softreset(struct qla_softc *sc) 1333 { 1334 int i; 1335 qla_set_ints(sc, 0); 1336 1337 /* reset */ 1338 qla_write(sc, QLA_CTRL_STATUS, QLA_CTRL_RESET); 1339 delay(100); 1340 /* clear data and control dma engines? */ 1341 1342 /* wait for soft reset to clear */ 1343 for (i = 0; i < 1000; i++) { 1344 if ((qla_read(sc, QLA_CTRL_STATUS) & QLA_CTRL_RESET) == 0) 1345 break; 1346 1347 delay(100); 1348 } 1349 1350 if (i == 1000) { 1351 DPRINTF(QLA_D_INTR, "%s: reset didn't clear\n", DEVNAME(sc)); 1352 qla_set_ints(sc, 0); 1353 return (ENXIO); 1354 } 1355 1356 /* reset FPM */ 1357 qla_write(sc, QLA_CTRL_STATUS, QLA_CTRL_FPM0_REGS); 1358 qla_write(sc, QLA_FPM_DIAG, QLA_FPM_RESET); 1359 qla_write(sc, QLA_FPM_DIAG, 0); /* isp(4) doesn't do this? */ 1360 qla_write(sc, QLA_CTRL_STATUS, QLA_CTRL_RISC_REGS); 1361 1362 /* reset risc processor */ 1363 qla_host_cmd(sc, QLA_HOST_CMD_RESET); 1364 delay(100); 1365 qla_write(sc, QLA_SEMA, 0); 1366 qla_host_cmd(sc, QLA_HOST_CMD_MASK_PARITY); /* from isp(4) */ 1367 qla_host_cmd(sc, QLA_HOST_CMD_RELEASE); 1368 1369 /* reset queue pointers */ 1370 qla_queue_write(sc, sc->sc_regs->req_in, 0); 1371 qla_queue_write(sc, sc->sc_regs->req_out, 0); 1372 qla_queue_write(sc, sc->sc_regs->res_in, 0); 1373 qla_queue_write(sc, sc->sc_regs->res_out, 0); 1374 1375 qla_set_ints(sc, 1); 1376 /* isp(4) sends QLA_HOST_CMD_BIOS here.. not documented? */ 1377 1378 /* do a basic mailbox operation to check we're alive */ 1379 sc->sc_mbox[0] = QLA_MBOX_NOP; 1380 if (qla_mbox(sc, 0x0001)) { 1381 DPRINTF(QLA_D_INTR, "%s: ISP not responding after reset\n", 1382 DEVNAME(sc)); 1383 return (ENXIO); 1384 } 1385 1386 return (0); 1387 } 1388 1389 void 1390 qla_update_topology(struct qla_softc *sc) 1391 { 1392 sc->sc_mbox[0] = QLA_MBOX_GET_LOOP_ID; 1393 if (qla_mbox(sc, 0x0001)) { 1394 DPRINTF(QLA_D_PORT, "%s: unable to get loop id\n", DEVNAME(sc)); 1395 sc->sc_topology = QLA_TOPO_N_PORT_NO_TARGET; 1396 } else { 1397 sc->sc_topology = sc->sc_mbox[6]; 1398 sc->sc_loop_id = sc->sc_mbox[1]; 1399 1400 switch (sc->sc_topology) { 1401 case QLA_TOPO_NL_PORT: 1402 case QLA_TOPO_N_PORT: 1403 DPRINTF(QLA_D_PORT, "%s: loop id %d\n", DEVNAME(sc), 1404 sc->sc_loop_id); 1405 break; 1406 1407 case QLA_TOPO_FL_PORT: 1408 case QLA_TOPO_F_PORT: 1409 sc->sc_port_id = sc->sc_mbox[2] | 1410 (sc->sc_mbox[3] << 16); 1411 DPRINTF(QLA_D_PORT, "%s: fabric port id %06x\n", 1412 DEVNAME(sc), sc->sc_port_id); 1413 break; 1414 1415 case QLA_TOPO_N_PORT_NO_TARGET: 1416 default: 1417 DPRINTF(QLA_D_PORT, "%s: not connected\n", DEVNAME(sc)); 1418 break; 1419 } 1420 1421 switch (sc->sc_topology) { 1422 case QLA_TOPO_NL_PORT: 1423 case QLA_TOPO_FL_PORT: 1424 sc->sc_loop_max_id = 126; 1425 break; 1426 1427 case QLA_TOPO_N_PORT: 1428 sc->sc_loop_max_id = 2; 1429 break; 1430 1431 default: 1432 sc->sc_loop_max_id = 0; 1433 break; 1434 } 1435 } 1436 } 1437 1438 int 1439 qla_update_fabric(struct qla_softc *sc) 1440 { 1441 struct qla_sns_rft_id *rft; 1442 1443 if (sc->sc_fabric == 0) 1444 return (0); 1445 1446 switch (sc->sc_topology) { 1447 case QLA_TOPO_F_PORT: 1448 case QLA_TOPO_FL_PORT: 1449 break; 1450 1451 default: 1452 return (0); 1453 } 1454 1455 /* get the name server's port db entry */ 1456 sc->sc_mbox[0] = QLA_MBOX_GET_PORT_DB; 1457 if (sc->sc_2k_logins) { 1458 sc->sc_mbox[1] = QLA_F_PORT_HANDLE; 1459 } else { 1460 sc->sc_mbox[1] = QLA_F_PORT_HANDLE << 8; 1461 } 1462 qla_mbox_putaddr(sc->sc_mbox, sc->sc_scratch); 1463 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 1464 sizeof(struct qla_get_port_db), BUS_DMASYNC_PREREAD); 1465 if (qla_mbox(sc, 0x00cf)) { 1466 DPRINTF(QLA_D_PORT, "%s: get port db for SNS failed: %x\n", 1467 DEVNAME(sc), sc->sc_mbox[0]); 1468 sc->sc_sns_port_name = 0; 1469 } else { 1470 struct qla_get_port_db *pdb; 1471 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 1472 sizeof(struct qla_get_port_db), BUS_DMASYNC_POSTREAD); 1473 pdb = QLA_DMA_KVA(sc->sc_scratch); 1474 DPRINTF(QLA_D_PORT, "%s: SNS port name %llx\n", DEVNAME(sc), 1475 betoh64(pdb->port_name)); 1476 sc->sc_sns_port_name = betoh64(pdb->port_name); 1477 } 1478 1479 /* 1480 * register fc4 types with the fabric 1481 * some switches do this automatically, but apparently 1482 * some don't. 1483 */ 1484 rft = QLA_DMA_KVA(sc->sc_scratch); 1485 memset(rft, 0, sizeof(*rft) + sizeof(struct qla_sns_req_hdr)); 1486 rft->subcmd = htole16(QLA_SNS_RFT_ID); 1487 rft->max_word = htole16(sizeof(struct qla_sns_req_hdr) / 4); 1488 rft->port_id = htole32(sc->sc_port_id); 1489 rft->fc4_types[0] = htole32(1 << QLA_FC4_SCSI); 1490 if (qla_sns_req(sc, sc->sc_scratch, sizeof(*rft))) { 1491 DPRINTF(QLA_D_PORT, "%s: RFT_ID failed\n", DEVNAME(sc)); 1492 /* we might be able to continue after this fails */ 1493 } 1494 1495 return (1); 1496 } 1497 1498 int 1499 qla_get_port_name_list(struct qla_softc *sc, u_int32_t match) 1500 { 1501 int i; 1502 struct qla_port_name_list *l; 1503 struct qla_fc_port *port; 1504 1505 sc->sc_mbox[0] = QLA_MBOX_GET_PORT_NAME_LIST; 1506 sc->sc_mbox[1] = 0x08; /* include initiators */ 1507 if (match & QLA_LOCATION_FABRIC) 1508 sc->sc_mbox[1] |= 0x02; /* return all loop ids */ 1509 qla_mbox_putaddr(sc->sc_mbox, sc->sc_scratch); 1510 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 1511 QLA_DMA_LEN(sc->sc_scratch), BUS_DMASYNC_PREREAD); 1512 if (qla_mbox(sc, 0x04f)) { 1513 DPRINTF(QLA_D_PORT, "%s: get port name list failed: %x\n", 1514 DEVNAME(sc), sc->sc_mbox[0]); 1515 return (1); 1516 } 1517 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(sc->sc_scratch), 0, 1518 QLA_DMA_LEN(sc->sc_scratch), BUS_DMASYNC_PREREAD); 1519 1520 i = 0; 1521 l = QLA_DMA_KVA(sc->sc_scratch); 1522 mtx_enter(&sc->sc_port_mtx); 1523 while (i * sizeof(*l) < sc->sc_mbox[1]) { 1524 u_int16_t loopid; 1525 u_int32_t loc; 1526 1527 loopid = letoh16(l[i].loop_id); 1528 /* skip special ports */ 1529 switch (loopid) { 1530 case QLA_F_PORT_HANDLE: 1531 case QLA_SNS_HANDLE: 1532 case QLA_FABRIC_CTRL_HANDLE: 1533 loc = 0; 1534 break; 1535 default: 1536 if (loopid <= sc->sc_loop_max_id) { 1537 loc = QLA_LOCATION_LOOP_ID(loopid); 1538 } else { 1539 /* 1540 * we don't have the port id here, so just 1541 * indicate it's a fabric port. 1542 */ 1543 loc = QLA_LOCATION_FABRIC; 1544 } 1545 } 1546 1547 if (match & loc) { 1548 port = malloc(sizeof(*port), M_DEVBUF, M_ZERO | 1549 M_NOWAIT); 1550 if (port == NULL) { 1551 printf("%s: failed to allocate port struct\n", 1552 DEVNAME(sc)); 1553 break; 1554 } 1555 port->location = loc; 1556 port->loopid = loopid; 1557 port->port_name = letoh64(l[i].port_name); 1558 DPRINTF(QLA_D_PORT, "%s: loop id %d, port name %llx\n", 1559 DEVNAME(sc), port->loopid, port->port_name); 1560 TAILQ_INSERT_TAIL(&sc->sc_ports_found, port, update); 1561 } 1562 i++; 1563 } 1564 mtx_leave(&sc->sc_port_mtx); 1565 1566 return (0); 1567 } 1568 1569 struct qla_fc_port * 1570 qla_next_fabric_port(struct qla_softc *sc, u_int32_t *firstport, 1571 u_int32_t *lastport) 1572 { 1573 struct qla_sns_ga_nxt *ga; 1574 struct qla_sns_ga_nxt_resp *gar; 1575 struct qla_fc_port *fport; 1576 int result; 1577 1578 /* get the next port from the fabric nameserver */ 1579 ga = QLA_DMA_KVA(sc->sc_scratch); 1580 memset(ga, 0, sizeof(*ga) + sizeof(*gar)); 1581 ga->subcmd = htole16(QLA_SNS_GA_NXT); 1582 ga->max_word = htole16(sizeof(*gar) / 4); 1583 ga->port_id = htole32(*lastport); 1584 result = qla_sns_req(sc, sc->sc_scratch, sizeof(*ga)); 1585 if (result) { 1586 DPRINTF(QLA_D_PORT, "%s: GA_NXT %06x failed: %x\n", DEVNAME(sc), 1587 *lastport, result); 1588 *lastport = 0xffffffff; 1589 return (NULL); 1590 } 1591 1592 gar = (struct qla_sns_ga_nxt_resp *)(ga + 1); 1593 /* if the response is all zeroes, try again */ 1594 if (gar->port_type_id == 0 && gar->port_name == 0 && 1595 gar->node_name == 0) { 1596 DPRINTF(QLA_D_PORT, "%s: GA_NXT returned junk\n", DEVNAME(sc)); 1597 return (NULL); 1598 } 1599 1600 /* are we back at the start? */ 1601 *lastport = betoh32(gar->port_type_id) & 0xffffff; 1602 if (*lastport == *firstport) { 1603 *lastport = 0xffffffff; 1604 return (NULL); 1605 } 1606 if (*firstport == 0xffffffff) 1607 *firstport = *lastport; 1608 1609 DPRINTF(QLA_D_PORT, "%s: GA_NXT: port id: %06x, wwpn %llx, wwnn %llx\n", 1610 DEVNAME(sc), *lastport, betoh64(gar->port_name), 1611 betoh64(gar->node_name)); 1612 1613 /* don't try to log in to ourselves */ 1614 if (*lastport == sc->sc_port_id) { 1615 return (NULL); 1616 } 1617 1618 fport = malloc(sizeof(*fport), M_DEVBUF, M_ZERO | M_NOWAIT); 1619 if (fport == NULL) { 1620 printf("%s: failed to allocate a port struct\n", 1621 DEVNAME(sc)); 1622 *lastport = 0xffffffff; 1623 return (NULL); 1624 } 1625 fport->port_name = betoh64(gar->port_name); 1626 fport->node_name = betoh64(gar->node_name); 1627 fport->location = QLA_LOCATION_PORT_ID(*lastport); 1628 fport->portid = *lastport; 1629 return (fport); 1630 } 1631 1632 int 1633 qla_fabric_plogi(struct qla_softc *sc, struct qla_fc_port *port) 1634 { 1635 int loopid, mboxin, err; 1636 u_int32_t id; 1637 1638 loopid = 0; 1639 retry: 1640 if (port->loopid == 0) { 1641 mtx_enter(&sc->sc_port_mtx); 1642 loopid = qla_get_loop_id(sc, loopid); 1643 mtx_leave(&sc->sc_port_mtx); 1644 if (loopid == -1) { 1645 DPRINTF(QLA_D_PORT, "%s: ran out of loop ids\n", 1646 DEVNAME(sc)); 1647 return (1); 1648 } 1649 } 1650 1651 mboxin = 0x000f; 1652 sc->sc_mbox[0] = QLA_MBOX_FABRIC_PLOGI; 1653 sc->sc_mbox[2] = (port->portid >> 16) & 0xff; 1654 sc->sc_mbox[3] = port->portid & 0xffff; 1655 if (sc->sc_2k_logins) { 1656 sc->sc_mbox[1] = loopid; 1657 sc->sc_mbox[10] = 0; 1658 mboxin |= (1 << 10); 1659 } else { 1660 sc->sc_mbox[1] = loopid << 8; 1661 } 1662 1663 err = qla_mbox(sc, mboxin); 1664 switch (err) { 1665 case 0: 1666 DPRINTF(QLA_D_PORT, "%s: logged in to %06x as %d\n", 1667 DEVNAME(sc), port->portid, loopid); 1668 port->flags &= ~QLA_PORT_FLAG_NEEDS_LOGIN; 1669 port->loopid = loopid; 1670 return (0); 1671 1672 case QLA_MBOX_PORT_USED: 1673 DPRINTF(QLA_D_PORT, "%s: already logged in to %06x as %d\n", 1674 DEVNAME(sc), port->portid, sc->sc_mbox[1]); 1675 port->flags &= ~QLA_PORT_FLAG_NEEDS_LOGIN; 1676 port->loopid = sc->sc_mbox[1]; 1677 return (0); 1678 1679 case QLA_MBOX_LOOP_USED: 1680 id = (sc->sc_mbox[1] << 16) | sc->sc_mbox[2]; 1681 if (qla_add_logged_in_port(sc, loopid, id)) { 1682 return (1); 1683 } 1684 port->loopid = 0; 1685 loopid++; 1686 goto retry; 1687 1688 default: 1689 DPRINTF(QLA_D_PORT, "%s: error %x logging in to port %06x\n", 1690 DEVNAME(sc), err, port->portid); 1691 port->loopid = 0; 1692 return (1); 1693 } 1694 } 1695 1696 void 1697 qla_fabric_plogo(struct qla_softc *sc, struct qla_fc_port *port) 1698 { 1699 int mboxin = 0x0003; 1700 sc->sc_mbox[0] = QLA_MBOX_FABRIC_PLOGO; 1701 if (sc->sc_2k_logins) { 1702 sc->sc_mbox[1] = port->loopid; 1703 sc->sc_mbox[10] = 0; 1704 mboxin |= (1 << 10); 1705 } else { 1706 sc->sc_mbox[1] = port->loopid << 8; 1707 } 1708 1709 if (qla_mbox(sc, mboxin)) 1710 DPRINTF(QLA_D_PORT, "%s: loop id %d logout failed\n", 1711 DEVNAME(sc), port->loopid); 1712 } 1713 1714 void 1715 qla_update_done(struct qla_softc *sc, int task) 1716 { 1717 atomic_clearbits_int(&sc->sc_update_tasks, task); 1718 } 1719 1720 void 1721 qla_update_start(struct qla_softc *sc, int task) 1722 { 1723 atomic_setbits_int(&sc->sc_update_tasks, task); 1724 task_add(sc->sc_update_taskq, &sc->sc_update_task); 1725 } 1726 1727 void 1728 qla_clear_port_lists(struct qla_softc *sc) 1729 { 1730 struct qla_fc_port *p; 1731 1732 while (!TAILQ_EMPTY(&sc->sc_ports_found)) { 1733 p = TAILQ_FIRST(&sc->sc_ports_found); 1734 TAILQ_REMOVE(&sc->sc_ports_found, p, update); 1735 free(p, M_DEVBUF, sizeof *p); 1736 } 1737 1738 while (!TAILQ_EMPTY(&sc->sc_ports_new)) { 1739 p = TAILQ_FIRST(&sc->sc_ports_new); 1740 TAILQ_REMOVE(&sc->sc_ports_new, p, update); 1741 free(p, M_DEVBUF, sizeof *p); 1742 } 1743 1744 while (!TAILQ_EMPTY(&sc->sc_ports_gone)) { 1745 p = TAILQ_FIRST(&sc->sc_ports_gone); 1746 TAILQ_REMOVE(&sc->sc_ports_gone, p, update); 1747 } 1748 } 1749 1750 void 1751 qla_do_update(void *xsc) 1752 { 1753 struct qla_softc *sc = xsc; 1754 int firstport, lastport; 1755 struct qla_fc_port *port, *fport; 1756 1757 DPRINTF(QLA_D_PORT, "%s: updating\n", DEVNAME(sc)); 1758 while (sc->sc_update_tasks != 0) { 1759 if (sc->sc_update_tasks & QLA_UPDATE_TASK_CLEAR_ALL) { 1760 TAILQ_HEAD(, qla_fc_port) detach; 1761 DPRINTF(QLA_D_PORT, "%s: detaching everything\n", 1762 DEVNAME(sc)); 1763 1764 mtx_enter(&sc->sc_port_mtx); 1765 qla_clear_port_lists(sc); 1766 TAILQ_INIT(&detach); 1767 while (!TAILQ_EMPTY(&sc->sc_ports)) { 1768 port = TAILQ_FIRST(&sc->sc_ports); 1769 TAILQ_REMOVE(&sc->sc_ports, port, ports); 1770 TAILQ_INSERT_TAIL(&detach, port, ports); 1771 } 1772 mtx_leave(&sc->sc_port_mtx); 1773 1774 while (!TAILQ_EMPTY(&detach)) { 1775 port = TAILQ_FIRST(&detach); 1776 TAILQ_REMOVE(&detach, port, ports); 1777 if (port->flags & QLA_PORT_FLAG_IS_TARGET) { 1778 scsi_detach_target(sc->sc_scsibus, 1779 port->loopid, -1); 1780 } 1781 sc->sc_targets[port->loopid] = NULL; 1782 if (port->location & QLA_LOCATION_FABRIC) 1783 qla_fabric_plogo(sc, port); 1784 1785 free(port, M_DEVBUF, sizeof *port); 1786 } 1787 1788 qla_update_done(sc, QLA_UPDATE_TASK_CLEAR_ALL); 1789 continue; 1790 } 1791 1792 if (sc->sc_update_tasks & QLA_UPDATE_TASK_SOFTRESET) { 1793 /* what no */ 1794 qla_update_done(sc, QLA_UPDATE_TASK_SOFTRESET); 1795 continue; 1796 } 1797 1798 if (sc->sc_update_tasks & QLA_UPDATE_TASK_UPDATE_TOPO) { 1799 DPRINTF(QLA_D_PORT, "%s: updating topology\n", 1800 DEVNAME(sc)); 1801 qla_update_topology(sc); 1802 qla_update_done(sc, QLA_UPDATE_TASK_UPDATE_TOPO); 1803 continue; 1804 } 1805 1806 if (sc->sc_update_tasks & QLA_UPDATE_TASK_GET_PORT_LIST) { 1807 DPRINTF(QLA_D_PORT, "%s: getting port name list\n", 1808 DEVNAME(sc)); 1809 mtx_enter(&sc->sc_port_mtx); 1810 qla_clear_port_lists(sc); 1811 mtx_leave(&sc->sc_port_mtx); 1812 1813 qla_get_port_name_list(sc, QLA_LOCATION_LOOP | 1814 QLA_LOCATION_FABRIC); 1815 mtx_enter(&sc->sc_port_mtx); 1816 TAILQ_FOREACH(port, &sc->sc_ports, ports) { 1817 TAILQ_INSERT_TAIL(&sc->sc_ports_gone, port, 1818 update); 1819 if (port->location & QLA_LOCATION_FABRIC) { 1820 port->flags |= 1821 QLA_PORT_FLAG_NEEDS_LOGIN; 1822 } 1823 } 1824 1825 /* take care of ports that haven't changed first */ 1826 TAILQ_FOREACH(fport, &sc->sc_ports_found, update) { 1827 port = sc->sc_targets[fport->loopid]; 1828 if (port == NULL || fport->port_name != 1829 port->port_name) { 1830 /* new or changed port, handled later */ 1831 continue; 1832 } 1833 1834 /* 1835 * the port hasn't been logged out, which 1836 * means we don't need to log in again, and, 1837 * for loop ports, that the port still exists. 1838 */ 1839 port->flags &= ~QLA_PORT_FLAG_NEEDS_LOGIN; 1840 if (port->location & QLA_LOCATION_LOOP) 1841 TAILQ_REMOVE(&sc->sc_ports_gone, 1842 port, update); 1843 1844 fport->location = 0; 1845 } 1846 mtx_leave(&sc->sc_port_mtx); 1847 qla_update_start(sc, QLA_UPDATE_TASK_PORT_LIST); 1848 qla_update_done(sc, QLA_UPDATE_TASK_GET_PORT_LIST); 1849 continue; 1850 } 1851 1852 if (sc->sc_update_tasks & QLA_UPDATE_TASK_PORT_LIST) { 1853 mtx_enter(&sc->sc_port_mtx); 1854 fport = TAILQ_FIRST(&sc->sc_ports_found); 1855 if (fport != NULL) { 1856 TAILQ_REMOVE(&sc->sc_ports_found, fport, 1857 update); 1858 } 1859 mtx_leave(&sc->sc_port_mtx); 1860 1861 if (fport == NULL) { 1862 DPRINTF(QLA_D_PORT, "%s: done with ports\n", 1863 DEVNAME(sc)); 1864 qla_update_done(sc, 1865 QLA_UPDATE_TASK_PORT_LIST); 1866 qla_update_start(sc, 1867 QLA_UPDATE_TASK_SCAN_FABRIC); 1868 } else if (fport->location & QLA_LOCATION_LOOP) { 1869 DPRINTF(QLA_D_PORT, "%s: loop port %d\n", 1870 DEVNAME(sc), fport->loopid); 1871 if (qla_add_loop_port(sc, fport) != 0) 1872 free(fport, M_DEVBUF, sizeof *fport); 1873 } else if (fport->location & QLA_LOCATION_FABRIC) { 1874 qla_add_fabric_port(sc, fport); 1875 } else { 1876 /* already processed */ 1877 free(fport, M_DEVBUF, sizeof *fport); 1878 } 1879 continue; 1880 } 1881 1882 if (sc->sc_update_tasks & QLA_UPDATE_TASK_SCAN_FABRIC) { 1883 DPRINTF(QLA_D_PORT, "%s: starting fabric scan\n", 1884 DEVNAME(sc)); 1885 lastport = sc->sc_port_id; 1886 firstport = 0xffffffff; 1887 if (qla_update_fabric(sc)) 1888 qla_update_start(sc, 1889 QLA_UPDATE_TASK_SCANNING_FABRIC); 1890 qla_update_done(sc, QLA_UPDATE_TASK_SCAN_FABRIC); 1891 continue; 1892 } 1893 1894 if (sc->sc_update_tasks & QLA_UPDATE_TASK_SCANNING_FABRIC) { 1895 fport = qla_next_fabric_port(sc, &firstport, &lastport); 1896 if (fport != NULL) { 1897 int disp; 1898 1899 mtx_enter(&sc->sc_port_mtx); 1900 disp = qla_classify_port(sc, fport->location, 1901 fport->port_name, fport->node_name, &port); 1902 switch (disp) { 1903 case QLA_PORT_DISP_CHANGED: 1904 case QLA_PORT_DISP_MOVED: 1905 /* we'll log out the old port later */ 1906 case QLA_PORT_DISP_NEW: 1907 DPRINTF(QLA_D_PORT, "%s: new port " 1908 "%06x\n", DEVNAME(sc), 1909 fport->portid); 1910 TAILQ_INSERT_TAIL(&sc->sc_ports_found, 1911 fport, update); 1912 break; 1913 case QLA_PORT_DISP_DUP: 1914 free(fport, M_DEVBUF, sizeof *fport); 1915 break; 1916 case QLA_PORT_DISP_SAME: 1917 DPRINTF(QLA_D_PORT, "%s: existing port" 1918 " %06x\n", DEVNAME(sc), 1919 fport->portid); 1920 TAILQ_REMOVE(&sc->sc_ports_gone, port, 1921 update); 1922 free(fport, M_DEVBUF, sizeof *fport); 1923 break; 1924 } 1925 mtx_leave(&sc->sc_port_mtx); 1926 } 1927 if (lastport == 0xffffffff) { 1928 DPRINTF(QLA_D_PORT, "%s: finished\n", 1929 DEVNAME(sc)); 1930 qla_update_done(sc, 1931 QLA_UPDATE_TASK_SCANNING_FABRIC); 1932 qla_update_start(sc, 1933 QLA_UPDATE_TASK_FABRIC_LOGIN); 1934 } 1935 continue; 1936 } 1937 1938 if (sc->sc_update_tasks & QLA_UPDATE_TASK_FABRIC_LOGIN) { 1939 mtx_enter(&sc->sc_port_mtx); 1940 port = TAILQ_FIRST(&sc->sc_ports_found); 1941 if (port != NULL) { 1942 TAILQ_REMOVE(&sc->sc_ports_found, port, update); 1943 } 1944 mtx_leave(&sc->sc_port_mtx); 1945 1946 if (port != NULL) { 1947 DPRINTF(QLA_D_PORT, "%s: found port %06x\n", 1948 DEVNAME(sc), port->portid); 1949 if (qla_fabric_plogi(sc, port) == 0) { 1950 qla_add_fabric_port(sc, port); 1951 } else { 1952 free(port, M_DEVBUF, sizeof *port); 1953 } 1954 } else { 1955 DPRINTF(QLA_D_PORT, "%s: done with logins\n", 1956 DEVNAME(sc)); 1957 qla_update_done(sc, 1958 QLA_UPDATE_TASK_FABRIC_LOGIN); 1959 qla_update_start(sc, 1960 QLA_UPDATE_TASK_ATTACH_TARGET | 1961 QLA_UPDATE_TASK_DETACH_TARGET); 1962 } 1963 continue; 1964 } 1965 1966 if (sc->sc_update_tasks & QLA_UPDATE_TASK_FABRIC_RELOGIN) { 1967 TAILQ_FOREACH(port, &sc->sc_ports, ports) { 1968 if (port->flags & QLA_PORT_FLAG_NEEDS_LOGIN) { 1969 qla_fabric_plogi(sc, port); 1970 break; 1971 } 1972 } 1973 1974 if (port == NULL) 1975 qla_update_done(sc, 1976 QLA_UPDATE_TASK_FABRIC_RELOGIN); 1977 continue; 1978 } 1979 1980 if (sc->sc_update_tasks & QLA_UPDATE_TASK_DETACH_TARGET) { 1981 mtx_enter(&sc->sc_port_mtx); 1982 port = TAILQ_FIRST(&sc->sc_ports_gone); 1983 if (port != NULL) { 1984 sc->sc_targets[port->loopid] = NULL; 1985 TAILQ_REMOVE(&sc->sc_ports_gone, port, update); 1986 TAILQ_REMOVE(&sc->sc_ports, port, ports); 1987 } 1988 mtx_leave(&sc->sc_port_mtx); 1989 1990 if (port != NULL) { 1991 DPRINTF(QLA_D_PORT, "%s: detaching target %d\n", 1992 DEVNAME(sc), port->loopid); 1993 if (sc->sc_scsibus != NULL) 1994 scsi_detach_target(sc->sc_scsibus, 1995 port->loopid, -1); 1996 1997 if (port->location & QLA_LOCATION_FABRIC) 1998 qla_fabric_plogo(sc, port); 1999 2000 free(port, M_DEVBUF, sizeof *port); 2001 } else { 2002 qla_update_done(sc, 2003 QLA_UPDATE_TASK_DETACH_TARGET); 2004 } 2005 continue; 2006 } 2007 2008 if (sc->sc_update_tasks & QLA_UPDATE_TASK_ATTACH_TARGET) { 2009 mtx_enter(&sc->sc_port_mtx); 2010 port = TAILQ_FIRST(&sc->sc_ports_new); 2011 if (port != NULL) { 2012 TAILQ_REMOVE(&sc->sc_ports_new, port, update); 2013 TAILQ_INSERT_TAIL(&sc->sc_ports, port, ports); 2014 } 2015 mtx_leave(&sc->sc_port_mtx); 2016 2017 if (port != NULL) { 2018 if (sc->sc_scsibus != NULL) 2019 scsi_probe_target(sc->sc_scsibus, 2020 port->loopid); 2021 } else { 2022 qla_update_done(sc, 2023 QLA_UPDATE_TASK_ATTACH_TARGET); 2024 } 2025 continue; 2026 } 2027 2028 } 2029 2030 DPRINTF(QLA_D_PORT, "%s: done updating\n", DEVNAME(sc)); 2031 } 2032 2033 int 2034 qla_async(struct qla_softc *sc, u_int16_t info) 2035 { 2036 u_int16_t id, exp; 2037 2038 switch (info) { 2039 case QLA_ASYNC_SYSTEM_ERROR: 2040 qla_update_start(sc, QLA_UPDATE_TASK_SOFTRESET); 2041 break; 2042 2043 case QLA_ASYNC_REQ_XFER_ERROR: 2044 qla_update_start(sc, QLA_UPDATE_TASK_SOFTRESET); 2045 break; 2046 2047 case QLA_ASYNC_RSP_XFER_ERROR: 2048 qla_update_start(sc, QLA_UPDATE_TASK_SOFTRESET); 2049 break; 2050 2051 case QLA_ASYNC_LIP_OCCURRED: 2052 DPRINTF(QLA_D_PORT, "%s: lip occurred\n", DEVNAME(sc)); 2053 break; 2054 2055 case QLA_ASYNC_LOOP_UP: 2056 DPRINTF(QLA_D_PORT, "%s: loop up\n", DEVNAME(sc)); 2057 sc->sc_loop_up = 1; 2058 sc->sc_marker_required = 1; 2059 qla_update_start(sc, QLA_UPDATE_TASK_UPDATE_TOPO | 2060 QLA_UPDATE_TASK_GET_PORT_LIST); 2061 break; 2062 2063 case QLA_ASYNC_LOOP_DOWN: 2064 DPRINTF(QLA_D_PORT, "%s: loop down\n", DEVNAME(sc)); 2065 sc->sc_loop_up = 0; 2066 qla_update_start(sc, QLA_UPDATE_TASK_CLEAR_ALL); 2067 break; 2068 2069 case QLA_ASYNC_LIP_RESET: 2070 DPRINTF(QLA_D_PORT, "%s: lip reset\n", DEVNAME(sc)); 2071 sc->sc_marker_required = 1; 2072 qla_update_start(sc, QLA_UPDATE_TASK_FABRIC_RELOGIN); 2073 break; 2074 2075 case QLA_ASYNC_PORT_DB_CHANGE: 2076 DPRINTF(QLA_D_PORT, "%s: port db changed %x\n", DEVNAME(sc), 2077 qla_read_mbox(sc, 1)); 2078 qla_update_start(sc, QLA_UPDATE_TASK_GET_PORT_LIST); 2079 break; 2080 2081 case QLA_ASYNC_CHANGE_NOTIFY: 2082 DPRINTF(QLA_D_PORT, "%s: name server change (%02x:%02x)\n", 2083 DEVNAME(sc), qla_read_mbox(sc, 1), qla_read_mbox(sc, 2)); 2084 qla_update_start(sc, QLA_UPDATE_TASK_GET_PORT_LIST); 2085 break; 2086 2087 case QLA_ASYNC_LIP_F8: 2088 DPRINTF(QLA_D_PORT, "%s: lip f8\n", DEVNAME(sc)); 2089 break; 2090 2091 case QLA_ASYNC_LOOP_INIT_ERROR: 2092 DPRINTF(QLA_D_PORT, "%s: loop initialization error: %x\n", 2093 DEVNAME(sc), qla_read_mbox(sc, 1)); 2094 break; 2095 2096 case QLA_ASYNC_LOGIN_REJECT: 2097 id = qla_read_mbox(sc, 1); 2098 exp = qla_read_mbox(sc, 2); 2099 DPRINTF(QLA_D_PORT, "%s: login reject from %x (reason %d," 2100 " explanation %x)\n", DEVNAME(sc), id >> 8, id & 0xff, exp); 2101 break; 2102 2103 case QLA_ASYNC_SCSI_CMD_COMPLETE: 2104 /* shouldn't happen, we disable fast posting */ 2105 break; 2106 2107 case QLA_ASYNC_CTIO_COMPLETE: 2108 /* definitely shouldn't happen, we don't do target mode */ 2109 break; 2110 2111 case QLA_ASYNC_POINT_TO_POINT: 2112 DPRINTF(QLA_D_PORT, "%s: connected in point-to-point mode\n", 2113 DEVNAME(sc)); 2114 /* we get stuck handling these if we have the wrong loop 2115 * topology; should somehow reinit with different things 2116 * somehow. 2117 */ 2118 break; 2119 2120 case QLA_ASYNC_ZIO_RESP_UPDATE: 2121 /* shouldn't happen, we don't do zio */ 2122 break; 2123 2124 case QLA_ASYNC_RND_ERROR: 2125 /* do nothing? */ 2126 break; 2127 2128 case QLA_ASYNC_QUEUE_FULL: 2129 break; 2130 2131 default: 2132 DPRINTF(QLA_D_INTR, "%s: unknown async %x\n", DEVNAME(sc), 2133 info); 2134 break; 2135 } 2136 return (1); 2137 } 2138 2139 void 2140 qla_dump_iocb(struct qla_softc *sc, void *buf) 2141 { 2142 #ifdef QLA_DEBUG 2143 u_int8_t *iocb = buf; 2144 int l; 2145 int b; 2146 2147 if ((qladebug & QLA_D_IOCB) == 0) 2148 return; 2149 2150 printf("%s: iocb:\n", DEVNAME(sc)); 2151 for (l = 0; l < 4; l++) { 2152 for (b = 0; b < 16; b++) { 2153 printf(" %2.2x", iocb[(l*16)+b]); 2154 } 2155 printf("\n"); 2156 } 2157 #endif 2158 } 2159 2160 void 2161 qla_dump_iocb_segs(struct qla_softc *sc, void *segs, int n) 2162 { 2163 #ifdef QLA_DEBUG 2164 u_int8_t *buf = segs; 2165 int s, b; 2166 if ((qladebug & QLA_D_IOCB) == 0) 2167 return; 2168 2169 printf("%s: iocb segs:\n", DEVNAME(sc)); 2170 for (s = 0; s < n; s++) { 2171 for (b = 0; b < sizeof(struct qla_iocb_seg); b++) { 2172 printf(" %2.2x", buf[(s*(sizeof(struct qla_iocb_seg))) 2173 + b]); 2174 } 2175 printf("\n"); 2176 } 2177 #endif 2178 } 2179 2180 void 2181 qla_put_marker(struct qla_softc *sc, void *buf) 2182 { 2183 struct qla_iocb_marker *marker = buf; 2184 2185 marker->entry_type = QLA_IOCB_MARKER; 2186 marker->entry_count = 1; 2187 marker->seqno = 0; 2188 marker->flags = 0; 2189 2190 /* could be more specific here; isp(4) isn't */ 2191 marker->target = 0; 2192 marker->modifier = QLA_IOCB_MARKER_SYNC_ALL; 2193 qla_dump_iocb(sc, buf); 2194 } 2195 2196 static inline void 2197 qla_put_data_seg(struct qla_iocb_seg *seg, bus_dmamap_t dmap, int num) 2198 { 2199 uint64_t addr = dmap->dm_segs[num].ds_addr; 2200 2201 htolem32(&seg->seg_addr_lo, addr); 2202 htolem32(&seg->seg_addr_hi, addr >> 32); 2203 htolem32(&seg->seg_len, dmap->dm_segs[num].ds_len); 2204 } 2205 2206 void 2207 qla_put_cmd(struct qla_softc *sc, void *buf, struct scsi_xfer *xs, 2208 struct qla_ccb *ccb) 2209 { 2210 struct qla_iocb_req34 *req = buf; 2211 u_int16_t dir; 2212 int seg; 2213 int target = xs->sc_link->target; 2214 2215 req->seqno = 0; 2216 req->flags = 0; 2217 req->entry_count = 1; 2218 2219 if (xs->datalen == 0) { 2220 dir = QLA_IOCB_CMD_NO_DATA; 2221 req->req_seg_count = 0; 2222 req->entry_type = QLA_IOCB_CMD_TYPE_3; 2223 } else { 2224 dir = xs->flags & SCSI_DATA_IN ? QLA_IOCB_CMD_READ_DATA : 2225 QLA_IOCB_CMD_WRITE_DATA; 2226 htolem16(&req->req_seg_count, ccb->ccb_dmamap->dm_nsegs); 2227 if (ccb->ccb_dmamap->dm_nsegs > QLA_IOCB_SEGS_PER_CMD) { 2228 req->entry_type = QLA_IOCB_CMD_TYPE_4; 2229 for (seg = 0; seg < ccb->ccb_dmamap->dm_nsegs; seg++) { 2230 qla_put_data_seg(&ccb->ccb_t4segs[seg], 2231 ccb->ccb_dmamap, seg); 2232 } 2233 req->req_type.req4.req4_seg_type = htole16(1); 2234 req->req_type.req4.req4_seg_base = 0; 2235 req->req_type.req4.req4_seg_addr = ccb->ccb_seg_dva; 2236 memset(req->req_type.req4.req4_reserved, 0, 2237 sizeof(req->req_type.req4.req4_reserved)); 2238 bus_dmamap_sync(sc->sc_dmat, 2239 QLA_DMA_MAP(sc->sc_segments), ccb->ccb_seg_offset, 2240 sizeof(*ccb->ccb_t4segs) * ccb->ccb_dmamap->dm_nsegs, 2241 BUS_DMASYNC_PREWRITE); 2242 } else { 2243 req->entry_type = QLA_IOCB_CMD_TYPE_3; 2244 for (seg = 0; seg < ccb->ccb_dmamap->dm_nsegs; seg++) { 2245 qla_put_data_seg(&req->req_type.req3_segs[seg], 2246 ccb->ccb_dmamap, seg); 2247 } 2248 } 2249 } 2250 2251 /* isp(4) uses head of queue for 'request sense' commands */ 2252 htolem16(&req->req_flags, QLA_IOCB_CMD_SIMPLE_QUEUE | dir); 2253 2254 /* 2255 * timeout is in seconds. make sure it's at least 1 if a timeout 2256 * was specified in xs 2257 */ 2258 if (xs->timeout != 0) 2259 htolem16(&req->req_time, MAX(1, xs->timeout/1000)); 2260 2261 /* lun and target layout vary with firmware attributes */ 2262 if (sc->sc_expanded_lun) { 2263 if (sc->sc_2k_logins) { 2264 req->req_target = htole16(target); 2265 } else { 2266 req->req_target = htole16(target << 8); 2267 } 2268 req->req_scclun = htole16(xs->sc_link->lun); 2269 } else { 2270 req->req_target = htole16(target << 8 | xs->sc_link->lun); 2271 } 2272 memcpy(req->req_cdb, xs->cmd, xs->cmdlen); 2273 req->req_totalcnt = htole32(xs->datalen); 2274 2275 req->req_handle = ccb->ccb_id; 2276 2277 qla_dump_iocb(sc, buf); 2278 } 2279 2280 int 2281 qla_verify_firmware(struct qla_softc *sc, u_int16_t addr) 2282 { 2283 sc->sc_mbox[0] = QLA_MBOX_VERIFY_CSUM; 2284 sc->sc_mbox[1] = addr; 2285 return (qla_mbox(sc, 0x0003)); 2286 } 2287 2288 #ifndef ISP_NOFIRMWARE 2289 int 2290 qla_load_firmware_words(struct qla_softc *sc, const u_int16_t *src, 2291 u_int16_t dest) 2292 { 2293 u_int16_t i; 2294 2295 for (i = 0; i < src[3]; i++) { 2296 sc->sc_mbox[0] = QLA_MBOX_WRITE_RAM_WORD; 2297 sc->sc_mbox[1] = i + dest; 2298 sc->sc_mbox[2] = src[i]; 2299 if (qla_mbox(sc, 0x07)) { 2300 printf("firmware load failed\n"); 2301 return (1); 2302 } 2303 } 2304 2305 return (qla_verify_firmware(sc, dest)); 2306 } 2307 2308 int 2309 qla_load_firmware_2100(struct qla_softc *sc) 2310 { 2311 return qla_load_firmware_words(sc, isp_2100_risc_code, 2312 QLA_2100_CODE_ORG); 2313 } 2314 2315 int 2316 qla_load_firmware_2200(struct qla_softc *sc) 2317 { 2318 return qla_load_firmware_words(sc, isp_2200_risc_code, 2319 QLA_2200_CODE_ORG); 2320 } 2321 2322 int 2323 qla_load_fwchunk_2300(struct qla_softc *sc, struct qla_dmamem *mem, 2324 const u_int16_t *src, u_int32_t dest) 2325 { 2326 u_int16_t origin, done, total; 2327 int i; 2328 2329 origin = dest; 2330 done = 0; 2331 total = src[3]; 2332 2333 while (done < total) { 2334 u_int16_t *copy; 2335 u_int32_t words; 2336 2337 /* limit transfer size otherwise it just doesn't work */ 2338 words = MIN(total - done, 1 << 10); 2339 copy = QLA_DMA_KVA(mem); 2340 for (i = 0; i < words; i++) { 2341 copy[i] = htole16(src[done++]); 2342 } 2343 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, words * 2, 2344 BUS_DMASYNC_PREWRITE); 2345 2346 sc->sc_mbox[0] = QLA_MBOX_LOAD_RAM_EXT; 2347 sc->sc_mbox[1] = dest; 2348 sc->sc_mbox[4] = words; 2349 sc->sc_mbox[8] = dest >> 16; 2350 qla_mbox_putaddr(sc->sc_mbox, mem); 2351 if (qla_mbox(sc, 0x01ff)) { 2352 printf("firmware load failed\n"); 2353 return (1); 2354 } 2355 bus_dmamap_sync(sc->sc_dmat, QLA_DMA_MAP(mem), 0, words * 2, 2356 BUS_DMASYNC_POSTWRITE); 2357 2358 dest += words; 2359 } 2360 2361 return (qla_verify_firmware(sc, origin)); 2362 } 2363 2364 int 2365 qla_load_firmware_2300(struct qla_softc *sc) 2366 { 2367 struct qla_dmamem *mem; 2368 const u_int16_t *fw = isp_2300_risc_code; 2369 int rv; 2370 2371 mem = qla_dmamem_alloc(sc, 65536); 2372 rv = qla_load_fwchunk_2300(sc, mem, fw, QLA_2300_CODE_ORG); 2373 qla_dmamem_free(sc, mem); 2374 2375 return (rv); 2376 } 2377 2378 int 2379 qla_load_firmware_2322(struct qla_softc *sc) 2380 { 2381 /* we don't have the 2322 firmware image yet */ 2382 #if 0 2383 struct qla_dmamem *mem; 2384 const u_int16_t *fw = isp_2322_risc_code; 2385 u_int32_t addr; 2386 int i; 2387 2388 mem = qla_dmamem_alloc(sc, 65536); 2389 if (qla_load_fwchunk_2300(sc, mem, fw, QLA_2300_CODE_ORG)) { 2390 qla_dmamem_free(sc, mem); 2391 return (1); 2392 } 2393 2394 for (i = 0; i < 2; i++) { 2395 fw += fw[3]; 2396 addr = fw[5] | ((fw[4] & 0x3f) << 16); 2397 if (qla_load_fwchunk_2300(sc, mem, fw, addr)) { 2398 qla_dmamem_free(sc, mem); 2399 return (1); 2400 } 2401 } 2402 2403 qla_dmamem_free(sc, mem); 2404 #endif 2405 return (0); 2406 } 2407 2408 #endif /* !ISP_NOFIRMWARE */ 2409 2410 int 2411 qla_read_nvram(struct qla_softc *sc) 2412 { 2413 u_int16_t data[sizeof(sc->sc_nvram) >> 1]; 2414 u_int16_t req, cmd, val; 2415 u_int8_t csum; 2416 int i, base, bit; 2417 2418 base = sc->sc_port * 0x80; 2419 2420 qla_write(sc, QLA_NVRAM, QLA_NVRAM_CHIP_SEL); 2421 delay(10); 2422 qla_write(sc, QLA_NVRAM, QLA_NVRAM_CHIP_SEL | QLA_NVRAM_CLOCK); 2423 delay(10); 2424 2425 for (i = 0; i < nitems(data); i++) { 2426 req = (i + base) | (QLA_NVRAM_CMD_READ << 8); 2427 2428 /* write each bit out through the nvram register */ 2429 for (bit = 10; bit >= 0; bit--) { 2430 cmd = QLA_NVRAM_CHIP_SEL; 2431 if ((req >> bit) & 1) { 2432 cmd |= QLA_NVRAM_DATA_OUT; 2433 } 2434 qla_write(sc, QLA_NVRAM, cmd); 2435 delay(10); 2436 qla_read(sc, QLA_NVRAM); 2437 2438 qla_write(sc, QLA_NVRAM, cmd | QLA_NVRAM_CLOCK); 2439 delay(10); 2440 qla_read(sc, QLA_NVRAM); 2441 2442 qla_write(sc, QLA_NVRAM, cmd); 2443 delay(10); 2444 qla_read(sc, QLA_NVRAM); 2445 } 2446 2447 /* read the result back */ 2448 val = 0; 2449 for (bit = 0; bit < 16; bit++) { 2450 val <<= 1; 2451 qla_write(sc, QLA_NVRAM, QLA_NVRAM_CHIP_SEL | 2452 QLA_NVRAM_CLOCK); 2453 delay(10); 2454 if (qla_read(sc, QLA_NVRAM) & QLA_NVRAM_DATA_IN) 2455 val |= 1; 2456 delay(10); 2457 2458 qla_write(sc, QLA_NVRAM, QLA_NVRAM_CHIP_SEL); 2459 delay(10); 2460 qla_read(sc, QLA_NVRAM); 2461 } 2462 2463 qla_write(sc, QLA_NVRAM, 0); 2464 delay(10); 2465 qla_read(sc, QLA_NVRAM); 2466 2467 data[i] = letoh16(val); 2468 } 2469 2470 csum = 0; 2471 for (i = 0; i < nitems(data); i++) { 2472 csum += data[i] & 0xff; 2473 csum += data[i] >> 8; 2474 } 2475 2476 memcpy(&sc->sc_nvram, data, sizeof(sc->sc_nvram)); 2477 /* id field should be 'ISP ', version should be at least 1 */ 2478 if (sc->sc_nvram.id[0] != 'I' || sc->sc_nvram.id[1] != 'S' || 2479 sc->sc_nvram.id[2] != 'P' || sc->sc_nvram.id[3] != ' ' || 2480 sc->sc_nvram.nvram_version < 1 || (csum != 0)) { 2481 /* 2482 * onboard 2200s on Sun hardware don't have an nvram 2483 * fitted, but will provide us with node and port name 2484 * through Open Firmware; don't complain in that case. 2485 */ 2486 if (sc->sc_node_name == 0 || sc->sc_port_name == 0) 2487 printf("%s: nvram corrupt\n", DEVNAME(sc)); 2488 return (1); 2489 } 2490 return (0); 2491 } 2492 2493 struct qla_dmamem * 2494 qla_dmamem_alloc(struct qla_softc *sc, size_t size) 2495 { 2496 struct qla_dmamem *m; 2497 int nsegs; 2498 2499 m = malloc(sizeof(*m), M_DEVBUF, M_NOWAIT | M_ZERO); 2500 if (m == NULL) 2501 return (NULL); 2502 2503 m->qdm_size = size; 2504 2505 if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0, 2506 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &m->qdm_map) != 0) 2507 goto qdmfree; 2508 2509 if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &m->qdm_seg, 1, 2510 &nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO) != 0) 2511 goto destroy; 2512 2513 if (bus_dmamem_map(sc->sc_dmat, &m->qdm_seg, nsegs, size, &m->qdm_kva, 2514 BUS_DMA_NOWAIT) != 0) 2515 goto free; 2516 2517 if (bus_dmamap_load(sc->sc_dmat, m->qdm_map, m->qdm_kva, size, NULL, 2518 BUS_DMA_NOWAIT) != 0) 2519 goto unmap; 2520 2521 return (m); 2522 2523 unmap: 2524 bus_dmamem_unmap(sc->sc_dmat, m->qdm_kva, m->qdm_size); 2525 free: 2526 bus_dmamem_free(sc->sc_dmat, &m->qdm_seg, 1); 2527 destroy: 2528 bus_dmamap_destroy(sc->sc_dmat, m->qdm_map); 2529 qdmfree: 2530 free(m, M_DEVBUF, sizeof(*m)); 2531 2532 return (NULL); 2533 } 2534 2535 void 2536 qla_dmamem_free(struct qla_softc *sc, struct qla_dmamem *m) 2537 { 2538 bus_dmamap_unload(sc->sc_dmat, m->qdm_map); 2539 bus_dmamem_unmap(sc->sc_dmat, m->qdm_kva, m->qdm_size); 2540 bus_dmamem_free(sc->sc_dmat, &m->qdm_seg, 1); 2541 bus_dmamap_destroy(sc->sc_dmat, m->qdm_map); 2542 free(m, M_DEVBUF, sizeof(*m)); 2543 } 2544 2545 int 2546 qla_alloc_ccbs(struct qla_softc *sc) 2547 { 2548 struct qla_ccb *ccb; 2549 u_int8_t *cmd; 2550 int i; 2551 2552 SIMPLEQ_INIT(&sc->sc_ccb_free); 2553 mtx_init(&sc->sc_ccb_mtx, IPL_BIO); 2554 mtx_init(&sc->sc_queue_mtx, IPL_BIO); 2555 mtx_init(&sc->sc_port_mtx, IPL_BIO); 2556 mtx_init(&sc->sc_mbox_mtx, IPL_BIO); 2557 2558 sc->sc_ccbs = mallocarray(sc->sc_maxcmds, sizeof(struct qla_ccb), 2559 M_DEVBUF, M_WAITOK | M_CANFAIL | M_ZERO); 2560 if (sc->sc_ccbs == NULL) { 2561 printf("%s: unable to allocate ccbs\n", DEVNAME(sc)); 2562 return (1); 2563 } 2564 2565 sc->sc_requests = qla_dmamem_alloc(sc, sc->sc_maxcmds * 2566 QLA_QUEUE_ENTRY_SIZE); 2567 if (sc->sc_requests == NULL) { 2568 printf("%s: unable to allocate ccb dmamem\n", DEVNAME(sc)); 2569 goto free_ccbs; 2570 } 2571 sc->sc_responses = qla_dmamem_alloc(sc, sc->sc_maxcmds * 2572 QLA_QUEUE_ENTRY_SIZE); 2573 if (sc->sc_responses == NULL) { 2574 printf("%s: unable to allocate rcb dmamem\n", DEVNAME(sc)); 2575 goto free_req; 2576 } 2577 sc->sc_segments = qla_dmamem_alloc(sc, sc->sc_maxcmds * QLA_MAX_SEGS * 2578 sizeof(struct qla_iocb_seg)); 2579 if (sc->sc_segments == NULL) { 2580 printf("%s: unable to allocate iocb segments\n", DEVNAME(sc)); 2581 goto free_res; 2582 } 2583 2584 cmd = QLA_DMA_KVA(sc->sc_requests); 2585 memset(cmd, 0, QLA_QUEUE_ENTRY_SIZE * sc->sc_maxcmds); 2586 for (i = 0; i < sc->sc_maxcmds; i++) { 2587 ccb = &sc->sc_ccbs[i]; 2588 2589 if (bus_dmamap_create(sc->sc_dmat, MAXPHYS, 2590 QLA_MAX_SEGS, MAXPHYS, 0, 2591 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 2592 &ccb->ccb_dmamap) != 0) { 2593 printf("%s: unable to create dma map\n", DEVNAME(sc)); 2594 goto free_maps; 2595 } 2596 2597 ccb->ccb_sc = sc; 2598 ccb->ccb_id = i; 2599 2600 ccb->ccb_seg_offset = i * QLA_MAX_SEGS * 2601 sizeof(struct qla_iocb_seg); 2602 htolem64(&ccb->ccb_seg_dva, 2603 QLA_DMA_DVA(sc->sc_segments) + ccb->ccb_seg_offset); 2604 ccb->ccb_t4segs = QLA_DMA_KVA(sc->sc_segments) + 2605 ccb->ccb_seg_offset; 2606 2607 qla_put_ccb(sc, ccb); 2608 } 2609 2610 scsi_iopool_init(&sc->sc_iopool, sc, qla_get_ccb, qla_put_ccb); 2611 return (0); 2612 2613 free_maps: 2614 while ((ccb = qla_get_ccb(sc)) != NULL) 2615 bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap); 2616 2617 qla_dmamem_free(sc, sc->sc_segments); 2618 free_res: 2619 qla_dmamem_free(sc, sc->sc_responses); 2620 free_req: 2621 qla_dmamem_free(sc, sc->sc_requests); 2622 free_ccbs: 2623 free(sc->sc_ccbs, M_DEVBUF, 0); 2624 2625 return (1); 2626 } 2627 2628 void 2629 qla_free_ccbs(struct qla_softc *sc) 2630 { 2631 struct qla_ccb *ccb; 2632 2633 scsi_iopool_destroy(&sc->sc_iopool); 2634 while ((ccb = qla_get_ccb(sc)) != NULL) 2635 bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap); 2636 qla_dmamem_free(sc, sc->sc_segments); 2637 qla_dmamem_free(sc, sc->sc_responses); 2638 qla_dmamem_free(sc, sc->sc_requests); 2639 free(sc->sc_ccbs, M_DEVBUF, 0); 2640 } 2641 2642 void * 2643 qla_get_ccb(void *xsc) 2644 { 2645 struct qla_softc *sc = xsc; 2646 struct qla_ccb *ccb; 2647 2648 mtx_enter(&sc->sc_ccb_mtx); 2649 ccb = SIMPLEQ_FIRST(&sc->sc_ccb_free); 2650 if (ccb != NULL) { 2651 SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_free, ccb_link); 2652 } 2653 mtx_leave(&sc->sc_ccb_mtx); 2654 return (ccb); 2655 } 2656 2657 void 2658 qla_put_ccb(void *xsc, void *io) 2659 { 2660 struct qla_softc *sc = xsc; 2661 struct qla_ccb *ccb = io; 2662 2663 ccb->ccb_xs = NULL; 2664 mtx_enter(&sc->sc_ccb_mtx); 2665 SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_free, ccb, ccb_link); 2666 mtx_leave(&sc->sc_ccb_mtx); 2667 } 2668