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