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