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